code: 
  
  
  
  
  from __future__ import annotations
  
  import unittest
  
  from transformers import is_tf_available
  from transformers.testing_utils import require_tf, slow
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
  				import tensorflow as tf
  
  				from transformers import (
  				    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
  				    TFXLMForMultipleChoice,
  				    TFXLMForQuestionAnsweringSimple,
  				    TFXLMForSequenceClassification,
  				    TFXLMForTokenClassification,
  				    TFXLMModel,
  				    TFXLMWithLMHeadModel,
  				    XLMConfig,
  				)
  
  
  
  class 			a_					:
  
  
  
  
  
  	def __init__(       self			,    SCREAMING_SNAKE_CASE			,    )     ->				Optional[Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	parent
  				SCREAMING_SNAKE_CASE_			=	13
  				SCREAMING_SNAKE_CASE_			=	7
  				SCREAMING_SNAKE_CASE_			=	True
  				SCREAMING_SNAKE_CASE_			=	True
  				SCREAMING_SNAKE_CASE_			=	True
  				SCREAMING_SNAKE_CASE_			=	True
  				SCREAMING_SNAKE_CASE_			=	True
  				SCREAMING_SNAKE_CASE_			=	False
  				SCREAMING_SNAKE_CASE_			=	False
  				SCREAMING_SNAKE_CASE_			=	False
  				SCREAMING_SNAKE_CASE_			=	2
  				SCREAMING_SNAKE_CASE_			=	99
  				SCREAMING_SNAKE_CASE_			=	0
  				SCREAMING_SNAKE_CASE_			=	32
  				SCREAMING_SNAKE_CASE_			=	2
  				SCREAMING_SNAKE_CASE_			=	4
  				SCREAMING_SNAKE_CASE_			=	0.1
  				SCREAMING_SNAKE_CASE_			=	0.1
  				SCREAMING_SNAKE_CASE_			=	512
  				SCREAMING_SNAKE_CASE_			=	16
  				SCREAMING_SNAKE_CASE_			=	2
  				SCREAMING_SNAKE_CASE_			=	0.0_2
  				SCREAMING_SNAKE_CASE_			=	3
  				SCREAMING_SNAKE_CASE_			=	4
  				SCREAMING_SNAKE_CASE_			=	'''last'''
  				SCREAMING_SNAKE_CASE_			=	True
  				SCREAMING_SNAKE_CASE_			=	None
  				SCREAMING_SNAKE_CASE_			=	0
  
  
  
  
  
  	def 	A_(       self			)     ->				Union[str, Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size, self.seq_length]			,    self.vocab_size			)
  				SCREAMING_SNAKE_CASE_			=	random_attention_mask([self.batch_size, self.seq_length]			,    dtype=tf.floataa			)
  
  				SCREAMING_SNAKE_CASE_			=	None
  				if self.use_input_lengths:
  							SCREAMING_SNAKE_CASE_			=	(
  							    ids_tensor([self.batch_size]			,    vocab_size=2			) + self.seq_length - 2
  							)  # small variation of seq_length
  
  				SCREAMING_SNAKE_CASE_			=	None
  				if self.use_token_type_ids:
  							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size, self.seq_length]			,    self.n_langs			)
  
  				SCREAMING_SNAKE_CASE_			=	None
  				SCREAMING_SNAKE_CASE_			=	None
  				SCREAMING_SNAKE_CASE_			=	None
  				if self.use_labels:
  							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size]			,    self.type_sequence_label_size			)
  							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size, self.seq_length]			,    self.num_labels			)
  							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size]			,    2			,    dtype=tf.floataa			)
  							SCREAMING_SNAKE_CASE_			=	ids_tensor([self.batch_size]			,    self.num_choices			)
  
  				SCREAMING_SNAKE_CASE_			=	XLMConfig(
  				    vocab_size=self.vocab_size			,    n_special=self.n_special			,    emb_dim=self.hidden_size			,    n_layers=self.num_hidden_layers			,    n_heads=self.num_attention_heads			,    dropout=self.hidden_dropout_prob			,    attention_dropout=self.attention_probs_dropout_prob			,    gelu_activation=self.gelu_activation			,    sinusoidal_embeddings=self.sinusoidal_embeddings			,    asm=self.asm			,    causal=self.causal			,    n_langs=self.n_langs			,    max_position_embeddings=self.max_position_embeddings			,    initializer_range=self.initializer_range			,    summary_type=self.summary_type			,    use_proj=self.use_proj			,    bos_token_id=self.bos_token_id			,    )
  
  				return (
  				    config,
  				    input_ids,
  				    token_type_ids,
  				    input_lengths,
  				    sequence_labels,
  				    token_labels,
  				    is_impossible_labels,
  				    choice_labels,
  				    input_mask,
  				)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				int:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	TFXLMModel(config=SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	[input_ids, input_mask]
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
  				self.parent.assertEqual(result.last_hidden_state.shape			,    (self.batch_size, self.seq_length, self.hidden_size)			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				Optional[Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	TFXLMWithLMHeadModel(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	outputs
  
  				self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.seq_length, self.vocab_size)			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				str:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	TFXLMForQuestionAnsweringSimple(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''lengths''': input_lengths}
  
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
  
  				self.parent.assertEqual(result.start_logits.shape			,    (self.batch_size, self.seq_length)			)
  				self.parent.assertEqual(result.end_logits.shape			,    (self.batch_size, self.seq_length)			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				int:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	TFXLMForSequenceClassification(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''lengths''': input_lengths}
  
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
  
  				self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.type_sequence_label_size)			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				int:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.num_labels
  				SCREAMING_SNAKE_CASE_			=	TFXLMForTokenClassification(config=SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
  				self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.seq_length, self.num_labels)			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    )     ->				Dict:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.num_choices
  				SCREAMING_SNAKE_CASE_			=	TFXLMForMultipleChoice(config=SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE			,    1			)			,    (1, self.num_choices, 1)			)
  				SCREAMING_SNAKE_CASE_			=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE			,    1			)			,    (1, self.num_choices, 1)			)
  				SCREAMING_SNAKE_CASE_			=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE			,    1			)			,    (1, self.num_choices, 1)			)
  				SCREAMING_SNAKE_CASE_			=	{
  				    '''input_ids''': multiple_choice_inputs_ids,
  				    '''attention_mask''': multiple_choice_input_mask,
  				    '''token_type_ids''': multiple_choice_token_type_ids,
  				}
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
  				self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.num_choices)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				int:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.prepare_config_and_inputs()
  				(
  				    SCREAMING_SNAKE_CASE_	
  				)			=	config_and_inputs
  				SCREAMING_SNAKE_CASE_			=	{
  				    '''input_ids''': input_ids,
  				    '''token_type_ids''': token_type_ids,
  				    '''langs''': token_type_ids,
  				    '''lengths''': input_lengths,
  				}
  				return config, inputs_dict
  
  
  
  
  @require_tf
  class 			a_					(    A_     ,						A_     ,						unittest.TestCase    ):
  	A						       =   (
  	    (
  	        TFXLMModel,
  	        TFXLMWithLMHeadModel,
  	        TFXLMForSequenceClassification,
  	        TFXLMForQuestionAnsweringSimple,
  	        TFXLMForTokenClassification,
  	        TFXLMForMultipleChoice,
  	    )
  	    if is_tf_available()
  	    else ()
  	)
  	A						       =   (
  	    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
  	)  # TODO (PVP): Check other models whether language generation is also applicable
  	A						       =   (
  	    {
  	        '''feature-extraction''': TFXLMModel,
  	        '''fill-mask''': TFXLMWithLMHeadModel,
  	        '''question-answering''': TFXLMForQuestionAnsweringSimple,
  	        '''text-classification''': TFXLMForSequenceClassification,
  	        '''text-generation''': TFXLMWithLMHeadModel,
  	        '''token-classification''': TFXLMForTokenClassification,
  	        '''zero-shot''': TFXLMForSequenceClassification,
  	    }
  	    if is_tf_available()
  	    else {}
  	)
  	A						       =   False
  	A						       =   False
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)     ->				Tuple:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				if (
  				    pipeline_test_casse_name == "QAPipelineTests"
  				    and tokenizer_name is not None
  				    and not tokenizer_name.endswith('Fast'			)
  				):
  							# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
  							# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
  							# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
  							return True
  
  				return False
  
  
  
  
  
  	def 	A_(       self			)     ->				str:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	TFXLMModelTester(self			)
  				SCREAMING_SNAKE_CASE_			=	ConfigTester(self			,    config_class=SCREAMING_SNAKE_CASE			,    emb_dim=37			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Optional[Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				self.config_tester.run_common_tests()
  
  
  
  
  
  	def 	A_(       self			)     ->				Any:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_xlm_model(*SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Union[str, Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_xlm_lm_head(*SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Dict:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_xlm_qa(*SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Dict:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_xlm_sequence_classif(*SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Optional[int]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_xlm_for_token_classification(*SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Dict:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_xlm_for_multiple_choice(*SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	@slow
  	def 	A_(       self			)     ->				str:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  							SCREAMING_SNAKE_CASE_			=	TFXLMModel.from_pretrained(SCREAMING_SNAKE_CASE			)
  							self.assertIsNotNone(SCREAMING_SNAKE_CASE			)
  
  
  
  
  @require_tf
  class 			a_					(    unittest.TestCase    ):
  
  
  
  
  
  	@slow
  	def 	A_(       self			)     ->				List[Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'			)
  				SCREAMING_SNAKE_CASE_			=	tf.convert_to_tensor([[14, 447]]			,    dtype=tf.intaa			)  # the president
  				SCREAMING_SNAKE_CASE_			=	[
  				    14,
  				    447,
  				    14,
  				    447,
  				    14,
  				    447,
  				    14,
  				    447,
  				    14,
  				    447,
  				    14,
  				    447,
  				    14,
  				    447,
  				    14,
  				    447,
  				    14,
  				    447,
  				    14,
  				    447,
  				]  # the president the president the president the president the president the president the president the president the president the president
  				# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
  				SCREAMING_SNAKE_CASE_			=	model.generate(SCREAMING_SNAKE_CASE			,    do_sample=SCREAMING_SNAKE_CASE			)
  				self.assertListEqual(output_ids[0].numpy().tolist()			,    SCREAMING_SNAKE_CASE			)
  
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			)
  