




import unittest

from transformers import MobileBertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         MODEL_FOR_PRETRAINING_MAPPING,
         MobileBertForMaskedLM,
         MobileBertForMultipleChoice,
         MobileBertForNextSentencePrediction,
         MobileBertForPreTraining,
         MobileBertForQuestionAnswering,
         MobileBertForSequenceClassification,
         MobileBertForTokenClassification,
         MobileBertModel,
     )

class   __a:






    """simple docstring"""





    def __init__(				self       ,_SCREAMING_SNAKE_CASE       ,_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=99       ,_SCREAMING_SNAKE_CASE=64       ,_SCREAMING_SNAKE_CASE=32       ,_SCREAMING_SNAKE_CASE=5       ,_SCREAMING_SNAKE_CASE=4       ,_SCREAMING_SNAKE_CASE=37       ,_SCREAMING_SNAKE_CASE="gelu"       ,_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.02       ,_SCREAMING_SNAKE_CASE=3       ,_SCREAMING_SNAKE_CASE=4       ,_SCREAMING_SNAKE_CASE=None       ,)			->		List[Any]:
         UpperCAmelCase_      :							Any       =      parent
         UpperCAmelCase_      :							Optional[Any]       =      batch_size
         UpperCAmelCase_      :							List[str]       =      seq_length
         UpperCAmelCase_      :							Any       =      is_training
         UpperCAmelCase_      :							Optional[Any]       =      use_input_mask
         UpperCAmelCase_      :							Tuple       =      use_token_type_ids
         UpperCAmelCase_      :							Union[str, Any]       =      use_labels
         UpperCAmelCase_      :							Optional[int]       =      vocab_size
         UpperCAmelCase_      :							Dict       =      hidden_size
         UpperCAmelCase_      :							Union[str, Any]       =      embedding_size
         UpperCAmelCase_      :							Dict       =      num_hidden_layers
         UpperCAmelCase_      :							Tuple       =      num_attention_heads
         UpperCAmelCase_      :							Optional[Any]       =      intermediate_size
         UpperCAmelCase_      :							Union[str, Any]       =      hidden_act
         UpperCAmelCase_      :							List[str]       =      hidden_dropout_prob
         UpperCAmelCase_      :							str       =      attention_probs_dropout_prob
         UpperCAmelCase_      :							List[str]       =      max_position_embeddings
         UpperCAmelCase_      :							str       =      type_vocab_size
         UpperCAmelCase_      :							str       =      type_sequence_label_size
         UpperCAmelCase_      :							str       =      initializer_range
         UpperCAmelCase_      :							Any       =      num_labels
         UpperCAmelCase_      :							int       =      num_choices
         UpperCAmelCase_      :							List[str]       =      scope





    def 							a__				(				self  )			->		Optional[Any]:
         UpperCAmelCase_      :							List[Any]       =      ids_tensor([self.batch_size, self.seq_length]       ,self.vocab_size  )

         UpperCAmelCase_      :							Dict       =      None
         if self.use_input_mask:
              UpperCAmelCase_      :							Dict       =      random_attention_mask([self.batch_size, self.seq_length]  )

         UpperCAmelCase_      :							Tuple       =      None
         if self.use_token_type_ids:
              UpperCAmelCase_      :							Tuple       =      ids_tensor([self.batch_size, self.seq_length]       ,self.type_vocab_size  )

         UpperCAmelCase_      :							List[Any]       =      None
         UpperCAmelCase_      :							int       =      None
         UpperCAmelCase_      :							Optional[int]       =      None
         if self.use_labels:
              UpperCAmelCase_      :							Optional[Any]       =      ids_tensor([self.batch_size]       ,self.type_sequence_label_size  )
              UpperCAmelCase_      :							Optional[int]       =      ids_tensor([self.batch_size, self.seq_length]       ,self.num_labels  )
              UpperCAmelCase_      :							List[Any]       =      ids_tensor([self.batch_size]       ,self.num_choices  )

         UpperCAmelCase_      :							int       =      self.get_config()

         return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





    def 							a__				(				self  )			->		str:
         return MobileBertConfig(
             vocab_size=self.vocab_size       ,hidden_size=self.hidden_size       ,num_hidden_layers=self.num_hidden_layers       ,num_attention_heads=self.num_attention_heads       ,intermediate_size=self.intermediate_size       ,embedding_size=self.embedding_size       ,hidden_act=self.hidden_act       ,hidden_dropout_prob=self.hidden_dropout_prob       ,attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,max_position_embeddings=self.max_position_embeddings       ,type_vocab_size=self.type_vocab_size       ,is_decoder=_SCREAMING_SNAKE_CASE       ,initializer_range=self.initializer_range       ,)





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )			->		List[Any]:
         UpperCAmelCase_      :							Dict       =      MobileBertModel(config=_SCREAMING_SNAKE_CASE  )
         model.to(_SCREAMING_SNAKE_CASE  )
         model.eval()
         UpperCAmelCase_      :							Union[str, Any]       =      model(_SCREAMING_SNAKE_CASE       ,attention_mask=_SCREAMING_SNAKE_CASE       ,token_type_ids=_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Union[str, Any]       =      model(_SCREAMING_SNAKE_CASE       ,token_type_ids=_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Dict       =      model(_SCREAMING_SNAKE_CASE  )

         self.parent.assertEqual(result.last_hidden_state.shape       ,(self.batch_size, self.seq_length, self.hidden_size)  )
         self.parent.assertEqual(result.pooler_output.shape       ,(self.batch_size, 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  )			->		int:
         UpperCAmelCase_      :							Optional[int]       =      MobileBertForMaskedLM(config=_SCREAMING_SNAKE_CASE  )
         model.to(_SCREAMING_SNAKE_CASE  )
         model.eval()
         UpperCAmelCase_      :							Any       =      model(_SCREAMING_SNAKE_CASE       ,attention_mask=_SCREAMING_SNAKE_CASE       ,token_type_ids=_SCREAMING_SNAKE_CASE       ,labels=_SCREAMING_SNAKE_CASE  )
         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  )			->		List[str]:
         UpperCAmelCase_      :							int       =      MobileBertForNextSentencePrediction(config=_SCREAMING_SNAKE_CASE  )
         model.to(_SCREAMING_SNAKE_CASE  )
         model.eval()
         UpperCAmelCase_      :							str       =      model(
             _SCREAMING_SNAKE_CASE       ,attention_mask=_SCREAMING_SNAKE_CASE       ,token_type_ids=_SCREAMING_SNAKE_CASE       ,labels=_SCREAMING_SNAKE_CASE       ,)
         self.parent.assertEqual(result.logits.shape       ,(self.batch_size, 2)  )





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )			->		Tuple:
         UpperCAmelCase_      :							Optional[int]       =      MobileBertForPreTraining(config=_SCREAMING_SNAKE_CASE  )
         model.to(_SCREAMING_SNAKE_CASE  )
         model.eval()
         UpperCAmelCase_      :							Optional[int]       =      model(
             _SCREAMING_SNAKE_CASE       ,attention_mask=_SCREAMING_SNAKE_CASE       ,token_type_ids=_SCREAMING_SNAKE_CASE       ,labels=_SCREAMING_SNAKE_CASE       ,next_sentence_label=_SCREAMING_SNAKE_CASE       ,)
         self.parent.assertEqual(result.prediction_logits.shape       ,(self.batch_size, self.seq_length, self.vocab_size)  )
         self.parent.assertEqual(result.seq_relationship_logits.shape       ,(self.batch_size, 2)  )





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )			->		Dict:
         UpperCAmelCase_      :							str       =      MobileBertForQuestionAnswering(config=_SCREAMING_SNAKE_CASE  )
         model.to(_SCREAMING_SNAKE_CASE  )
         model.eval()
         UpperCAmelCase_      :							Optional[int]       =      model(
             _SCREAMING_SNAKE_CASE       ,attention_mask=_SCREAMING_SNAKE_CASE       ,token_type_ids=_SCREAMING_SNAKE_CASE       ,start_positions=_SCREAMING_SNAKE_CASE       ,end_positions=_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  )			->		Union[str, Any]:
         UpperCAmelCase_      :							List[str]       =      self.num_labels
         UpperCAmelCase_      :							Optional[Any]       =      MobileBertForSequenceClassification(_SCREAMING_SNAKE_CASE  )
         model.to(_SCREAMING_SNAKE_CASE  )
         model.eval()
         UpperCAmelCase_      :							Dict       =      model(_SCREAMING_SNAKE_CASE       ,attention_mask=_SCREAMING_SNAKE_CASE       ,token_type_ids=_SCREAMING_SNAKE_CASE       ,labels=_SCREAMING_SNAKE_CASE  )
         self.parent.assertEqual(result.logits.shape       ,(self.batch_size, 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  )			->		List[str]:
         UpperCAmelCase_      :							List[Any]       =      self.num_labels
         UpperCAmelCase_      :							List[str]       =      MobileBertForTokenClassification(config=_SCREAMING_SNAKE_CASE  )
         model.to(_SCREAMING_SNAKE_CASE  )
         model.eval()
         UpperCAmelCase_      :							Tuple       =      model(_SCREAMING_SNAKE_CASE       ,attention_mask=_SCREAMING_SNAKE_CASE       ,token_type_ids=_SCREAMING_SNAKE_CASE       ,labels=_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  )			->		Dict:
         UpperCAmelCase_      :							Optional[Any]       =      self.num_choices
         UpperCAmelCase_      :							List[str]       =      MobileBertForMultipleChoice(config=_SCREAMING_SNAKE_CASE  )
         model.to(_SCREAMING_SNAKE_CASE  )
         model.eval()
         UpperCAmelCase_      :							str       =      input_ids.unsqueeze(1  ).expand(-1       ,self.num_choices       ,-1  ).contiguous()
         UpperCAmelCase_      :							List[Any]       =      token_type_ids.unsqueeze(1  ).expand(-1       ,self.num_choices       ,-1  ).contiguous()
         UpperCAmelCase_      :							str       =      input_mask.unsqueeze(1  ).expand(-1       ,self.num_choices       ,-1  ).contiguous()
         UpperCAmelCase_      :							List[str]       =      model(
             _SCREAMING_SNAKE_CASE       ,attention_mask=_SCREAMING_SNAKE_CASE       ,token_type_ids=_SCREAMING_SNAKE_CASE       ,labels=_SCREAMING_SNAKE_CASE       ,)
         self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.num_choices)  )





    def 							a__				(				self  )			->		Tuple:
         UpperCAmelCase_      :							str       =      self.prepare_config_and_inputs()
         (
             (
             UpperCAmelCase_
         ),   (
             UpperCAmelCase_
         ),   (
             UpperCAmelCase_
         ),   (
             UpperCAmelCase_
         ),   (
             UpperCAmelCase_
         ),   (
             UpperCAmelCase_
         ),   (
             UpperCAmelCase_
         ),   
         )      :							Union[str, Any]       =      config_and_inputs
         UpperCAmelCase_      :							Union[str, Any]       =      {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
         return config, inputs_dict


@require_torch
class   __a(					_a    ,						_a    ,						unittest.TestCase       ):






    """simple docstring"""





    lowerCAmelCase        =				(
        (
            MobileBertModel,
            MobileBertForMaskedLM,
            MobileBertForMultipleChoice,
            MobileBertForNextSentencePrediction,
            MobileBertForPreTraining,
            MobileBertForQuestionAnswering,
            MobileBertForSequenceClassification,
            MobileBertForTokenClassification,
        )
        if is_torch_available()
        else ()
    )
    lowerCAmelCase        =				(
        {
            '''feature-extraction''': MobileBertModel,
            '''fill-mask''': MobileBertForMaskedLM,
            '''question-answering''': MobileBertForQuestionAnswering,
            '''text-classification''': MobileBertForSequenceClassification,
            '''token-classification''': MobileBertForTokenClassification,
            '''zero-shot''': MobileBertForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    lowerCAmelCase        =				True





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE=False  )			->		List[str]:
         UpperCAmelCase_      :							Any       =      super()._prepare_for_class(_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,return_labels=_SCREAMING_SNAKE_CASE  )

         if return_labels:
              if model_class in get_values(_SCREAMING_SNAKE_CASE  ):
                   UpperCAmelCase_      :							str       =      torch.zeros(
                       (self.model_tester.batch_size, self.model_tester.seq_length)       ,dtype=torch.long       ,device=_SCREAMING_SNAKE_CASE  )
                   UpperCAmelCase_      :							List[str]       =      torch.zeros(
                       self.model_tester.batch_size       ,dtype=torch.long       ,device=_SCREAMING_SNAKE_CASE  )
         return inputs_dict





    def 							a__				(				self  )			->		int:
         UpperCAmelCase_      :							Any       =      MobileBertModelTester(self  )
         UpperCAmelCase_      :							int       =      ConfigTester(self       ,config_class=_SCREAMING_SNAKE_CASE       ,hidden_size=37  )





    def 							a__				(				self  )			->		Any:
         self.config_tester.run_common_tests()





    def 							a__				(				self  )			->		Any:
         UpperCAmelCase_      :							Tuple       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_model(*_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self  )			->		List[Any]:
         UpperCAmelCase_      :							List[Any]       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_masked_lm(*_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self  )			->		int:
         UpperCAmelCase_      :							List[str]       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_multiple_choice(*_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self  )			->		str:
         UpperCAmelCase_      :							Dict       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self  )			->		int:
         UpperCAmelCase_      :							List[str]       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_pretraining(*_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self  )			->		Any:
         UpperCAmelCase_      :							Union[str, Any]       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_question_answering(*_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self  )			->		List[Any]:
         UpperCAmelCase_      :							Union[str, Any]       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_sequence_classification(*_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self  )			->		List[str]:
         UpperCAmelCase_      :							int       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mobilebert_for_token_classification(*_SCREAMING_SNAKE_CASE  )







def lowerCamelCase__       (      _lowercase				):

     '''simple docstring'''


     return torch.tensor(
         _lowercase			,						dtype=torch.long			,						device=_lowercase			,						)


__a          =			1E-3



@require_torch
@require_sentencepiece
@require_tokenizers
class   __a(					unittest.TestCase       ):






    """simple docstring"""





    @slow
    def 							a__				(				self  )			->		Tuple:
         UpperCAmelCase_      :							int       =      MobileBertModel.from_pretrained('''google/mobilebert-uncased'''  ).to(_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Dict       =      _long_tensor([[101, 7_110, 1_005, 1_056, 2_023, 11_333, 17_413, 1_029, 102]]  )
         with torch.no_grad():
              UpperCAmelCase_      :							List[str]       =      model(_SCREAMING_SNAKE_CASE  )[0]
         UpperCAmelCase_      :							Tuple       =      torch.Size((1, 9, 512)  )
         self.assertEqual(output.shape       ,_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Optional[Any]       =      torch.tensor(
             [
                 [
                     [-2.4_73_65_26e07, 8.2_69_16_56e04, 1.6_52_18_38e05],
                     [-5.7_54_17_04e-01, 3.9_05_60_22e00, 4.4_01_15_07e00],
                     [2.6_04_73_59e00, 1.5_67_76_52e00, -1.7_32_41_88e-01],
                 ]
             ]       ,device=_SCREAMING_SNAKE_CASE       ,)

         # MobileBERT results range from 10e0 to 10e8. Even a 0.0000001% difference with a value of 10e8 results in a
         # ~1 difference, it's therefore not a good idea to measure using addition.
         # Here, we instead divide the expected result with the result in order to obtain ~1. We then check that the
         # result is held between bounds: 1 - TOLERANCE < expected_result / result < 1 + TOLERANCE
         UpperCAmelCase_      :							int       =      torch.all((expected_slice / output[..., :3, :3]) >= 1 - TOLERANCE  )
         UpperCAmelCase_      :							Any       =      torch.all((expected_slice / output[..., :3, :3]) <= 1 + TOLERANCE  )

         self.assertTrue(lower_bound and upper_bound  )





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_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
     import PIL


__a          =			logging.get_logger(__name__)







def lowerCamelCase__       (      _lowercase				):

     '''simple docstring'''


     if isinstance(_lowercase			,						(list, tuple)				) and isinstance(videos[0]			,						(list, tuple)				) and is_valid_image(videos[0][0]				):
          return videos

     elif isinstance(_lowercase			,						(list, tuple)				) and is_valid_image(videos[0]				):
          return [videos]

     elif is_valid_image(_lowercase				):
          return [[videos]]

     raise ValueError(f'''Could not make batched video from {videos}'''				)



class   __a(					_a       ):






    """simple docstring"""





    lowerCAmelCase        =				['''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 = None       ,_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:
         super().__init__(**_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							int       =      size if size is not None else {'''shortest_edge''': 224}
         UpperCAmelCase_      :							Any       =      get_size_dict(_SCREAMING_SNAKE_CASE       ,default_to_square=_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Any       =      crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
         UpperCAmelCase_      :							List[str]       =      get_size_dict(_SCREAMING_SNAKE_CASE       ,param_name='''crop_size'''  )

         UpperCAmelCase_      :							str       =      do_resize
         UpperCAmelCase_      :							Union[str, Any]       =      size
         UpperCAmelCase_      :							int       =      do_center_crop
         UpperCAmelCase_      :							List[str]       =      crop_size
         UpperCAmelCase_      :							Optional[int]       =      resample
         UpperCAmelCase_      :							List[Any]       =      do_rescale
         UpperCAmelCase_      :							Tuple       =      rescale_factor
         UpperCAmelCase_      :							Optional[Any]       =      do_normalize
         UpperCAmelCase_      :							int       =      image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
         UpperCAmelCase_      :							Optional[int]       =      image_std if image_std is not None else IMAGENET_STANDARD_STD





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE = PILImageResampling.BILINEAR       ,_SCREAMING_SNAKE_CASE = None       ,**_SCREAMING_SNAKE_CASE       ,)			->		np.ndarray:
         UpperCAmelCase_      :							Optional[int]       =      get_size_dict(_SCREAMING_SNAKE_CASE       ,default_to_square=_SCREAMING_SNAKE_CASE  )
         if "shortest_edge" in size:
              UpperCAmelCase_      :							Dict       =      get_resize_output_image_size(_SCREAMING_SNAKE_CASE       ,size['''shortest_edge''']       ,default_to_square=_SCREAMING_SNAKE_CASE  )
         elif "height" in size and "width" in size:
              UpperCAmelCase_      :							Tuple       =      (size['''height'''], size['''width'''])
         else:
              raise ValueError(f'''Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}'''  )
         return resize(_SCREAMING_SNAKE_CASE       ,size=_SCREAMING_SNAKE_CASE       ,resample=_SCREAMING_SNAKE_CASE       ,data_format=_SCREAMING_SNAKE_CASE       ,**_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE = None       ,**_SCREAMING_SNAKE_CASE       ,)			->		np.ndarray:
         UpperCAmelCase_      :							str       =      get_size_dict(_SCREAMING_SNAKE_CASE  )
         if "height" not in size or "width" not in size:
              raise ValueError(f'''Size must have \'height\' and \'width\' as keys. Got {size.keys()}'''  )
         return center_crop(_SCREAMING_SNAKE_CASE       ,size=(size['''height'''], size['''width'''])       ,data_format=_SCREAMING_SNAKE_CASE       ,**_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE = None       ,**_SCREAMING_SNAKE_CASE       ,)			->		Dict:
         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:
         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 = None       ,_SCREAMING_SNAKE_CASE = None       ,_SCREAMING_SNAKE_CASE = None       ,_SCREAMING_SNAKE_CASE = None       ,_SCREAMING_SNAKE_CASE = ChannelDimension.FIRST       ,)			->		np.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_size is None:
              raise ValueError('''Crop size 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.
         UpperCAmelCase_      :							Any       =      to_numpy_array(_SCREAMING_SNAKE_CASE  )

         if do_resize:
              UpperCAmelCase_      :							Union[str, Any]       =      self.resize(image=_SCREAMING_SNAKE_CASE       ,size=_SCREAMING_SNAKE_CASE       ,resample=_SCREAMING_SNAKE_CASE  )

         if do_center_crop:
              UpperCAmelCase_      :							Optional[int]       =      self.center_crop(_SCREAMING_SNAKE_CASE       ,size=_SCREAMING_SNAKE_CASE  )

         if do_rescale:
              UpperCAmelCase_      :							str       =      self.rescale(image=_SCREAMING_SNAKE_CASE       ,scale=_SCREAMING_SNAKE_CASE  )

         if do_normalize:
              UpperCAmelCase_      :							List[Any]       =      self.normalize(image=_SCREAMING_SNAKE_CASE       ,mean=_SCREAMING_SNAKE_CASE       ,std=_SCREAMING_SNAKE_CASE  )

         UpperCAmelCase_      :							Optional[int]       =      to_channel_dimension_format(_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )
         return image





    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 = 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:
         UpperCAmelCase_      :							Dict       =      do_resize if do_resize is not None else self.do_resize
         UpperCAmelCase_      :							int       =      resample if resample is not None else self.resample
         UpperCAmelCase_      :							List[str]       =      do_center_crop if do_center_crop is not None else self.do_center_crop
         UpperCAmelCase_      :							Optional[Any]       =      do_rescale if do_rescale is not None else self.do_rescale
         UpperCAmelCase_      :							List[Any]       =      rescale_factor if rescale_factor is not None else self.rescale_factor
         UpperCAmelCase_      :							Tuple       =      do_normalize if do_normalize is not None else self.do_normalize
         UpperCAmelCase_      :							Optional[int]       =      image_mean if image_mean is not None else self.image_mean
         UpperCAmelCase_      :							Optional[int]       =      image_std if image_std is not None else self.image_std

         UpperCAmelCase_      :							List[str]       =      size if size is not None else self.size
         UpperCAmelCase_      :							Optional[int]       =      get_size_dict(_SCREAMING_SNAKE_CASE       ,default_to_square=_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							List[str]       =      crop_size if crop_size is not None else self.crop_size
         UpperCAmelCase_      :							Any       =      get_size_dict(_SCREAMING_SNAKE_CASE       ,param_name='''crop_size'''  )

         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.'''  )

         UpperCAmelCase_      :							List[Any]       =      make_batched(_SCREAMING_SNAKE_CASE  )

         UpperCAmelCase_      :							str       =      [
             [
                 self._preprocess_image(
                     image=_SCREAMING_SNAKE_CASE       ,do_resize=_SCREAMING_SNAKE_CASE       ,size=_SCREAMING_SNAKE_CASE       ,resample=_SCREAMING_SNAKE_CASE       ,do_center_crop=_SCREAMING_SNAKE_CASE       ,crop_size=_SCREAMING_SNAKE_CASE       ,do_rescale=_SCREAMING_SNAKE_CASE       ,rescale_factor=_SCREAMING_SNAKE_CASE       ,do_normalize=_SCREAMING_SNAKE_CASE       ,image_mean=_SCREAMING_SNAKE_CASE       ,image_std=_SCREAMING_SNAKE_CASE       ,data_format=_SCREAMING_SNAKE_CASE       ,)
                 for img in video
             ]
             for video in videos
         ]

         UpperCAmelCase_      :							Any       =      {'''pixel_values''': videos}
         return BatchFeature(data=_SCREAMING_SNAKE_CASE       ,tensor_type=_SCREAMING_SNAKE_CASE  )