code: 
  
  
  import argparse
  import os
  
  import align
  import numpy as np
  import requests
  import tensorflow as tf
  import torch
  from PIL import Image
  from tokenizer import Tokenizer
  
  from transformers import (
      AlignConfig,
      AlignModel,
      AlignProcessor,
      BertConfig,
      BertTokenizer,
      EfficientNetConfig,
      EfficientNetImageProcessor,
  )
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  __snake_case             =	logging.get_logger(__name__)
  
  
  
  
  
  
  def 		_A		(		_lowercase   )				->   int:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = tf.image.resize(_lowercase				,     (3_46, 3_46)   )
       __UpperCamelCase   = tf.image.crop_to_bounding_box(_lowercase				,     (3_46 - 2_89) // 2				,     (3_46 - 2_89) // 2				,     2_89				,     2_89   )
       return image
  
  
  
  
  
  
  def 		_A		(		)				->   int:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = EfficientNetConfig.from_pretrained('google/efficientnet-b7'   )
       __UpperCamelCase   = 2_89
       __UpperCamelCase   = 6_40
       __UpperCamelCase   = {"0": "LABEL_0", "1": "LABEL_1"}
       __UpperCamelCase   = {"LABEL_0": 0, "LABEL_1": 1}
       __UpperCamelCase   = []
  
       __UpperCamelCase   = BertConfig()
       __UpperCamelCase   = AlignConfig.from_text_vision_configs(
           text_config=_lowercase				,     vision_config=_lowercase				,     projection_dim=6_40   )
       return config
  
  
  
  
  
  
  def 		_A		(		)				->   int:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = "http://images.cocodataset.org/val2017/000000039769.jpg"
       __UpperCamelCase   = Image.open(requests.get(_lowercase				,     stream=_lowercase   ).raw   )
       return im
  
  
  
  
  
  
  def 		_A		(		)				->   List[str]:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = EfficientNetImageProcessor(
           do_center_crop=_lowercase				,     rescale_factor=1 / 1_27.5				,     rescale_offset=_lowercase				,     do_normalize=_lowercase				,     include_top=_lowercase				,     resample=Image.BILINEAR				,     )
       __UpperCamelCase   = BertTokenizer.from_pretrained('bert-base-uncased'   )
       __UpperCamelCase   = 64
       __UpperCamelCase   = AlignProcessor(image_processor=_lowercase				,     tokenizer=_lowercase   )
       return processor
  
  
  
  
  
  
  def 		_A		(		_lowercase   )				->   List[Any]:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = [v.split('_'   )[0].split('block'   )[1] for v in original_param_names if v.startswith('block'   )]
       __UpperCamelCase   = list(set(_lowercase   )   )
       __UpperCamelCase   = sorted(_lowercase   )
       __UpperCamelCase   = len(_lowercase   )
       __UpperCamelCase   = {b: str(_lowercase   ) for b, i in zip(_lowercase				,     range(_lowercase   )   )}
  
       __UpperCamelCase   = []
       rename_keys.append(('stem_conv/kernel:0', 'embeddings.convolution.weight')   )
       rename_keys.append(('stem_bn/gamma:0', 'embeddings.batchnorm.weight')   )
       rename_keys.append(('stem_bn/beta:0', 'embeddings.batchnorm.bias')   )
       rename_keys.append(('stem_bn/moving_mean:0', 'embeddings.batchnorm.running_mean')   )
       rename_keys.append(('stem_bn/moving_variance:0', 'embeddings.batchnorm.running_var')   )
  
       for b in block_names:
            __UpperCamelCase   = block_name_mapping[b]
            rename_keys.append((f'''block{b}_expand_conv/kernel:0''', f'''encoder.blocks.{hf_b}.expansion.expand_conv.weight''')   )
            rename_keys.append((f'''block{b}_expand_bn/gamma:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.weight''')   )
            rename_keys.append((f'''block{b}_expand_bn/beta:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.bias''')   )
            rename_keys.append(
                (f'''block{b}_expand_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_mean''')   )
            rename_keys.append(
                (f'''block{b}_expand_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_var''')   )
            rename_keys.append(
                (f'''block{b}_dwconv/depthwise_kernel:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight''')   )
            rename_keys.append((f'''block{b}_bn/gamma:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight''')   )
            rename_keys.append((f'''block{b}_bn/beta:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias''')   )
            rename_keys.append(
                (f'''block{b}_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean''')   )
            rename_keys.append(
                (f'''block{b}_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var''')   )
  
            rename_keys.append((f'''block{b}_se_reduce/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.weight''')   )
            rename_keys.append((f'''block{b}_se_reduce/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.bias''')   )
            rename_keys.append((f'''block{b}_se_expand/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.weight''')   )
            rename_keys.append((f'''block{b}_se_expand/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.bias''')   )
            rename_keys.append(
                (f'''block{b}_project_conv/kernel:0''', f'''encoder.blocks.{hf_b}.projection.project_conv.weight''')   )
            rename_keys.append((f'''block{b}_project_bn/gamma:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.weight''')   )
            rename_keys.append((f'''block{b}_project_bn/beta:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.bias''')   )
            rename_keys.append(
                (f'''block{b}_project_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_mean''')   )
            rename_keys.append(
                (f'''block{b}_project_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_var''')   )
  
       __UpperCamelCase   = {}
       for item in rename_keys:
            if item[0] in original_param_names:
                 __UpperCamelCase   = "vision_model." + item[1]
  
      # BERT text encoder
       __UpperCamelCase   = []
       __UpperCamelCase   = "tf_bert_model/bert"
       __UpperCamelCase   = "text_model"
       for i in range(12   ):
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/self/query/kernel:0''',
                    f'''{new}.encoder.layer.{i}.attention.self.query.weight''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/self/query/bias:0''',
                    f'''{new}.encoder.layer.{i}.attention.self.query.bias''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/self/key/kernel:0''',
                    f'''{new}.encoder.layer.{i}.attention.self.key.weight''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/self/key/bias:0''',
                    f'''{new}.encoder.layer.{i}.attention.self.key.bias''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/self/value/kernel:0''',
                    f'''{new}.encoder.layer.{i}.attention.self.value.weight''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/self/value/bias:0''',
                    f'''{new}.encoder.layer.{i}.attention.self.value.bias''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/output/dense/kernel:0''',
                    f'''{new}.encoder.layer.{i}.attention.output.dense.weight''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/output/dense/bias:0''',
                    f'''{new}.encoder.layer.{i}.attention.output.dense.bias''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/output/LayerNorm/gamma:0''',
                    f'''{new}.encoder.layer.{i}.attention.output.LayerNorm.weight''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/attention/output/LayerNorm/beta:0''',
                    f'''{new}.encoder.layer.{i}.attention.output.LayerNorm.bias''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/intermediate/dense/kernel:0''',
                    f'''{new}.encoder.layer.{i}.intermediate.dense.weight''',
                )   )
            rename_keys.append(
                (
                    f'''{old}/encoder/layer_._{i}/intermediate/dense/bias:0''',
                    f'''{new}.encoder.layer.{i}.intermediate.dense.bias''',
                )   )
            rename_keys.append(
                (f'''{old}/encoder/layer_._{i}/output/dense/kernel:0''', f'''{new}.encoder.layer.{i}.output.dense.weight''')   )
            rename_keys.append(
                (f'''{old}/encoder/layer_._{i}/output/dense/bias:0''', f'''{new}.encoder.layer.{i}.output.dense.bias''')   )
            rename_keys.append(
                (f'''{old}/encoder/layer_._{i}/output/LayerNorm/gamma:0''', f'''{new}.encoder.layer.{i}.output.LayerNorm.weight''')   )
            rename_keys.append(
                (f'''{old}/encoder/layer_._{i}/output/LayerNorm/beta:0''', f'''{new}.encoder.layer.{i}.output.LayerNorm.bias''')   )
  
       rename_keys.append((f'''{old}/embeddings/word_embeddings/weight:0''', f'''{new}.embeddings.word_embeddings.weight''')   )
       rename_keys.append(
           (f'''{old}/embeddings/position_embeddings/embeddings:0''', f'''{new}.embeddings.position_embeddings.weight''')   )
       rename_keys.append(
           (f'''{old}/embeddings/token_type_embeddings/embeddings:0''', f'''{new}.embeddings.token_type_embeddings.weight''')   )
       rename_keys.append((f'''{old}/embeddings/LayerNorm/gamma:0''', f'''{new}.embeddings.LayerNorm.weight''')   )
       rename_keys.append((f'''{old}/embeddings/LayerNorm/beta:0''', f'''{new}.embeddings.LayerNorm.bias''')   )
  
       rename_keys.append((f'''{old}/pooler/dense/kernel:0''', f'''{new}.pooler.dense.weight''')   )
       rename_keys.append((f'''{old}/pooler/dense/bias:0''', f'''{new}.pooler.dense.bias''')   )
       rename_keys.append(('dense/kernel:0', 'text_projection.weight')   )
       rename_keys.append(('dense/bias:0', 'text_projection.bias')   )
       rename_keys.append(('dense/bias:0', 'text_projection.bias')   )
       rename_keys.append(('temperature:0', 'temperature')   )
  
       for item in rename_keys:
            if item[0] in original_param_names:
                 __UpperCamelCase   = item[1]
       return key_mapping
  
  
  
  
  
  
  def 		_A		(		_lowercase				,     _lowercase				,     _lowercase   )				->   List[Any]:
  
  
       """simple docstring"""
  
  
       list(hf_params.keys()   )
  
       for key, value in tf_params.items():
            if key not in key_mapping:
                 continue
  
            __UpperCamelCase   = key_mapping[key]
            if "_conv" in key and "kernel" in key:
                 __UpperCamelCase   = torch.from_numpy(_lowercase   ).permute(3				,     2				,     0				,     1   )
            elif "embeddings" in key:
                 __UpperCamelCase   = torch.from_numpy(_lowercase   )
            elif "depthwise_kernel" in key:
                 __UpperCamelCase   = torch.from_numpy(_lowercase   ).permute(2				,     3				,     0				,     1   )
            elif "kernel" in key:
                 __UpperCamelCase   = torch.from_numpy(np.transpose(_lowercase   )   )
            elif "temperature" in key:
                 __UpperCamelCase   = value
            elif "bn/gamma" or "bn/beta" in key:
                 __UpperCamelCase   = torch.from_numpy(np.transpose(_lowercase   )   ).squeeze()
            else:
                 __UpperCamelCase   = torch.from_numpy(_lowercase   )
  
            # Replace HF parameters with original TF model parameters
            hf_params[hf_key].copy_(_lowercase   )
  
  
  
  
  
  
  @torch.no_grad()
  def 		_A		(		_lowercase				,     _lowercase				,     _lowercase				,     _lowercase   )				->   int:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = 64
       __UpperCamelCase   = Tokenizer(_lowercase   )
       __UpperCamelCase   = align.Align('efficientnet-b7'				,     'bert-base'				,     6_40				,     _lowercase				,     tok.get_vocab_size()   )
       original_model.compile()
       original_model.load_weights(_lowercase   )
  
       __UpperCamelCase   = original_model.trainable_variables
       __UpperCamelCase   = original_model.non_trainable_variables
       __UpperCamelCase   = {param.name: param.numpy() for param in tf_params}
       for param in tf_non_train_params:
            __UpperCamelCase   = param.numpy()
       __UpperCamelCase   = list(tf_params.keys()   )
  
       # Load HuggingFace model
       __UpperCamelCase   = get_align_config()
       __UpperCamelCase   = AlignModel(_lowercase   ).eval()
       __UpperCamelCase   = hf_model.state_dict()
  
       # Create src-to-dst parameter name mapping dictionary
       print('Converting parameters...'   )
       __UpperCamelCase   = rename_keys(_lowercase   )
       replace_params(_lowercase				,     _lowercase				,     _lowercase   )
  
       # Initialize processor
       __UpperCamelCase   = get_processor()
       __UpperCamelCase   = processor(
           images=prepare_img()				,     text='A picture of a cat'				,     padding='max_length'				,     max_length=64				,     return_tensors='pt'   )
  
       # HF model inference
       hf_model.eval()
       with torch.no_grad():
            __UpperCamelCase   = hf_model(**_lowercase   )
  
       __UpperCamelCase   = outputs.image_embeds.detach().numpy()
       __UpperCamelCase   = outputs.text_embeds.detach().numpy()
  
       # Original model inference
       __UpperCamelCase   = False
       __UpperCamelCase   = EfficientNetImageProcessor(
           do_center_crop=_lowercase				,     do_rescale=_lowercase				,     do_normalize=_lowercase				,     include_top=_lowercase				,     resample=Image.BILINEAR				,     )
       __UpperCamelCase   = tf_image_processor(images=prepare_img()				,     return_tensors='tf'				,     data_format='channels_last'   )["pixel_values"]
       __UpperCamelCase   = tok(tf.constant(['A picture of a cat']   )   )
  
       __UpperCamelCase   = original_model.image_encoder(_lowercase				,     training=_lowercase   )
       __UpperCamelCase   = original_model.text_encoder(_lowercase				,     training=_lowercase   )
  
       __UpperCamelCase   = tf.nn.la_normalize(_lowercase				,     axis=-1   )
       __UpperCamelCase   = tf.nn.la_normalize(_lowercase				,     axis=-1   )
  
       # Check whether original and HF model outputs match  -> np.allclose
       if not np.allclose(_lowercase				,     _lowercase				,     atol=1e-3   ):
            raise ValueError('The predicted image features are not the same.'   )
       if not np.allclose(_lowercase				,     _lowercase				,     atol=1e-3   ):
            raise ValueError('The predicted text features are not the same.'   )
       print('Model outputs match!'   )
  
       if save_model:
            # Create folder to save model
            if not os.path.isdir(_lowercase   ):
                 os.mkdir(_lowercase   )
            # Save converted model and image processor
            hf_model.save_pretrained(_lowercase   )
            processor.save_pretrained(_lowercase   )
  
       if push_to_hub:
            # Push model and image processor to hub
            print('Pushing converted ALIGN to the hub...'   )
            processor.push_to_hub('align-base'   )
            hf_model.push_to_hub('align-base'   )
  
  
  if __name__ == "__main__":
      __snake_case             =	argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '''--checkpoint_path''',
          default='''./weights/model-weights''',
          type=str,
          help='''Path to the pretrained TF ALIGN checkpoint.''',
      )
      parser.add_argument(
          '''--pytorch_dump_folder_path''',
          default='''hf_model''',
          type=str,
          help='''Path to the output PyTorch model directory.''',
      )
      parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
      parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')
  
      __snake_case             =	parser.parse_args()
      convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)
  
  
  
style_context: 
  
  
  import unittest
  
  import numpy as np
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
  
  
  if is_torch_available():
      import torch
  
  if is_vision_available():
      from PIL import Image
  
      from transformers import DeiTImageProcessor
  
  
  
  class   __lowerCamelCase (unittest.TestCase	):
  
  
  
  
  
  
  
         def __init__( self:   List[str],A_:   List[Any],A_:   List[Any]=7,A_:   str=3,A_:   Tuple=18,A_:   Union[str, Any]=30,A_:   Union[str, Any]=400,A_:   List[str]=True,A_:   List[Any]=None,A_:   Tuple=True,A_:   Union[str, Any]=None,A_:   int=True,A_:   Any=[0.5, 0.5, 0.5],A_:   Optional[Any]=[0.5, 0.5, 0.5],):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = size if size is not None else {'height': 20, 'width': 20}
              __UpperCamelCase   = crop_size if crop_size is not None else {'height': 18, 'width': 18}
  
              __UpperCamelCase   = parent
              __UpperCamelCase   = batch_size
              __UpperCamelCase   = num_channels
              __UpperCamelCase   = image_size
              __UpperCamelCase   = min_resolution
              __UpperCamelCase   = max_resolution
              __UpperCamelCase   = do_resize
              __UpperCamelCase   = size
              __UpperCamelCase   = do_center_crop
              __UpperCamelCase   = crop_size
              __UpperCamelCase   = do_normalize
              __UpperCamelCase   = image_mean
              __UpperCamelCase   = image_std
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return {
                  "do_resize": self.do_resize,
                  "size": self.size,
                  "do_center_crop": self.do_center_crop,
                  "crop_size": self.crop_size,
                  "do_normalize": self.do_normalize,
                  "image_mean": self.image_mean,
                  "image_std": self.image_std,
              }
  
  
  
  @require_torch
  @require_vision
  class   __lowerCamelCase (_a							,			unittest.TestCase	):
         _lowercase       							=    DeiTImageProcessor if is_vision_available() else None
         _lowercase       							=    True
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = DeiTImageProcessingTester(self				)
  
  
  
  
  
  
  
         @property
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Union[str, Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class(**self.image_processor_dict				)
              self.assertTrue(hasattr(A_,'do_resize'				)				)
              self.assertTrue(hasattr(A_,'size'				)				)
              self.assertTrue(hasattr(A_,'do_center_crop'				)				)
              self.assertTrue(hasattr(A_,'center_crop'				)				)
              self.assertTrue(hasattr(A_,'do_normalize'				)				)
              self.assertTrue(hasattr(A_,'image_mean'				)				)
              self.assertTrue(hasattr(A_,'image_std'				)				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class.from_dict(self.image_processor_dict				)
              self.assertEqual(image_processor.size,{'height': 20, 'width': 20}				)
              self.assertEqual(image_processor.crop_size,{'height': 18, 'width': 18}				)
  
              __UpperCamelCase   = self.image_processing_class.from_dict(self.image_processor_dict,size=42,crop_size=84				)
              self.assertEqual(image_processor.size,{'height': 42, 'width': 42}				)
              self.assertEqual(image_processor.crop_size,{'height': 84, 'width': 84}				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Tuple				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              pass
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class(**self.image_processor_dict				)
              # create random PIL images
              __UpperCamelCase   = prepare_image_inputs(self.image_processor_tester,equal_resolution=A_				)
              for image in image_inputs:
                   self.assertIsInstance(A_,Image.Image				)
  
              # Test not batched input
              __UpperCamelCase   = image_processing(image_inputs[0],return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      1,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
              # Test batched
              __UpperCamelCase   = image_processing(A_,return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      self.image_processor_tester.batch_size,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class(**self.image_processor_dict				)
              # create random numpy tensors
              __UpperCamelCase   = prepare_image_inputs(self.image_processor_tester,equal_resolution=A_,numpify=A_				)
              for image in image_inputs:
                   self.assertIsInstance(A_,np.ndarray				)
  
              # Test not batched input
              __UpperCamelCase   = image_processing(image_inputs[0],return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      1,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
              # Test batched
              __UpperCamelCase   = image_processing(A_,return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      self.image_processor_tester.batch_size,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.image_processing_class(**self.image_processor_dict				)
              # create random PyTorch tensors
              __UpperCamelCase   = prepare_image_inputs(self.image_processor_tester,equal_resolution=A_,torchify=A_				)
              for image in image_inputs:
                   self.assertIsInstance(A_,torch.Tensor				)
  
              # Test not batched input
              __UpperCamelCase   = image_processing(image_inputs[0],return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      1,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
              # Test batched
              __UpperCamelCase   = image_processing(A_,return_tensors='pt'				).pixel_values
              self.assertEqual(
                  encoded_images.shape,(
                      self.image_processor_tester.batch_size,
                      self.image_processor_tester.num_channels,
                      self.image_processor_tester.crop_size['height'],
                      self.image_processor_tester.crop_size['width'],
                  ),)
  
  
  