code: 
  
  
  
  
  from typing import List
  
  from packaging import version
  from sklearn.metrics import fa_score
  
  import datasets
  from datasets.config import PY_VERSION
  
  
  if PY_VERSION < version.parse("3.8"):
  				import importlib_metadata
  else:
  				import importlib.metadata as importlib_metadata
  
  
  # TODO(Patrick/Anton)
  SCREAMING_SNAKE_CASE__    :    Optional[Any]								=					"\\n"
  
  SCREAMING_SNAKE_CASE__    :    List[Any]								=					"\\n    XTREME-S is a benchmark to evaluate universal cross-lingual speech representations in many languages.\n    XTREME-S covers four task families: speech recognition, classification, speech-to-text translation and retrieval.\n"
  
  SCREAMING_SNAKE_CASE__    :    Optional[Any]								=					"\nCompute XTREME-S evaluation metric associated to each XTREME-S dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    bleu_kwargs: optional dict of keywords to be passed when computing 'bleu'.\n        Keywords include Dict can be one of 'smooth_method', 'smooth_value', 'force', 'lowercase',\n        'tokenize', 'use_effective_order'.\n    wer_kwargs: optional dict of keywords to be passed when computing 'wer' and 'cer'.\n        Keywords include 'concatenate_texts'.\nReturns: depending on the XTREME-S task, one or several of:\n    \"accuracy\": Accuracy - for 'fleurs-lang_id', 'minds14'\n    \"f1\": F1 score - for 'minds14'\n    \"wer\": Word error rate - for 'mls', 'fleurs-asr', 'voxpopuli', 'babel'\n    \"cer\": Character error rate - for 'mls', 'fleurs-asr', 'voxpopuli', 'babel'\n    \"bleu\": BLEU score according to the `sacrebleu` metric - for 'covost2'\nExamples:\n\n    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'mls')  # 'mls', 'voxpopuli', 'fleurs-asr' or 'babel'\n    >>> references = [\"it is sunny here\", \"paper and pen are essentials\"]\n    >>> predictions = [\"it's sunny\", \"paper pen are essential\"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {'wer': 0.56, 'cer': 0.27}\n\n    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'covost2')\n    >>> references = [\"bonjour paris\", \"il est necessaire de faire du sport de temps en temp\"]\n    >>> predictions = [\"bonjour paris\", \"il est important de faire du sport souvent\"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {'bleu': 31.65}\n\n    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'fleurs-lang_id')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {'accuracy': 0.6}\n\n    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'minds14')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {'f1': 0.58, 'accuracy': 0.6}\n"
  
  SCREAMING_SNAKE_CASE__    :    Tuple								=					["fleurs-asr", "mls", "voxpopuli", "babel", "covost2", "fleurs-lang_id", "minds14"]
  SCREAMING_SNAKE_CASE__    :    int								=					""
  
  try:
  				from jiwer import transforms as tr
  
  				SCREAMING_SNAKE_CASE__    :    List[str]								=					True
  except ImportError:
  				SCREAMING_SNAKE_CASE__    :    Dict								=					False
  
  if _jiwer_available and version.parse(importlib_metadata.version("jiwer")) < version.parse("2.3.0"):
  
  
  
  				class 			a_					(    tr.AbstractTransform    ):
  
  
  
  
  
  					def __init__(       self			,    SCREAMING_SNAKE_CASE = " "			)     ->				Optional[int]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  								SCREAMING_SNAKE_CASE_			=	sentence_delimiter
  
  
  
  
  
  					def 	A_(       self			,    SCREAMING_SNAKE_CASE			)     ->				Dict:
  
  
  
  
  								"""simple docstring"""
  
  
  
  								return list(SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  					def 	A_(       self			,    SCREAMING_SNAKE_CASE			)     ->				Any:
  
  
  
  
  								"""simple docstring"""
  
  
  
  								SCREAMING_SNAKE_CASE_			=	[]
  								for sent_idx, sentence in enumerate(SCREAMING_SNAKE_CASE			):
  											chars.extend(self.process_string(SCREAMING_SNAKE_CASE			)			)
  											if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(SCREAMING_SNAKE_CASE			) - 1:
  														chars.append(self.sentence_delimiter			)
  								return chars
  
  
  
  
  				SCREAMING_SNAKE_CASE__    :    str								=					tr.Compose(
  				    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
  				)
  elif _jiwer_available:
  				SCREAMING_SNAKE_CASE__    :    Optional[Any]								=					tr.Compose(
  				    [
  				        tr.RemoveMultipleSpaces(),
  				        tr.Strip(),
  				        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
  				        tr.ReduceToListOfListOfChars(),
  				    ]
  				)
  else:
  				SCREAMING_SNAKE_CASE__    :    Tuple								=					None
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       List[Any]:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			return float((preds == labels).mean()   )
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       int:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			return {
  			    "f1": float(fa_score(y_true=SCREAMING_SNAKE_CASE					,						y_pred=SCREAMING_SNAKE_CASE					,						average='macro'   )   ),
  			    "accuracy": simple_accuracy(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ),
  			}
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE="exp"					,						SCREAMING_SNAKE_CASE=None					,						SCREAMING_SNAKE_CASE=False					,						SCREAMING_SNAKE_CASE=False					,						SCREAMING_SNAKE_CASE=None					,						SCREAMING_SNAKE_CASE=False					,						) ->       List[Any]:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			SCREAMING_SNAKE_CASE_			=	[[label] for label in labels]
  			SCREAMING_SNAKE_CASE_			=	list(SCREAMING_SNAKE_CASE   )
  			try:
  						import sacrebleu as scb
  			except ImportError:
  						raise ValueError(
  						    'sacrebleu has to be installed in order to apply the bleu metric for covost2.'
  						    'You can install it via `pip install sacrebleu`.'   )
  
  			if version.parse(scb.__version__   ) < version.parse('1.4.12'   ):
  						raise ImportWarning(
  						    'To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n'
  						    'You can install it with `pip install "sacrebleu>=1.4.12"`.'   )
  
  			SCREAMING_SNAKE_CASE_			=	len(labels[0]   )
  			if any(len(SCREAMING_SNAKE_CASE   ) != references_per_prediction for refs in labels   ):
  						raise ValueError('Sacrebleu requires the same number of references for each prediction'   )
  			SCREAMING_SNAKE_CASE_			=	[[refs[i] for refs in labels] for i in range(SCREAMING_SNAKE_CASE   )]
  			SCREAMING_SNAKE_CASE_			=	scb.corpus_bleu(
  			    SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						smooth_method=SCREAMING_SNAKE_CASE					,						smooth_value=SCREAMING_SNAKE_CASE					,						force=SCREAMING_SNAKE_CASE					,						lowercase=SCREAMING_SNAKE_CASE					,						use_effective_order=SCREAMING_SNAKE_CASE					,						**({'tokenize': tokenize} if tokenize else {})					,						)
  			return {"bleu": output.score}
  
  def lowercase						(     SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ) ->       List[str]:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			try:
  						from jiwer import compute_measures
  			except ImportError:
  						raise ValueError(
  						    F'jiwer has to be installed in order to apply the wer metric for {config_name}.'
  						    'You can install it via `pip install jiwer`.'   )
  
  			if concatenate_texts:
  						SCREAMING_SNAKE_CASE_			=	compute_measures(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   )['wer']
  
  						SCREAMING_SNAKE_CASE_			=	compute_measures(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						truth_transform=SCREAMING_SNAKE_CASE					,						hypothesis_transform=SCREAMING_SNAKE_CASE   )['wer']
  						return {"wer": wer, "cer": cer}
  			else:
  
  						def compute_score(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE="wer"   ):
  									SCREAMING_SNAKE_CASE_			=	0
  									SCREAMING_SNAKE_CASE_			=	0
  									for prediction, reference in zip(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   ):
  												if score_type == "wer":
  															SCREAMING_SNAKE_CASE_			=	compute_measures(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE   )
  												elif score_type == "cer":
  															SCREAMING_SNAKE_CASE_			=	compute_measures(
  															    SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						truth_transform=SCREAMING_SNAKE_CASE					,						hypothesis_transform=SCREAMING_SNAKE_CASE   )
  												incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
  												total += measures["substitutions"] + measures["deletions"] + measures["hits"]
  									return incorrect / total
  
  						return {"wer": compute_score(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						'wer'   ), "cer": compute_score(SCREAMING_SNAKE_CASE					,						SCREAMING_SNAKE_CASE					,						'cer'   )}
  
  
  
  @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION     ,						_KWARGS_DESCRIPTION    )
  class 			a_					(    datasets.Metric    ):
  
  
  
  
  
  	def 	A_(       self			)     ->				Any:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				if self.config_name not in _CONFIG_NAMES:
  							raise KeyError(f'You should supply a configuration name selected in {_CONFIG_NAMES}'			)
  
  				SCREAMING_SNAKE_CASE_			=	'int64' if self.config_name in ['fleurs-lang_id', 'minds14'] else 'string'
  
  				return datasets.MetricInfo(
  				    description=_DESCRIPTION			,    citation=_CITATION			,    inputs_description=_KWARGS_DESCRIPTION			,    features=datasets.Features(
  				        {'predictions': datasets.Value(SCREAMING_SNAKE_CASE			), 'references': datasets.Value(SCREAMING_SNAKE_CASE			)}			)			,    codebase_urls=[]			,    reference_urls=[]			,    format='numpy'			,    )
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE=None			,    SCREAMING_SNAKE_CASE=None			)     ->				Tuple:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	bleu_kwargs if bleu_kwargs is not None else {}
  				SCREAMING_SNAKE_CASE_			=	wer_kwargs if wer_kwargs is not None else {}
  
  				if self.config_name == "fleurs-lang_id":
  							return {"accuracy": simple_accuracy(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)}
  				elif self.config_name == "minds14":
  							return fa_and_simple_accuracy(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)
  				elif self.config_name == "covost2":
  							SCREAMING_SNAKE_CASE_			=	bleu_kwargs.pop('smooth_method'			,    'exp'			)
  							SCREAMING_SNAKE_CASE_			=	bleu_kwargs.pop('smooth_value'			,    SCREAMING_SNAKE_CASE			)
  							SCREAMING_SNAKE_CASE_			=	bleu_kwargs.pop('force'			,    SCREAMING_SNAKE_CASE			)
  							SCREAMING_SNAKE_CASE_			=	bleu_kwargs.pop('lowercase'			,    SCREAMING_SNAKE_CASE			)
  							SCREAMING_SNAKE_CASE_			=	bleu_kwargs.pop('tokenize'			,    SCREAMING_SNAKE_CASE			)
  							SCREAMING_SNAKE_CASE_			=	bleu_kwargs.pop('use_effective_order'			,    SCREAMING_SNAKE_CASE			)
  							return bleu(
  							    preds=SCREAMING_SNAKE_CASE			,    labels=SCREAMING_SNAKE_CASE			,    smooth_method=SCREAMING_SNAKE_CASE			,    smooth_value=SCREAMING_SNAKE_CASE			,    force=SCREAMING_SNAKE_CASE			,    lowercase=SCREAMING_SNAKE_CASE			,    tokenize=SCREAMING_SNAKE_CASE			,    use_effective_order=SCREAMING_SNAKE_CASE			,    )
  				elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
  							SCREAMING_SNAKE_CASE_			=	wer_kwargs.pop('concatenate_texts'			,    SCREAMING_SNAKE_CASE			)
  							return wer_and_cer(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    self.config_name			)
  				else:
  							raise KeyError(f'You should supply a configuration name selected in {_CONFIG_NAMES}'			)
  
