





from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, 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 numpy as np
     import tensorflow as tf

     from transformers import (
         TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
         FlaubertConfig,
         TFFlaubertForMultipleChoice,
         TFFlaubertForQuestionAnsweringSimple,
         TFFlaubertForSequenceClassification,
         TFFlaubertForTokenClassification,
         TFFlaubertModel,
         TFFlaubertWithLMHeadModel,
     )


class   A      :
   '''simple docstring'''




   def __init__(      self       :   int							,     __lowerCAmelCase       :   List[Any]							,     )     ->     Any:







     """simple docstring"""






     A__  				=       parent
     A__  				=       13
     A__  				=       7
     A__  				=       True
     A__  				=       True
     A__  				=       True
     A__  				=       True
     A__  				=       True
     A__  				=       False
     A__  				=       False
     A__  				=       False
     A__  				=       2
     A__  				=       99
     A__  				=       0
     A__  				=       32
     A__  				=       2
     A__  				=       4
     A__  				=       0.1
     A__  				=       0.1
     A__  				=       5_12
     A__  				=       16
     A__  				=       2
     A__  				=       0.0_2
     A__  				=       3
     A__  				=       4
     A__  				=       """last"""
     A__  				=       True
     A__  				=       None
     A__  				=       0






   def        a_	(      self       :   List[str]       )     ->     List[str]:







     """simple docstring"""






     A__  				=       ids_tensor([self.batch_size, self.seq_length]							,     self.vocab_size       )
     A__  				=       random_attention_mask([self.batch_size, self.seq_length]							,     dtype=tf.floataa       )

     A__  				=       None
     if self.use_input_lengths:
       A__  				=       (
           ids_tensor([self.batch_size]							,     vocab_size=2       ) + self.seq_length - 2
       )  # small variation of seq_length

     A__  				=       None
     if self.use_token_type_ids:
       A__  				=       ids_tensor([self.batch_size, self.seq_length]							,     self.n_langs       )

     A__  				=       None
     A__  				=       None
     A__  				=       None
     if self.use_labels:
       A__  				=       ids_tensor([self.batch_size]							,     self.type_sequence_label_size       )
       A__  				=       ids_tensor([self.batch_size, self.seq_length]							,     self.num_labels       )
       A__  				=       ids_tensor([self.batch_size]							,     2							,     dtype=tf.floataa       )
       A__  				=       ids_tensor([self.batch_size]							,     self.num_choices       )

     A__  				=       FlaubertConfig(
         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       :   Union[str, Any]							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   str							,     )     ->     List[Any]:







     """simple docstring"""






     A__  				=       TFFlaubertModel(config=__lowerCAmelCase       )
     A__  				=       {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
     A__  				=       model(__lowerCAmelCase       )

     A__  				=       [input_ids, input_mask]
     A__  				=       model(__lowerCAmelCase       )
     self.parent.assertEqual(result.last_hidden_state.shape							,     (self.batch_size, self.seq_length, self.hidden_size)       )






   def        a_	(      self       :   List[Any]							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   Optional[int]							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   Optional[Any]							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   str							,     )     ->     Union[str, Any]:







     """simple docstring"""






     A__  				=       TFFlaubertWithLMHeadModel(__lowerCAmelCase       )

     A__  				=       {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
     A__  				=       model(__lowerCAmelCase       )

     self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.vocab_size)       )






   def        a_	(      self       :   Dict							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   Optional[int]							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   Optional[Any]							,     )     ->     Optional[int]:







     """simple docstring"""






     A__  				=       TFFlaubertForQuestionAnsweringSimple(__lowerCAmelCase       )

     A__  				=       {"""input_ids""": input_ids, """lengths""": input_lengths}

     A__  				=       model(__lowerCAmelCase       )

     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       :   str							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   Optional[int]							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   Union[str, Any]							,     )     ->     Optional[int]:







     """simple docstring"""






     A__  				=       TFFlaubertForSequenceClassification(__lowerCAmelCase       )

     A__  				=       {"""input_ids""": input_ids, """lengths""": input_lengths}

     A__  				=       model(__lowerCAmelCase       )

     self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.type_sequence_label_size)       )






   def        a_	(      self       :   Dict							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   Optional[Any]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   Any							,     )     ->     List[str]:







     """simple docstring"""






     A__  				=       self.num_labels
     A__  				=       TFFlaubertForTokenClassification(config=__lowerCAmelCase       )
     A__  				=       {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
     A__  				=       model(__lowerCAmelCase       )
     self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.num_labels)       )






   def        a_	(      self       :   Any							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   Optional[int]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   Dict							,     )     ->     Any:







     """simple docstring"""






     A__  				=       self.num_choices
     A__  				=       TFFlaubertForMultipleChoice(config=__lowerCAmelCase       )
     A__  				=       tf.tile(tf.expand_dims(__lowerCAmelCase							,     1       )							,     (1, self.num_choices, 1)       )
     A__  				=       tf.tile(tf.expand_dims(__lowerCAmelCase							,     1       )							,     (1, self.num_choices, 1)       )
     A__  				=       tf.tile(tf.expand_dims(__lowerCAmelCase							,     1       )							,     (1, self.num_choices, 1)       )
     A__  				=       {
         """input_ids""": multiple_choice_inputs_ids,
         """attention_mask""": multiple_choice_input_mask,
         """token_type_ids""": multiple_choice_token_type_ids,
     }
     A__  				=       model(__lowerCAmelCase       )
     self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.num_choices)       )







   def        a_	(      self       :   int       )     ->     Optional[Any]:







     """simple docstring"""






     A__  				=       self.prepare_config_and_inputs()
     (
         (
         A__      
     )				,      (
         A__      
     )				,      (
         A__      
     )				,      (
         A__      
     )				,      (
         A__      
     )				,      (
         A__      
     )				,      (
         A__      
     )				,      (
         A__      
     )				,      (
         A__      
     )				,            
     )  				=       config_and_inputs
     A__  				=       {
         """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      (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					unittest.TestCase   ):
   '''simple docstring'''




   __lowerCamelCase     :	List[Any]          =   (
       (
           TFFlaubertModel,
           TFFlaubertWithLMHeadModel,
           TFFlaubertForSequenceClassification,
           TFFlaubertForQuestionAnsweringSimple,
           TFFlaubertForTokenClassification,
           TFFlaubertForMultipleChoice,
       )
       if is_tf_available()
       else ()
   )
   __lowerCamelCase     :	Optional[int]          =   (
       (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
   )  # TODO (PVP): Check other models whether language generation is also applicable
   __lowerCamelCase     :	List[str]          =   (
       {
           '''feature-extraction''': TFFlaubertModel,
           '''fill-mask''': TFFlaubertWithLMHeadModel,
           '''question-answering''': TFFlaubertForQuestionAnsweringSimple,
           '''text-classification''': TFFlaubertForSequenceClassification,
           '''token-classification''': TFFlaubertForTokenClassification,
           '''zero-shot''': TFFlaubertForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   __lowerCamelCase     :	Tuple          =   False
   __lowerCamelCase     :	Union[str, Any]          =   False






   def        a_	(      self       :   List[Any]							,     __lowerCAmelCase       :   Optional[Any]							,     __lowerCAmelCase       :   Optional[Any]							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   Tuple       )     ->     Optional[int]:







     """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       :   List[str]       )     ->     Dict:







     """simple docstring"""






     A__  				=       TFFlaubertModelTester(self       )
     A__  				=       ConfigTester(self							,     config_class=__lowerCAmelCase							,     emb_dim=37       )






   def        a_	(      self       :   int       )     ->     Dict:







     """simple docstring"""






     self.config_tester.run_common_tests()






   def        a_	(      self       :   List[str]       )     ->     Tuple:







     """simple docstring"""






     A__  				=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_model(*__lowerCAmelCase       )






   def        a_	(      self       :   Optional[int]       )     ->     Any:







     """simple docstring"""






     A__  				=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_lm_head(*__lowerCAmelCase       )






   def        a_	(      self       :   int       )     ->     Dict:







     """simple docstring"""






     A__  				=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_qa(*__lowerCAmelCase       )






   def        a_	(      self       :   Dict       )     ->     str:







     """simple docstring"""






     A__  				=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_sequence_classif(*__lowerCAmelCase       )






   def        a_	(      self       :   Optional[int]       )     ->     Tuple:







     """simple docstring"""






     A__  				=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_for_token_classification(*__lowerCAmelCase       )






   def        a_	(      self       :   Dict       )     ->     Optional[int]:







     """simple docstring"""






     A__  				=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_for_multiple_choice(*__lowerCAmelCase       )







   @slow
   def        a_	(      self       :   List[str]       )     ->     List[Any]:







     """simple docstring"""






     for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       A__  				=       TFFlaubertModel.from_pretrained(__lowerCAmelCase       )
       self.assertIsNotNone(__lowerCAmelCase       )


