code: 
  
  import argparse
  import json
  from pathlib import Path
  
  import requests
  import torch
  from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
  from PIL import Image
  
  from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  lowerCamelCase     =      logging.get_logger(__name__)
  
  
  
  
  def     UpperCAmelCase__       (    ):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						=DetaConfig(
        num_queries=9_00			,   encoder_ffn_dim=20_48			,   decoder_ffn_dim=20_48			,   num_feature_levels=5			,   assign_first_stage=_A			,   with_box_refine=_A			,   two_stage=_A			,   )
  
    # set labels
    a__						=91
    a__						='''huggingface/label-files'''
    a__						='''coco-detection-id2label.json'''
    a__						=json.load(open(cached_download(hf_hub_url(_A			,   _A			,   repo_type='''dataset'''							)							)			,   '''r'''							)							)
    a__						={int(_A							): v for k, v in idalabel.items()}
    a__						=idalabel
    a__						={v: k for k, v in idalabel.items()}
  
    return config
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				int							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						=[]
  
    # stem
    # fmt: off
    rename_keys.append(('''backbone.0.body.conv1.weight''', '''model.backbone.model.embedder.embedder.convolution.weight''')							)
    rename_keys.append(('''backbone.0.body.bn1.weight''', '''model.backbone.model.embedder.embedder.normalization.weight''')							)
    rename_keys.append(('''backbone.0.body.bn1.bias''', '''model.backbone.model.embedder.embedder.normalization.bias''')							)
    rename_keys.append(('''backbone.0.body.bn1.running_mean''', '''model.backbone.model.embedder.embedder.normalization.running_mean''')							)
    rename_keys.append(('''backbone.0.body.bn1.running_var''', '''model.backbone.model.embedder.embedder.normalization.running_var''')							)
    # stages
    for stage_idx in range(len(config.backbone_config.depths							)							):
      for layer_idx in range(config.backbone_config.depths[stage_idx]							):
        # shortcut
        if layer_idx == 0:
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight""",
              )							)
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight""",
              )							)
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias""",
              )							)
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean""",
              )							)
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var""",
              )							)
        # 3 convs
        for i in range(3							):
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight""",
              )							)
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight""",
              )							)
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias""",
              )							)
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean""",
              )							)
          rename_keys.append(
              (
                  F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var""",
                  F"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var""",
              )							)
      # transformer encoder
    for i in range(config.encoder_layers							):
      rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.weight""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.bias""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.weight""", F"""model.encoder.layers.{i}.self_attn.attention_weights.weight""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.bias""", F"""model.encoder.layers.{i}.self_attn.attention_weights.bias""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.weight""", F"""model.encoder.layers.{i}.self_attn.value_proj.weight""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.bias""", F"""model.encoder.layers.{i}.self_attn.value_proj.bias""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.weight""", F"""model.encoder.layers.{i}.self_attn.output_proj.weight""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.bias""", F"""model.encoder.layers.{i}.self_attn.output_proj.bias""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.weight""", F"""model.encoder.layers.{i}.self_attn_layer_norm.weight""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.bias""", F"""model.encoder.layers.{i}.self_attn_layer_norm.bias""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.weight""", F"""model.encoder.layers.{i}.fc1.weight""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.bias""", F"""model.encoder.layers.{i}.fc1.bias""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.weight""", F"""model.encoder.layers.{i}.fc2.weight""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.bias""", F"""model.encoder.layers.{i}.fc2.bias""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.weight""", F"""model.encoder.layers.{i}.final_layer_norm.weight""")							)
      rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.bias""", F"""model.encoder.layers.{i}.final_layer_norm.bias""")							)
  
    # transformer decoder
    for i in range(config.decoder_layers							):
      rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.weight""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.bias""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.bias""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.bias""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.bias""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.weight""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.bias""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.bias""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", F"""model.decoder.layers.{i}.self_attn.out_proj.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", F"""model.decoder.layers.{i}.self_attn.out_proj.bias""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.weight""", F"""model.decoder.layers.{i}.self_attn_layer_norm.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.bias""", F"""model.decoder.layers.{i}.self_attn_layer_norm.bias""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.weight""", F"""model.decoder.layers.{i}.fc1.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.bias""", F"""model.decoder.layers.{i}.fc1.bias""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.weight""", F"""model.decoder.layers.{i}.fc2.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.bias""", F"""model.decoder.layers.{i}.fc2.bias""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.weight""", F"""model.decoder.layers.{i}.final_layer_norm.weight""")							)
      rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.bias""", F"""model.decoder.layers.{i}.final_layer_norm.bias""")							)
  
    # fmt: on
  
    return rename_keys
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				int			,   _A   :				str			,   _A   :				List[str]							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						=dct.pop(_A							)
    a__						=val
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				int			,   _A   :				str							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						=config.d_model
    for i in range(config.decoder_layers							):
      # read in weights + bias of input projection layer of self-attention
      a__						=state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_weight"""							)
      a__						=state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_bias"""							)
      # next, add query, keys and values (in that order) to the state dict
      a__						=in_proj_weight[:hidden_size, :]
      a__						=in_proj_bias[:hidden_size]
      a__						=in_proj_weight[
          hidden_size : hidden_size * 2, :
      ]
      a__						=in_proj_bias[hidden_size : hidden_size * 2]
      a__						=in_proj_weight[-hidden_size:, :]
      a__						=in_proj_bias[-hidden_size:]
  
  
  
  
  def     UpperCAmelCase__       (    ):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						='''http://images.cocodataset.org/val2017/000000039769.jpg'''
    a__						=Image.open(requests.get(_A			,   stream=_A							).raw							)
  
    return im
  
  
  
  
  @torch.no_grad()
  def     UpperCAmelCase__       (    _A   :				Tuple			,   _A   :				int			,   _A   :				List[str]							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						=get_deta_config()
  
    # load original state dict
    if model_name == "deta-resnet-50":
      a__						='''adet_checkpoint0011.pth'''
    elif model_name == "deta-resnet-50-24-epochs":
      a__						='''adet_2x_checkpoint0023.pth'''
    else:
      raise ValueError(F"""Model name {model_name} not supported"""							)
    a__						=hf_hub_download(repo_id='''nielsr/deta-checkpoints'''			,   filename=_A							)
    a__						=torch.load(_A			,   map_location='''cpu'''							)['''model''']
  
    # rename keys
    a__						=create_rename_keys(_A							)
    for src, dest in rename_keys:
      rename_key(_A			,   _A			,   _A							)
    read_in_decoder_q_k_v(_A			,   _A							)
  
    # fix some prefixes
    for key in state_dict.copy().keys():
      if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
        a__						=state_dict.pop(_A							)
        a__						=val
      if "input_proj" in key:
        a__						=state_dict.pop(_A							)
        a__						=val
      if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
        a__						=state_dict.pop(_A							)
        a__						=val
  
      # finally, create HuggingFace model and load state dict
    a__						=DetaForObjectDetection(_A							)
    model.load_state_dict(_A							)
    model.eval()
  
    a__						='''cuda''' if torch.cuda.is_available() else '''cpu'''
    model.to(_A							)
  
    # load image processor
    a__						=DetaImageProcessor(format='''coco_detection'''							)
  
    # verify our conversion on image
    a__						=prepare_img()
    a__						=processor(images=_A			,   return_tensors='''pt'''							)
    a__						=encoding['''pixel_values''']
    a__						=model(pixel_values.to(_A							)							)
  
    # verify logits
    if model_name == "deta-resnet-50":
      a__						=torch.tensor(
          [[-7.3_978, -2.5_406, -4.1_668], [-8.2_684, -3.9_933, -3.8_096], [-7.0_515, -3.7_973, -5.8_516]]							)
      a__						=torch.tensor([[0.5_043, 0.4_973, 0.9_998], [0.2_542, 0.5_489, 0.4_748], [0.5_490, 0.2_765, 0.0_570]]							)
    elif model_name == "deta-resnet-50-24-epochs":
      a__						=torch.tensor(
          [[-7.1_688, -2.4_857, -4.8_669], [-7.8_630, -3.8_154, -4.2_674], [-7.2_730, -4.1_865, -5.5_323]]							)
      a__						=torch.tensor([[0.5_021, 0.4_971, 0.9_994], [0.2_546, 0.5_486, 0.4_731], [0.1_686, 0.1_986, 0.2_142]]							)
  
    assert torch.allclose(outputs.logits[0, :3, :3]			,   expected_logits.to(_A							)			,   atol=1E-4							)
    assert torch.allclose(outputs.pred_boxes[0, :3, :3]			,   expected_boxes.to(_A							)			,   atol=1E-4							)
    print('''Everything ok!'''							)
  
    if pytorch_dump_folder_path:
      # Save model and processor
      logger.info(F"""Saving PyTorch model and processor to {pytorch_dump_folder_path}..."""							)
      Path(_A							).mkdir(exist_ok=_A							)
      model.save_pretrained(_A							)
      processor.save_pretrained(_A							)
  
    # Push to hub
    if push_to_hub:
      print('''Pushing model and processor to hub...'''							)
      model.push_to_hub(F"""jozhang97/{model_name}"""							)
      processor.push_to_hub(F"""jozhang97/{model_name}"""							)
  
  
  if __name__ == "__main__":
         lowerCamelCase     =      argparse.ArgumentParser()
  
         parser.add_argument(
             '''--model_name''',
             type=str,
             default='''deta-resnet-50''',
             choices=['''deta-resnet-50''', '''deta-resnet-50-24-epochs'''],
             help='''Name of the model you\'d like to convert.''',
         )
         parser.add_argument(
             '''--pytorch_dump_folder_path''',
             default=None,
             type=str,
             help='''Path to the folder to output PyTorch model.''',
         )
         parser.add_argument(
             '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
         )
         lowerCamelCase     =      parser.parse_args()
         convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, 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
  
  
  if is_torch_available():
         import torch
  
  if is_vision_available():
         from PIL import Image
  
         from transformers import TvltImageProcessor
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				Optional[int]			,   _A   :				List[Any]=10			,   _A   :				Optional[int]=10			,   _A   :				Dict=False			,   _A   :				Any=False							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						=[]
    for i in range(image_processor_tester.num_frames							):
      video.append(np.random.randint(2_55			,   size=(image_processor_tester.num_channels, width, height)			,   dtype=np.uinta							)							)
  
    if not numpify and not torchify:
      # PIL expects the channel dimension as last dimension
      a__						=[Image.fromarray(np.moveaxis(_A			,   0			,   -1							)							) for frame in video]
  
    if torchify:
      a__						=[torch.from_numpy(_A							) for frame in video]
  
    return video
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				List[str]			,   _A   :				Optional[int]=False			,   _A   :				Dict=False			,   _A   :				Optional[Any]=False							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
    a__						=[]
    for i in range(image_processor_tester.batch_size							):
      if equal_resolution:
        a__						=a__						=image_processor_tester.max_resolution
      else:
        a__,   a__						=np.random.choice(
            np.arange(image_processor_tester.min_resolution			,   image_processor_tester.max_resolution							)			,   2							)
        a__						=prepare_video(
            image_processor_tester=_A			,   width=_A			,   height=_A			,   numpify=_A			,   torchify=_A			,   )
      video_inputs.append(_A							)
  
    return video_inputs
  
  
  
  
  
  
  
  class 		__magic_name__    (							unittest.TestCase							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					lowercase_=7,					lowercase_=3,					lowercase_=4,					lowercase_=18,					lowercase_=30,					lowercase_=400,					lowercase_=True,					lowercase_=None,					lowercase_=True,					lowercase_=[0.5, 0.5, 0.5],					lowercase_=[0.5, 0.5, 0.5],					lowercase_=True,					lowercase_=None,					)							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=size if size is not None else {'''shortest_edge''': 18}
       a__						=crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
  
       a__						=parent
       a__						=batch_size
       a__						=num_channels
       a__						=num_frames
       a__						=image_size
       a__						=min_resolution
       a__						=max_resolution
       a__						=do_resize
       a__						=size
       a__						=do_normalize
       a__						=image_mean
       a__						=image_std
       a__						=do_center_crop
       a__						=crop_size
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return {
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_normalize": self.do_normalize,
           "do_resize": self.do_resize,
           "size": self.size,
           "do_center_crop": self.do_center_crop,
           "crop_size": self.crop_size,
       }
  
  
  
  
  
  
  
  @require_torch
  @require_vision
  class 		__magic_name__    (							lowerCamelCase__	, unittest.TestCase							):
  
     '''simple docstring'''
  
  
  
  
     lowerCamelCase__				:			str												=     TvltImageProcessor if is_vision_available() else None
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=TvltImageProcessorTester(self )
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
     def 				_UpperCAmelCase				(       self )							->					str:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.image_processing_class(**self.image_processor_dict )
       self.assertTrue(hasattr(lowercase_,					'''image_mean''' ) )
       self.assertTrue(hasattr(lowercase_,					'''image_std''' ) )
       self.assertTrue(hasattr(lowercase_,					'''do_normalize''' ) )
       self.assertTrue(hasattr(lowercase_,					'''do_resize''' ) )
       self.assertTrue(hasattr(lowercase_,					'''do_center_crop''' ) )
       self.assertTrue(hasattr(lowercase_,					'''size''' ) )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Tuple:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.image_processing_class(**self.image_processor_dict )
       # create random PIL videos
       a__						=prepare_video_inputs(self.image_processor_tester,					equal_resolution=lowercase_ )
       for video in video_inputs:
         self.assertIsInstance(lowercase_,					lowercase_ )
         self.assertIsInstance(video[0],					Image.Image )
  
       # Test not batched input
       a__						=image_processor(video_inputs[0],					return_tensors='''pt''' ).pixel_values
       self.assertEqual(
           encoded_videos.shape,					(
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           ),					)
  
       # Test batched
       a__						=image_processor(lowercase_,					return_tensors='''pt''' ).pixel_values
       self.assertEqual(
           encoded_videos.shape,					(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           ),					)
  
  
  
     def 				_UpperCAmelCase				(       self )							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.image_processing_class(**self.image_processor_dict )
       # create random numpy tensors
       a__						=prepare_video_inputs(self.image_processor_tester,					equal_resolution=lowercase_,					numpify=lowercase_ )
       for video in video_inputs:
         self.assertIsInstance(lowercase_,					lowercase_ )
         self.assertIsInstance(video[0],					np.ndarray )
  
       # Test not batched input
       a__						=image_processor(video_inputs[0],					return_tensors='''pt''' ).pixel_values
       self.assertEqual(
           encoded_videos.shape,					(
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           ),					)
  
       # Test batched
       a__						=image_processor(lowercase_,					return_tensors='''pt''' ).pixel_values
       self.assertEqual(
           encoded_videos.shape,					(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           ),					)
  
  
  
     def 				_UpperCAmelCase				(       self )							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.image_processing_class(**self.image_processor_dict )
       # create random PyTorch tensors
       a__						=prepare_video_inputs(self.image_processor_tester,					equal_resolution=lowercase_,					torchify=lowercase_ )
       for video in video_inputs:
         self.assertIsInstance(lowercase_,					lowercase_ )
         self.assertIsInstance(video[0],					torch.Tensor )
  
       # Test not batched input
       a__						=image_processor(video_inputs[0],					return_tensors='''pt''' ).pixel_values
       self.assertEqual(
           encoded_videos.shape,					(
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           ),					)
  
       # Test batched
       a__						=image_processor(lowercase_,					return_tensors='''pt''' ).pixel_values
       self.assertEqual(
           encoded_videos.shape,					(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           ),					)
  