






"""simple docstring"""
import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
			import tensorflow as tf

			tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
			import torch

if is_datasets_available():
			from datasets import load_dataset


lowerCAmelCase__							= 5E-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors





def 							lowercase__		(				lowerCamelCase					):
				return PTtoTFCommand(
				    args.model_name,	args.local_dir,	args.max_error,	args.new_weights,	args.no_pr,	args.push,	args.extra_commit_description,	args.override_model_class,	)






class _lowerCAmelCase	(						UpperCAmelCase_					):







						@staticmethod
						def  A			(						lowerCAmelCase_       )		->       Dict:
										_SCREAMING_SNAKE_CASE      :		int							=						parser.add_parser(
										    'pt-to-tf'      ,							help=(
										        'CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint.'
										        ' Can also be used to validate existing weights without opening PRs, with --no-pr.'
										    )      ,							)
										train_parser.add_argument(
										    '--model-name'      ,							type=lowerCAmelCase_      ,							required=lowerCAmelCase_      ,							help='The model name, including owner/organization, as seen on the hub.'      ,							)
										train_parser.add_argument(
										    '--local-dir'      ,							type=lowerCAmelCase_      ,							default=''      ,							help='Optional local directory of the model repository. Defaults to /tmp/{model_name}'      ,							)
										train_parser.add_argument(
										    '--max-error'      ,							type=lowerCAmelCase_      ,							default=lowerCAmelCase_      ,							help=(
										        F"""Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk."""
										    )      ,							)
										train_parser.add_argument(
										    '--new-weights'      ,							action='store_true'      ,							help='Optional flag to create new TensorFlow weights, even if they already exist.'      ,							)
										train_parser.add_argument(
										    '--no-pr'      ,							action='store_true'      ,							help='Optional flag to NOT open a PR with converted weights.'       )
										train_parser.add_argument(
										    '--push'      ,							action='store_true'      ,							help='Optional flag to push the weights directly to `main` (requires permissions)'      ,							)
										train_parser.add_argument(
										    '--extra-commit-description'      ,							type=lowerCAmelCase_      ,							default=''      ,							help='Optional additional commit description to use when opening a PR (e.g. to tag the owner).'      ,							)
										train_parser.add_argument(
										    '--override-model-class'      ,							type=lowerCAmelCase_      ,							default=lowerCAmelCase_      ,							help='If you think you know better than the auto-detector, you can specify the model class here. '
										    'Can be either an AutoModel class or a specific model class like BertForSequenceClassification.'      ,							)
										train_parser.set_defaults(func=lowerCAmelCase_       )







						@staticmethod
						def  A			(						lowerCAmelCase_      ,							lowerCAmelCase_       )		->       List[Any]:
										_SCREAMING_SNAKE_CASE      :		Any							=						set(pt_outputs.keys()       )
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						set(tf_outputs.keys()       )
										if pt_out_attrs != tf_out_attrs:
														raise ValueError(
														    F"""The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:"""
														    F""" {tf_out_attrs})"""       )

										# 2. For each output attribute, computes the difference
										def _find_pt_tf_differences(lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_=""       ):
														# If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
														# recursivelly, keeping the name of the attribute.
														if isinstance(lowerCAmelCase_      ,							torch.Tensor       ):
																		_SCREAMING_SNAKE_CASE      :		Tuple							=						np.max(np.abs(pt_out.numpy() - tf_out.numpy()       )       )
																		_SCREAMING_SNAKE_CASE      :		List[Any]							=						tensor_difference
														else:
																		_SCREAMING_SNAKE_CASE      :		Optional[int]							=						attr_name
																		for i, pt_item in enumerate(lowerCAmelCase_       ):
																						# If it is a named attribute, we keep the name. Otherwise, just its index.
																						if isinstance(lowerCAmelCase_      ,							lowerCAmelCase_       ):
																										_SCREAMING_SNAKE_CASE      :		Dict							=						root_name + pt_item
																										_SCREAMING_SNAKE_CASE      :		Tuple							=						tf_out[pt_item]
																										_SCREAMING_SNAKE_CASE      :		int							=						pt_out[pt_item]
																						else:
																										_SCREAMING_SNAKE_CASE      :		List[str]							=						root_name + F"""[{i}]"""
																										_SCREAMING_SNAKE_CASE      :		int							=						tf_out[i]
																						_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						_find_pt_tf_differences(lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_       )

														return differences

										return _find_pt_tf_differences(lowerCAmelCase_      ,							lowerCAmelCase_      ,							{}       )







						def __init__(						self      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							*lowerCAmelCase_      ,							)		->       Optional[Any]:
										_SCREAMING_SNAKE_CASE      :		Tuple							=						logging.get_logger('transformers-cli/pt_to_tf'       )
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						model_name
										_SCREAMING_SNAKE_CASE      :		List[str]							=						local_dir if local_dir else os.path.join('/tmp'      ,							lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		List[str]							=						max_error
										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						new_weights
										_SCREAMING_SNAKE_CASE      :		List[str]							=						no_pr
										_SCREAMING_SNAKE_CASE      :		int							=						push
										_SCREAMING_SNAKE_CASE      :		Dict							=						extra_commit_description
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						override_model_class







						def  A			(						self      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_       )		->       Any:

										def _get_audio_input():
														_SCREAMING_SNAKE_CASE      :		Optional[int]							=						load_dataset('hf-internal-testing/librispeech_asr_dummy'      ,							'clean'      ,							split='validation'       )
														_SCREAMING_SNAKE_CASE      :		Dict							=						ds.sort('id'       ).select(range(2       )       )[:2]['audio']
														_SCREAMING_SNAKE_CASE      :		Any							=						[x['array'] for x in speech_samples]
														return raw_samples

										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						type(pt_model.config       )
										if model_config_class in PROCESSOR_MAPPING:
														_SCREAMING_SNAKE_CASE      :		Optional[int]							=						AutoProcessor.from_pretrained(self._local_dir       )
														if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
																		_SCREAMING_SNAKE_CASE      :		List[str]							=						processor.tokenizer.eos_token
										elif model_config_class in IMAGE_PROCESSOR_MAPPING:
														_SCREAMING_SNAKE_CASE      :		List[Any]							=						AutoImageProcessor.from_pretrained(self._local_dir       )
										elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
														_SCREAMING_SNAKE_CASE      :		Tuple							=						AutoFeatureExtractor.from_pretrained(self._local_dir       )
										elif model_config_class in TOKENIZER_MAPPING:
														_SCREAMING_SNAKE_CASE      :		List[str]							=						AutoTokenizer.from_pretrained(self._local_dir       )
														if processor.pad_token is None:
																		_SCREAMING_SNAKE_CASE      :		int							=						processor.eos_token
										else:
														raise ValueError(F"""Unknown data processing type (model config type: {model_config_class})"""       )

										_SCREAMING_SNAKE_CASE      :		Dict							=						set(inspect.signature(pt_model.forward       ).parameters.keys()       )
										_SCREAMING_SNAKE_CASE      :		Tuple							=						{}
										if "input_ids" in model_forward_signature:
														processor_inputs.update(
														    {
														        'text': ['Hi there!', 'I am a batch with more than one row and different input lengths.'],
														        'padding': True,
														        'truncation': True,
														    }       )
										if "pixel_values" in model_forward_signature:
														_SCREAMING_SNAKE_CASE      :		str							=						load_dataset('cifar10'      ,							'plain_text'      ,							split='test'       )[:2]['img']
														processor_inputs.update({'images': sample_images}       )
										if "input_features" in model_forward_signature:
														_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						inspect.signature(processor.feature_extractor       ).parameters
														# Pad to the largest input length by default but take feature extractor default
														# padding value if it exists e.g. "max_length" and is not False or None
														if "padding" in feature_extractor_signature:
																		_SCREAMING_SNAKE_CASE      :		Optional[int]							=						feature_extractor_signature['padding'].default
																		if default_strategy is not False and default_strategy is not None:
																						_SCREAMING_SNAKE_CASE      :		Optional[int]							=						default_strategy
																		else:
																						_SCREAMING_SNAKE_CASE      :		Any							=						True
														else:
																		_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						True
														processor_inputs.update({'audio': _get_audio_input(), 'padding': padding_strategy}       )
										if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
														processor_inputs.update({'audio': _get_audio_input(), 'padding': True}       )
										_SCREAMING_SNAKE_CASE      :		Any							=						processor(**lowerCAmelCase_      ,							return_tensors='pt'       )
										_SCREAMING_SNAKE_CASE      :		Tuple							=						processor(**lowerCAmelCase_      ,							return_tensors='tf'       )

										# Extra input requirements, in addition to the input modality
										if (
										    config.is_encoder_decoder
										    or (hasattr(lowerCAmelCase_      ,							'encoder'       ) and hasattr(lowerCAmelCase_      ,							'decoder'       ))
										    or "decoder_input_ids" in tf_dummy_inputs
										):
														_SCREAMING_SNAKE_CASE      :		Tuple							=						np.asarray([[1], [1]]      ,							dtype=lowerCAmelCase_       ) * (pt_model.config.decoder_start_token_id or 0)
														pt_input.update({'decoder_input_ids': torch.tensor(lowerCAmelCase_       )}       )
														tf_input.update({'decoder_input_ids': tf.convert_to_tensor(lowerCAmelCase_       )}       )

										return pt_input, tf_input







						def  A			(						self       )		->       Tuple:
										# hub version 0.9.0 introduced the possibility of programmatically opening PRs with normal write tokens.
										if version.parse(huggingface_hub.__version__       ) < version.parse('0.9.0'       ):
														raise ImportError(
														    'The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub'
														    ' installation.'       )
										else:
														from huggingface_hub import Repository, create_commit
														from huggingface_hub._commit_api import CommitOperationAdd

										# Fetch remote data
										_SCREAMING_SNAKE_CASE      :		Tuple							=						Repository(local_dir=self._local_dir      ,							clone_from=self._model_name       )

										# Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
										_SCREAMING_SNAKE_CASE      :		Any							=						AutoConfig.from_pretrained(self._local_dir       )
										_SCREAMING_SNAKE_CASE      :		Tuple							=						config.architectures
										if self._override_model_class is not None:
														if self._override_model_class.startswith('TF'       ):
																		_SCREAMING_SNAKE_CASE      :		List[str]							=						[self._override_model_class[2:]]
														else:
																		_SCREAMING_SNAKE_CASE      :		str							=						[self._override_model_class]
														try:
																		_SCREAMING_SNAKE_CASE      :		Any							=						getattr(import_module('transformers'       )      ,							architectures[0]       )
														except AttributeError:
																		raise ValueError(F"""Model class {self._override_model_class} not found in transformers."""       )
														try:
																		_SCREAMING_SNAKE_CASE      :		str							=						getattr(import_module('transformers'       )      ,							'TF' + architectures[0]       )
														except AttributeError:
																		raise ValueError(F"""TF model class TF{self._override_model_class} not found in transformers."""       )
										elif architectures is None:  # No architecture defined -- use auto classes
														_SCREAMING_SNAKE_CASE      :		Tuple							=						getattr(import_module('transformers'       )      ,							'AutoModel'       )
														_SCREAMING_SNAKE_CASE      :		List[Any]							=						getattr(import_module('transformers'       )      ,							'TFAutoModel'       )
														self._logger.warning('No detected architecture, using AutoModel/TFAutoModel'       )
										else:  # Architecture defined -- use it
														if len(lowerCAmelCase_       ) > 1:
																		raise ValueError(F"""More than one architecture was found, aborting. (architectures = {architectures})"""       )
														self._logger.warning(F"""Detected architecture: {architectures[0]}"""       )
														_SCREAMING_SNAKE_CASE      :		Tuple							=						getattr(import_module('transformers'       )      ,							architectures[0]       )
														try:
																		_SCREAMING_SNAKE_CASE      :		int							=						getattr(import_module('transformers'       )      ,							'TF' + architectures[0]       )
														except AttributeError:
																		raise AttributeError(F"""The TensorFlow equivalent of {architectures[0]} doesn't exist in transformers."""       )

																		    # Check the TF dummy inputs to see what keys we need in the forward pass
										_SCREAMING_SNAKE_CASE      :		Dict							=						tf_class.from_config(lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		str							=						tf_from_pt_model.dummy_inputs

										del tf_from_pt_model  # Try to keep only one model in memory at a time

										# Load the model and get some basic inputs
										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						pt_class.from_pretrained(self._local_dir       )
										pt_model.eval()

										_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						self.get_inputs(lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_       )

										with torch.no_grad():
														_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						pt_model(**lowerCAmelCase_      ,							output_hidden_states=lowerCAmelCase_       )
										del pt_model  # will no longer be used, and may have a large memory footprint

										_SCREAMING_SNAKE_CASE      :		Dict							=						tf_class.from_pretrained(self._local_dir      ,							from_pt=lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						tf_from_pt_model(**lowerCAmelCase_      ,							output_hidden_states=lowerCAmelCase_      ,							training=lowerCAmelCase_       )

										# Confirms that cross loading PT weights into TF worked.
										_SCREAMING_SNAKE_CASE      :		Tuple							=						self.find_pt_tf_differences(lowerCAmelCase_      ,							lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						{k: v for k, v in crossload_differences.items() if 'hidden' not in k}
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						{k: v for k, v in crossload_differences.items() if 'hidden' in k}
										if len(lowerCAmelCase_       ) == 0 and architectures is not None:
														raise ValueError(
														    F"""Something went wrong -- the config file has architectures ({architectures}), but no model head"""
														    ' output was found. All outputs start with \'hidden\''       )
										_SCREAMING_SNAKE_CASE      :		int							=						max(output_differences.values()       ) if output_differences else 0.0
										_SCREAMING_SNAKE_CASE      :		List[str]							=						max(hidden_differences.values()       )
										if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
														raise ValueError(
														    'The cross-loaded TensorFlow model has different outputs, something went wrong!\n'
														    + F"""\nList of maximum output differences above the threshold ({self._max_error}):\n"""
														    + '\n'.join([F"""{k}: {v:.3e}""" for k, v in output_differences.items() if v > self._max_error]       )
														    + F"""\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n"""
														    + '\n'.join([F"""{k}: {v:.3e}""" for k, v in hidden_differences.items() if v > self._max_error]       )       )

										# Save the weights in a TF format (if needed) and confirms that the results are still good
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						os.path.join(self._local_dir      ,							lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						os.path.join(self._local_dir      ,							lowerCAmelCase_       )
										if (not os.path.exists(lowerCAmelCase_       ) and not os.path.exists(lowerCAmelCase_       )) or self._new_weights:
														tf_from_pt_model.save_pretrained(self._local_dir       )
										del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

										_SCREAMING_SNAKE_CASE      :		str							=						tf_class.from_pretrained(self._local_dir       )
										_SCREAMING_SNAKE_CASE      :		Any							=						tf_model(**lowerCAmelCase_      ,							output_hidden_states=lowerCAmelCase_       )

										_SCREAMING_SNAKE_CASE      :		Tuple							=						self.find_pt_tf_differences(lowerCAmelCase_      ,							lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		List[str]							=						{k: v for k, v in conversion_differences.items() if 'hidden' not in k}
										_SCREAMING_SNAKE_CASE      :		Dict							=						{k: v for k, v in conversion_differences.items() if 'hidden' in k}
										if len(lowerCAmelCase_       ) == 0 and architectures is not None:
														raise ValueError(
														    F"""Something went wrong -- the config file has architectures ({architectures}), but no model head"""
														    ' output was found. All outputs start with \'hidden\''       )
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						max(output_differences.values()       ) if output_differences else 0.0
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						max(hidden_differences.values()       )
										if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
														raise ValueError(
														    'The converted TensorFlow model has different outputs, something went wrong!\n'
														    + F"""\nList of maximum output differences above the threshold ({self._max_error}):\n"""
														    + '\n'.join([F"""{k}: {v:.3e}""" for k, v in output_differences.items() if v > self._max_error]       )
														    + F"""\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n"""
														    + '\n'.join([F"""{k}: {v:.3e}""" for k, v in hidden_differences.items() if v > self._max_error]       )       )

										_SCREAMING_SNAKE_CASE      :		Any							=						'Update TF weights' if self._new_weights else 'Add TF weights'
										if self._push:
														repo.git_add(auto_lfs_track=lowerCAmelCase_       )
														repo.git_commit(lowerCAmelCase_       )
														repo.git_push(blocking=lowerCAmelCase_       )  # this prints a progress bar with the upload
														self._logger.warning(F"""TF weights pushed into {self._model_name}"""       )
										elif not self._no_pr:
														self._logger.warning('Uploading the weights into a new PR...'       )
														_SCREAMING_SNAKE_CASE      :		Tuple							=						(
														    'Model converted by the [`transformers`\' `pt_to_tf`'
														    ' CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). '
														    'All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n'
														    F"""Maximum crossload output difference={max_crossload_output_diff:.3e}; """
														    F"""Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n"""
														    F"""Maximum conversion output difference={max_conversion_output_diff:.3e}; """
														    F"""Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n"""
														)
														if self._max_error > MAX_ERROR:
																		commit_descrition += (
																		    F"""\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!"""
																		)
														if self._extra_commit_description:
																		commit_descrition += "\n\n" + self._extra_commit_description

														# sharded model -> adds all related files (index and .h5 shards)
														if os.path.exists(lowerCAmelCase_       ):
																		_SCREAMING_SNAKE_CASE      :		str							=						[
																		    CommitOperationAdd(path_in_repo=lowerCAmelCase_      ,							path_or_fileobj=lowerCAmelCase_       )
																		]
																		for shard_path in tf.io.gfile.glob(self._local_dir + '/tf_model-*.h5'       ):
																						operations += [
																						    CommitOperationAdd(path_in_repo=os.path.basename(lowerCAmelCase_       )      ,							path_or_fileobj=lowerCAmelCase_       )
																						]
														else:
																		_SCREAMING_SNAKE_CASE      :		Tuple							=						[CommitOperationAdd(path_in_repo=lowerCAmelCase_      ,							path_or_fileobj=lowerCAmelCase_       )]

														_SCREAMING_SNAKE_CASE      :		int							=						create_commit(
														    repo_id=self._model_name      ,							operations=lowerCAmelCase_      ,							commit_message=lowerCAmelCase_      ,							commit_description=lowerCAmelCase_      ,							repo_type='model'      ,							create_pr=lowerCAmelCase_      ,							).pr_url
														self._logger.warning(F"""PR open in {hub_pr_url}"""       )














"""simple docstring"""
from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


lowerCAmelCase__							= logging.get_logger(__name__)


class _lowerCAmelCase	(						__UpperCAmelCase					):
						SCREAMING_SNAKE_CASE_:				List[str]   				=							['pixel_values']







						def __init__(						self      ,							lowerCAmelCase_ = True      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = PILImageResampling.BILINEAR      ,							lowerCAmelCase_ = True      ,							lowerCAmelCase_ = 1 / 2_5_5      ,							lowerCAmelCase_ = True      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = None      ,							**lowerCAmelCase_      ,							)		->       None:
										super().__init__(**lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		str							=						size if size is not None else {'height': 2_2_4, 'width': 2_2_4}
										_SCREAMING_SNAKE_CASE      :		List[str]							=						get_size_dict(lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						do_resize
										_SCREAMING_SNAKE_CASE      :		List[str]							=						do_rescale
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						do_normalize
										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						size
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						resample
										_SCREAMING_SNAKE_CASE      :		List[str]							=						rescale_factor
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
										_SCREAMING_SNAKE_CASE      :		Dict							=						image_std if image_std is not None else IMAGENET_STANDARD_STD







						def  A			(						self      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_ = PILImageResampling.BILINEAR      ,							lowerCAmelCase_ = None      ,							**lowerCAmelCase_      ,							)		->       np.ndarray:
										_SCREAMING_SNAKE_CASE      :		List[str]							=						get_size_dict(lowerCAmelCase_       )
										if "height" not in size or "width" not in size:
														raise ValueError(F"""The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}"""       )
										return resize(
										    lowerCAmelCase_      ,							size=(size['height'], size['width'])      ,							resample=lowerCAmelCase_      ,							data_format=lowerCAmelCase_      ,							**lowerCAmelCase_       )







						def  A			(						self      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_ = None      ,							**lowerCAmelCase_       )		->       np.ndarray:
										return rescale(lowerCAmelCase_      ,							scale=lowerCAmelCase_      ,							data_format=lowerCAmelCase_      ,							**lowerCAmelCase_       )







						def  A			(						self      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_      ,							lowerCAmelCase_ = None      ,							**lowerCAmelCase_      ,							)		->       np.ndarray:
										return normalize(lowerCAmelCase_      ,							mean=lowerCAmelCase_      ,							std=lowerCAmelCase_      ,							data_format=lowerCAmelCase_      ,							**lowerCAmelCase_       )







						def  A			(						self      ,							lowerCAmelCase_      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = None      ,							lowerCAmelCase_ = ChannelDimension.FIRST      ,							**lowerCAmelCase_      ,							)		->       Dict:
										_SCREAMING_SNAKE_CASE      :		List[str]							=						do_resize if do_resize is not None else self.do_resize
										_SCREAMING_SNAKE_CASE      :		Any							=						do_rescale if do_rescale is not None else self.do_rescale
										_SCREAMING_SNAKE_CASE      :		List[str]							=						do_normalize if do_normalize is not None else self.do_normalize
										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						resample if resample is not None else self.resample
										_SCREAMING_SNAKE_CASE      :		List[str]							=						rescale_factor if rescale_factor is not None else self.rescale_factor
										_SCREAMING_SNAKE_CASE      :		Any							=						image_mean if image_mean is not None else self.image_mean
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						image_std if image_std is not None else self.image_std

										_SCREAMING_SNAKE_CASE      :		Tuple							=						size if size is not None else self.size
										_SCREAMING_SNAKE_CASE      :		List[str]							=						get_size_dict(lowerCAmelCase_       )

										_SCREAMING_SNAKE_CASE      :		Dict							=						make_list_of_images(lowerCAmelCase_       )

										if not valid_images(lowerCAmelCase_       ):
														raise ValueError(
														    'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
														    'torch.Tensor, tf.Tensor or jax.ndarray.'       )

										if do_resize and size is None:
														raise ValueError('Size must be specified if do_resize is True.'       )

										if do_rescale and rescale_factor is None:
														raise ValueError('Rescale factor must be specified if do_rescale is True.'       )

										# All transformations expect numpy arrays.
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						[to_numpy_array(lowerCAmelCase_       ) for image in images]

										if do_resize:
														_SCREAMING_SNAKE_CASE      :		Dict							=						[self.resize(image=lowerCAmelCase_      ,							size=lowerCAmelCase_      ,							resample=lowerCAmelCase_       ) for image in images]

										if do_rescale:
														_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						[self.rescale(image=lowerCAmelCase_      ,							scale=lowerCAmelCase_       ) for image in images]

										if do_normalize:
														_SCREAMING_SNAKE_CASE      :		str							=						[self.normalize(image=lowerCAmelCase_      ,							mean=lowerCAmelCase_      ,							std=lowerCAmelCase_       ) for image in images]

										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						[to_channel_dimension_format(lowerCAmelCase_      ,							lowerCAmelCase_       ) for image in images]

										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						{'pixel_values': images}
										return BatchFeature(data=lowerCAmelCase_      ,							tensor_type=lowerCAmelCase_       )