@require_tf
@require_sentencepiece
@require_tokenizers
class   A      (unittest.TestCase   ):
   '''simple docstring'''




   @slow
   def        a_	(      self       :   List[Any]       )     ->     str:







     """simple docstring"""






     A__  				=       TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased"""       )

     A__  				=       tf.convert_to_tensor(
         [[0, 1_58, 7_35, 25_92, 14_24, 67_27, 82, 1]]							,     dtype=tf.intaa							,     )  # "J'aime flaubert !"

     A__  				=       model(__lowerCAmelCase       )[0]
     A__  				=       tf.TensorShape((1, 8, 5_12)       )
     self.assertEqual(output.shape							,     __lowerCAmelCase       )
     # compare the actual values for a slice.
     A__  				=       tf.convert_to_tensor(
         [
             [
                 [-1.8_7_6_8_7_7_3, -1.5_6_6_5_5_5, 0.2_7_0_7_2_4_1_8],
                 [-1.6_9_2_0_0_3_8, -0.5_8_7_3_5_0_5, 1.9_3_2_9_5_9_9],
                 [-2.9_5_6_3_9_8_5, -1.6_9_9_3_8_3_5, 1.7_9_7_2_0_5_2],
             ]
         ]							,     dtype=tf.floataa							,     )

     self.assertTrue(np.allclose(output[:, :3, :3].numpy()							,     expected_slice.numpy()							,     atol=1e-4       )       )










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 (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
					import PIL


A   : int			=				logging.get_logger(__name__)


class   A      (SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''




			__lowerCamelCase     :	Optional[Any]          =   ['''pixel_values''']






			def __init__(      self       :   Dict							,     __lowerCAmelCase       :   bool = True							,     __lowerCAmelCase       :   Dict[str, int] = None							,     __lowerCAmelCase       :   int = 0.9							,     __lowerCAmelCase       :   PILImageResampling = PILImageResampling.BICUBIC							,     __lowerCAmelCase       :   bool = True							,     __lowerCAmelCase       :   Dict[str, int] = None							,     __lowerCAmelCase       :   Union[int, float] = 1 / 2_55							,     __lowerCAmelCase       :   bool = True							,     __lowerCAmelCase       :   bool = True							,     __lowerCAmelCase       :   Optional[Union[float, List[float]]] = None							,     __lowerCAmelCase       :   Optional[Union[float, List[float]]] = None							,     **__lowerCAmelCase       :   Optional[int]							,     )     ->     None:







					"""simple docstring"""






					super().__init__(**__lowerCAmelCase       )
					A__  				=       size if size is not None else {"""shortest_edge""": 2_24}
					A__  				=       get_size_dict(__lowerCAmelCase							,     default_to_square=__lowerCAmelCase       )
					A__  				=       crop_size if crop_size is not None else {"""height""": 2_24, """width""": 2_24}
					A__  				=       get_size_dict(__lowerCAmelCase							,     param_name="""crop_size"""       )

					A__  				=       do_resize
					A__  				=       size
					A__  				=       crop_pct
					A__  				=       resample
					A__  				=       do_center_crop
					A__  				=       crop_size
					A__  				=       do_rescale
					A__  				=       rescale_factor
					A__  				=       do_normalize
					A__  				=       image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
					A__  				=       image_std if image_std is not None else IMAGENET_DEFAULT_STD






			def        a_	(      self       :   int							,     __lowerCAmelCase       :   np.ndarray							,     __lowerCAmelCase       :   Dict[str, int]							,     __lowerCAmelCase       :   Optional[float] = None							,     __lowerCAmelCase       :   PILImageResampling = PILImageResampling.BICUBIC							,     __lowerCAmelCase       :   Optional[Union[str, ChannelDimension]] = None							,     **__lowerCAmelCase       :   int							,     )     ->     np.ndarray:







					"""simple docstring"""






					A__  				=       get_size_dict(__lowerCAmelCase							,     default_to_square=__lowerCAmelCase       )
					if "shortest_edge" not in size and ("height" not in size or "width" not in size):
							raise ValueError(f'size must contain \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}'       )
					if crop_pct is not None:
							if "shortest_edge" in size:
									A__  				=       int(size["""shortest_edge"""] / crop_pct       )
							elif "height" in size and "width" in size:
									if size["height"] == size["width"]:
											A__  				=       int(size["""height"""] / crop_pct       )
									else:
											A__  				=       (int(size["""height"""] / crop_pct       ), int(size["""width"""] / crop_pct       ))
							else:
									raise ValueError("""Invalid size for resize: {}""".format(__lowerCAmelCase       )       )

							A__  				=       get_resize_output_image_size(__lowerCAmelCase							,     size=__lowerCAmelCase							,     default_to_square=__lowerCAmelCase       )
					else:
							if "shortest_edge" in size:
									A__  				=       get_resize_output_image_size(__lowerCAmelCase							,     size=size["""shortest_edge"""]							,     default_to_square=__lowerCAmelCase       )
							elif "height" in size and "width" in size:
									A__  				=       (size["""height"""], size["""width"""])
							else:
									raise ValueError("""Invalid size for resize: {}""".format(__lowerCAmelCase       )       )

					return resize(__lowerCAmelCase							,     size=__lowerCAmelCase							,     resample=__lowerCAmelCase							,     data_format=__lowerCAmelCase							,     **__lowerCAmelCase       )






			def        a_	(      self       :   Optional[Any]							,     __lowerCAmelCase       :   np.ndarray							,     __lowerCAmelCase       :   Dict[str, int]							,     __lowerCAmelCase       :   Optional[Union[str, ChannelDimension]] = None							,     **__lowerCAmelCase       :   Optional[Any]							,     )     ->     np.ndarray:







					"""simple docstring"""






					A__  				=       get_size_dict(__lowerCAmelCase       )
					if "height" not in size or "width" not in size:
							raise ValueError(f'size must contain \'height\' and \'width\' as keys. Got {size.keys()}'       )
					return center_crop(__lowerCAmelCase							,     size=(size["""height"""], size["""width"""])							,     data_format=__lowerCAmelCase							,     **__lowerCAmelCase       )






			def        a_	(      self       :   str							,     __lowerCAmelCase       :   np.ndarray							,     __lowerCAmelCase       :   Union[int, float]							,     __lowerCAmelCase       :   Optional[Union[str, ChannelDimension]] = None							,     **__lowerCAmelCase       :   Dict							,     )     ->     List[str]:







					"""simple docstring"""






					return rescale(__lowerCAmelCase							,     scale=__lowerCAmelCase							,     data_format=__lowerCAmelCase							,     **__lowerCAmelCase       )






			def        a_	(      self       :   int							,     __lowerCAmelCase       :   np.ndarray							,     __lowerCAmelCase       :   Union[float, List[float]]							,     __lowerCAmelCase       :   Union[float, List[float]]							,     __lowerCAmelCase       :   Optional[Union[str, ChannelDimension]] = None							,     **__lowerCAmelCase       :   int							,     )     ->     np.ndarray:







					"""simple docstring"""






					return normalize(__lowerCAmelCase							,     mean=__lowerCAmelCase							,     std=__lowerCAmelCase							,     data_format=__lowerCAmelCase							,     **__lowerCAmelCase       )







			def        a_	(      self       :   Optional[Any]							,     __lowerCAmelCase       :   ImageInput							,     __lowerCAmelCase       :   bool = None							,     __lowerCAmelCase       :   Dict[str, int] = None							,     __lowerCAmelCase       :   int = None							,     __lowerCAmelCase       :   PILImageResampling = None							,     __lowerCAmelCase       :   bool = None							,     __lowerCAmelCase       :   Dict[str, int] = None							,     __lowerCAmelCase       :   bool = None							,     __lowerCAmelCase       :   float = None							,     __lowerCAmelCase       :   bool = None							,     __lowerCAmelCase       :   Optional[Union[float, List[float]]] = None							,     __lowerCAmelCase       :   Optional[Union[float, List[float]]] = None							,     __lowerCAmelCase       :   Optional[Union[str, TensorType]] = None							,     __lowerCAmelCase       :   ChannelDimension = ChannelDimension.FIRST							,     **__lowerCAmelCase       :   Tuple							,     )     ->     PIL.Image.Image:







					"""simple docstring"""






					A__  				=       do_resize if do_resize is not None else self.do_resize
					A__  				=       crop_pct if crop_pct is not None else self.crop_pct
					A__  				=       resample if resample is not None else self.resample
					A__  				=       do_center_crop if do_center_crop is not None else self.do_center_crop
					A__  				=       do_rescale if do_rescale is not None else self.do_rescale
					A__  				=       rescale_factor if rescale_factor is not None else self.rescale_factor
					A__  				=       do_normalize if do_normalize is not None else self.do_normalize
					A__  				=       image_mean if image_mean is not None else self.image_mean
					A__  				=       image_std if image_std is not None else self.image_std

					A__  				=       size if size is not None else self.size
					A__  				=       get_size_dict(__lowerCAmelCase							,     default_to_square=__lowerCAmelCase       )
					A__  				=       crop_size if crop_size is not None else self.crop_size
					A__  				=       get_size_dict(__lowerCAmelCase							,     param_name="""crop_size"""       )

					A__  				=       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 or resample is None:
							raise ValueError("""Size and resample must be specified if do_resize is True."""       )

					if do_center_crop and crop_pct is None:
							raise ValueError("""Crop_pct must be specified if do_center_crop is True."""       )

					if do_rescale and rescale_factor is None:
							raise ValueError("""Rescale factor must be specified if do_rescale 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.
					A__  				=       [to_numpy_array(__lowerCAmelCase       ) for image in images]

					if do_resize:
							A__  				=       [self.resize(image=__lowerCAmelCase							,     size=__lowerCAmelCase							,     crop_pct=__lowerCAmelCase							,     resample=__lowerCAmelCase       ) for image in images]

					if do_center_crop:
							A__  				=       [self.center_crop(image=__lowerCAmelCase							,     size=__lowerCAmelCase       ) for image in images]

					if do_rescale:
							A__  				=       [self.rescale(image=__lowerCAmelCase							,     scale=__lowerCAmelCase       ) for image in images]

					if do_normalize:
							A__  				=       [self.normalize(image=__lowerCAmelCase							,     mean=__lowerCAmelCase							,     std=__lowerCAmelCase       ) for image in images]

					A__  				=       [to_channel_dimension_format(__lowerCAmelCase							,     __lowerCAmelCase       ) for image in images]

					A__  				=       {"""pixel_values""": images}
					return BatchFeature(data=__lowerCAmelCase							,     tensor_type=__lowerCAmelCase       )