style_context: 
  
  
  
  
  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 (
      get_resize_output_image_size,
      normalize,
      pad,
      rescale,
      resize,
      to_channel_dimension_format,
  )
  from ...image_utils import (
      IMAGENET_STANDARD_MEAN,
      IMAGENET_STANDARD_STD,
      ChannelDimension,
      ImageInput,
      PILImageResampling,
      get_image_size,
      make_list_of_images,
      to_numpy_array,
      valid_images,
  )
  from ...utils import TensorType, logging
  from ...utils.import_utils import is_vision_available
  
  
  SCREAMING_SNAKE_CASE__    :    Tuple								=					logging.get_logger(__name__)
  
  
  if is_vision_available():
  				import PIL
  
  
  
  class 			a_					(    SCREAMING_SNAKE_CASE__    ):
  	A						       =   ['''pixel_values''']
  
  
  
  
  
  	def __init__(       self			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = PILImageResampling.BILINEAR			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = False			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = 1 / 255			,    SCREAMING_SNAKE_CASE = True			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				None:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				super().__init__(**SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	size if size is not None else {'height': 2560, 'width': 1920}
  				if isinstance(SCREAMING_SNAKE_CASE			,    (tuple, list)			):
  							# The previous feature extractor size parameter was in (width, height) format
  							SCREAMING_SNAKE_CASE_			=	size[::-1]
  				SCREAMING_SNAKE_CASE_			=	get_size_dict(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	do_resize
  				SCREAMING_SNAKE_CASE_			=	size
  				SCREAMING_SNAKE_CASE_			=	resample
  				SCREAMING_SNAKE_CASE_			=	do_thumbnail
  				SCREAMING_SNAKE_CASE_			=	do_align_long_axis
  				SCREAMING_SNAKE_CASE_			=	do_pad
  				SCREAMING_SNAKE_CASE_			=	do_rescale
  				SCREAMING_SNAKE_CASE_			=	rescale_factor
  				SCREAMING_SNAKE_CASE_			=	do_normalize
  				SCREAMING_SNAKE_CASE_			=	image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
  				SCREAMING_SNAKE_CASE_			=	image_std if image_std is not None else IMAGENET_STANDARD_STD
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = None			)     ->				np.ndarray:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	get_image_size(SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	size['height'], size['width']
  
  				if (output_width < output_height and input_width > input_height) or (
  				    output_width > output_height and input_width < input_height
  				):
  							SCREAMING_SNAKE_CASE_			=	np.rotaa(SCREAMING_SNAKE_CASE			,    3			)
  
  				if data_format is not None:
  							SCREAMING_SNAKE_CASE_			=	to_channel_dimension_format(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)
  
  				return image
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = False			,    SCREAMING_SNAKE_CASE = None			,    )     ->				np.ndarray:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	size['height'], size['width']
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	get_image_size(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	output_width - input_width
  				SCREAMING_SNAKE_CASE_			=	output_height - input_height
  
  				if random_padding:
  							SCREAMING_SNAKE_CASE_			=	np.random.randint(low=0			,    high=delta_height + 1			)
  							SCREAMING_SNAKE_CASE_			=	np.random.randint(low=0			,    high=delta_width + 1			)
  				else:
  							SCREAMING_SNAKE_CASE_			=	delta_height // 2
  							SCREAMING_SNAKE_CASE_			=	delta_width // 2
  
  				SCREAMING_SNAKE_CASE_			=	delta_height - pad_top
  				SCREAMING_SNAKE_CASE_			=	delta_width - pad_left
  
  				SCREAMING_SNAKE_CASE_			=	((pad_top, pad_bottom), (pad_left, pad_right))
  				return pad(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    data_format=SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			,    *SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)     ->				Any:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				logger.info('pad is deprecated and will be removed in version 4.27. Please use pad_image instead.'			)
  				return self.pad_image(*SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				np.ndarray:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	get_image_size(SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	size['height'], size['width']
  
  				# We always resize to the smallest of either the input or output size.
  				SCREAMING_SNAKE_CASE_			=	min(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	min(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)
  
  				if height == input_height and width == input_width:
  							return image
  
  				if input_height > input_width:
  							SCREAMING_SNAKE_CASE_			=	int(input_width * height / input_height			)
  				elif input_width > input_height:
  							SCREAMING_SNAKE_CASE_			=	int(input_height * width / input_width			)
  
  				return resize(
  				    SCREAMING_SNAKE_CASE			,    size=(height, width)			,    resample=SCREAMING_SNAKE_CASE			,    reducing_gap=2.0			,    data_format=SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				np.ndarray:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	get_size_dict(SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	min(size['height']			,    size['width']			)
  				SCREAMING_SNAKE_CASE_			=	get_resize_output_image_size(SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			,    default_to_square=SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	resize(SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			,    resample=SCREAMING_SNAKE_CASE			,    data_format=SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)
  				return resized_image
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				Any:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				return rescale(SCREAMING_SNAKE_CASE			,    scale=SCREAMING_SNAKE_CASE			,    data_format=SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = None			,    **SCREAMING_SNAKE_CASE			,    )     ->				np.ndarray:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				return normalize(SCREAMING_SNAKE_CASE			,    mean=SCREAMING_SNAKE_CASE			,    std=SCREAMING_SNAKE_CASE			,    data_format=SCREAMING_SNAKE_CASE			,    **SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = False			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = None			,    SCREAMING_SNAKE_CASE = ChannelDimension.FIRST			,    **SCREAMING_SNAKE_CASE			,    )     ->				PIL.Image.Image:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	do_resize if do_resize is not None else self.do_resize
  				SCREAMING_SNAKE_CASE_			=	size if size is not None else self.size
  				if isinstance(SCREAMING_SNAKE_CASE			,    (tuple, list)			):
  							# Previous feature extractor had size in (width, height) format
  							SCREAMING_SNAKE_CASE_			=	size[::-1]
  				SCREAMING_SNAKE_CASE_			=	get_size_dict(SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	resample if resample is not None else self.resample
  				SCREAMING_SNAKE_CASE_			=	do_thumbnail if do_thumbnail is not None else self.do_thumbnail
  				SCREAMING_SNAKE_CASE_			=	do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
  				SCREAMING_SNAKE_CASE_			=	do_pad if do_pad is not None else self.do_pad
  				SCREAMING_SNAKE_CASE_			=	do_rescale if do_rescale is not None else self.do_rescale
  				SCREAMING_SNAKE_CASE_			=	rescale_factor if rescale_factor is not None else self.rescale_factor
  				SCREAMING_SNAKE_CASE_			=	do_normalize if do_normalize is not None else self.do_normalize
  				SCREAMING_SNAKE_CASE_			=	image_mean if image_mean is not None else self.image_mean
  				SCREAMING_SNAKE_CASE_			=	image_std if image_std is not None else self.image_std
  
  				SCREAMING_SNAKE_CASE_			=	make_list_of_images(SCREAMING_SNAKE_CASE			)
  
  				if not valid_images(SCREAMING_SNAKE_CASE			):
  							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.'			)
  
  				if do_pad and size is None:
  							raise ValueError('Size must be specified if do_pad is True.'			)
  
  				if do_normalize and (image_mean is None or image_std is None):
  							raise ValueError('Image mean and std must be specified if do_normalize is True.'			)
  
  				# All transformations expect numpy arrays.
  				SCREAMING_SNAKE_CASE_			=	[to_numpy_array(SCREAMING_SNAKE_CASE			) for image in images]
  
  				if do_align_long_axis:
  							SCREAMING_SNAKE_CASE_			=	[self.align_long_axis(SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			) for image in images]
  
  				if do_resize:
  							SCREAMING_SNAKE_CASE_			=	[self.resize(image=SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			,    resample=SCREAMING_SNAKE_CASE			) for image in images]
  
  				if do_thumbnail:
  							SCREAMING_SNAKE_CASE_			=	[self.thumbnail(image=SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			) for image in images]
  
  				if do_pad:
  							SCREAMING_SNAKE_CASE_			=	[self.pad_image(image=SCREAMING_SNAKE_CASE			,    size=SCREAMING_SNAKE_CASE			,    random_padding=SCREAMING_SNAKE_CASE			) for image in images]
  
  				if do_rescale:
  							SCREAMING_SNAKE_CASE_			=	[self.rescale(image=SCREAMING_SNAKE_CASE			,    scale=SCREAMING_SNAKE_CASE			) for image in images]
  
  				if do_normalize:
  							SCREAMING_SNAKE_CASE_			=	[self.normalize(image=SCREAMING_SNAKE_CASE			,    mean=SCREAMING_SNAKE_CASE			,    std=SCREAMING_SNAKE_CASE			) for image in images]
  
  				SCREAMING_SNAKE_CASE_			=	[to_channel_dimension_format(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			) for image in images]
  
  				SCREAMING_SNAKE_CASE_			=	{'pixel_values': images}
  				return BatchFeature(data=SCREAMING_SNAKE_CASE			,    tensor_type=SCREAMING_SNAKE_CASE			)
  