
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			:       List[str]      =						logging.get_logger(__name__)

def    __snake_case       (  __magic_name__	):







    '''simple docstring'''


    lowercase						    =			tf.image.resize(__magic_name__		,						(346, 346)	)
    lowercase						    =			tf.image.crop_to_bounding_box(__magic_name__		,						(346 - 289) // 2		,						(346 - 289) // 2		,						289		,						289	)
    return image

def    __snake_case       (  ):







    '''simple docstring'''


    lowercase						    =			EfficientNetConfig.from_pretrained("google/efficientnet-b7"	)
    lowercase						    =			289
    lowercase						    =			640
    lowercase						    =			{"0": "LABEL_0", "1": "LABEL_1"}
    lowercase						    =			{"LABEL_0": 0, "LABEL_1": 1}
    lowercase						    =			[]

    lowercase						    =			BertConfig()
    lowercase						    =			AlignConfig.from_text_vision_configs(
        text_config=__magic_name__		,						vision_config=__magic_name__		,						projection_dim=640	)
    return config

def    __snake_case       (  ):







    '''simple docstring'''


    lowercase						    =			"http://images.cocodataset.org/val2017/000000039769.jpg"
    lowercase						    =			Image.open(requests.get(__magic_name__		,						stream=__magic_name__	).raw	)
    return im

def    __snake_case       (  ):







    '''simple docstring'''


    lowercase						    =			EfficientNetImageProcessor(
        do_center_crop=__magic_name__		,						rescale_factor=1 / 127.5		,						rescale_offset=__magic_name__		,						do_normalize=__magic_name__		,						include_top=__magic_name__		,						resample=Image.BILINEAR		,						)
    lowercase						    =			BertTokenizer.from_pretrained("bert-base-uncased"	)
    lowercase						    =			64
    lowercase						    =			AlignProcessor(image_processor=__magic_name__		,						tokenizer=__magic_name__	)
    return processor

def    __snake_case       (  __magic_name__	):







    '''simple docstring'''


    lowercase						    =			[v.split("_"	)[0].split("block"	)[1] for v in original_param_names if v.startswith("block"	)]
    lowercase						    =			list(set(__magic_name__	)	)
    lowercase						    =			sorted(__magic_name__	)
    lowercase						    =			len(__magic_name__	)
    lowercase						    =			{b: str(__magic_name__	) for b, i in zip(__magic_name__		,						range(__magic_name__	)	)}

    lowercase						    =			[]
    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:
        lowercase						    =			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''')	)

    lowercase						    =			{}
    for item in rename_keys:
        if item[0] in original_param_names:
            lowercase						    =			"vision_model." + item[1]

    # BERT text encoder
    lowercase						    =			[]
    lowercase						    =			"tf_bert_model/bert"
    lowercase						    =			"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:
            lowercase						    =			item[1]
    return key_mapping

def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):







    '''simple docstring'''


    list(hf_params.keys()	)

    for key, value in tf_params.items():
        if key not in key_mapping:
            continue

        lowercase						    =			key_mapping[key]
        if "_conv" in key and "kernel" in key:
            lowercase						    =			torch.from_numpy(__magic_name__	).permute(3		,						2		,						0		,						1	)
        elif "embeddings" in key:
            lowercase						    =			torch.from_numpy(__magic_name__	)
        elif "depthwise_kernel" in key:
            lowercase						    =			torch.from_numpy(__magic_name__	).permute(2		,						3		,						0		,						1	)
        elif "kernel" in key:
            lowercase						    =			torch.from_numpy(np.transpose(__magic_name__	)	)
        elif "temperature" in key:
            lowercase						    =			value
        elif "bn/gamma" or "bn/beta" in key:
            lowercase						    =			torch.from_numpy(np.transpose(__magic_name__	)	).squeeze()
        else:
            lowercase						    =			torch.from_numpy(__magic_name__	)

        # Replace HF parameters with original TF model parameters
        hf_params[hf_key].copy_(__magic_name__	)

@torch.no_grad()
def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__		,						__magic_name__	):







    '''simple docstring'''


    lowercase						    =			64
    lowercase						    =			Tokenizer(__magic_name__	)
    lowercase						    =			align.Align("efficientnet-b7"		,						"bert-base"		,						640		,						__magic_name__		,						tok.get_vocab_size()	)
    original_model.compile()
    original_model.load_weights(__magic_name__	)

    lowercase						    =			original_model.trainable_variables
    lowercase						    =			original_model.non_trainable_variables
    lowercase						    =			{param.name: param.numpy() for param in tf_params}
    for param in tf_non_train_params:
        lowercase						    =			param.numpy()
    lowercase						    =			list(tf_params.keys()	)

    # Load HuggingFace model
    lowercase						    =			get_align_config()
    lowercase						    =			AlignModel(__magic_name__	).eval()
    lowercase						    =			hf_model.state_dict()

    # Create src-to-dst parameter name mapping dictionary
    print("Converting parameters..."	)
    lowercase						    =			rename_keys(__magic_name__	)
    replace_params(__magic_name__		,						__magic_name__		,						__magic_name__	)

    # Initialize processor
    lowercase						    =			get_processor()
    lowercase						    =			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():
        lowercase						    =			hf_model(**__magic_name__	)

    lowercase						    =			outputs.image_embeds.detach().numpy()
    lowercase						    =			outputs.text_embeds.detach().numpy()

    # Original model inference
    lowercase						    =			False
    lowercase						    =			EfficientNetImageProcessor(
        do_center_crop=__magic_name__		,						do_rescale=__magic_name__		,						do_normalize=__magic_name__		,						include_top=__magic_name__		,						resample=Image.BILINEAR		,						)
    lowercase						    =			tf_image_processor(images=prepare_img()		,						return_tensors="tf"		,						data_format="channels_last"	)["pixel_values"]
    lowercase						    =			tok(tf.constant(["A picture of a cat"]	)	)

    lowercase						    =			original_model.image_encoder(__magic_name__		,						training=__magic_name__	)
    lowercase						    =			original_model.text_encoder(__magic_name__		,						training=__magic_name__	)

    lowercase						    =			tf.nn.la_normalize(__magic_name__		,						axis=-1	)
    lowercase						    =			tf.nn.la_normalize(__magic_name__		,						axis=-1	)

    # Check whether original and HF model outputs match  -> np.allclose
    if not np.allclose(__magic_name__		,						__magic_name__		,						atol=1e-3	):
        raise ValueError("The predicted image features are not the same."	)
    if not np.allclose(__magic_name__		,						__magic_name__		,						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(__magic_name__	):
            os.mkdir(__magic_name__	)
        # Save converted model and image processor
        hf_model.save_pretrained(__magic_name__	)
        processor.save_pretrained(__magic_name__	)

    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			:       List[str]      =						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			:       List[str]      =						parser.parse_args()
      convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)


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_video_inputs


if is_torch_available():
						import torch

if is_vision_available():
						from PIL import Image

						from transformers import VideoMAEImageProcessor





class      UpperCamelCase_			(			unittest.TestCase		):







						'''simple docstring'''



						def __init__( self       :Any		,						lowerCAmelCase__       :Any		,						lowerCAmelCase__       :Optional[int]=7		,						lowerCAmelCase__       :Tuple=3		,						lowerCAmelCase__       :List[str]=10		,						lowerCAmelCase__       :Dict=18		,						lowerCAmelCase__       :int=30		,						lowerCAmelCase__       :List[str]=400		,						lowerCAmelCase__       :Union[str, Any]=True		,						lowerCAmelCase__       :List[Any]=None		,						lowerCAmelCase__       :List[Any]=True		,						lowerCAmelCase__       :int=[0.5, 0.5, 0.5]		,						lowerCAmelCase__       :Optional[Any]=[0.5, 0.5, 0.5]		,						lowerCAmelCase__       :Dict=None		,						)     ->Union[str, Any]:
										lowercase						    =			size if size is not None else {"shortest_edge": 18}
										lowercase						    =			crop_size if crop_size is not None else {"height": 18, "width": 18}

										lowercase						    =			parent
										lowercase						    =			batch_size
										lowercase						    =			num_channels
										lowercase						    =			num_frames
										lowercase						    =			image_size
										lowercase						    =			min_resolution
										lowercase						    =			max_resolution
										lowercase						    =			do_resize
										lowercase						    =			size
										lowercase						    =			do_normalize
										lowercase						    =			image_mean
										lowercase						    =			image_std
										lowercase						    =			crop_size





						def 					SCREAMING_SNAKE_CASE( self       :List[Any]    )     ->int:
										return {
										    "image_mean": self.image_mean,
										    "image_std": self.image_std,
										    "do_normalize": self.do_normalize,
										    "do_resize": self.do_resize,
										    "size": self.size,
										    "crop_size": self.crop_size,
										}





@require_torch
@require_vision
class      UpperCamelCase_			(			__a		,						unittest.TestCase		):







						'''simple docstring'''



						UpperCamelCase			:     Union[str, Any]							      =				VideoMAEImageProcessor if is_vision_available() else None





						def 					SCREAMING_SNAKE_CASE( self       :List[str]    )     ->List[Any]:
										lowercase						    =			VideoMAEImageProcessingTester(self    )





						@property
						def 					SCREAMING_SNAKE_CASE( self       :List[Any]    )     ->Any:
										return self.image_processor_tester.prepare_image_processor_dict()





						def 					SCREAMING_SNAKE_CASE( self       :Dict    )     ->str:
										lowercase						    =			self.image_processing_class(**self.image_processor_dict    )
										self.assertTrue(hasattr(lowerCAmelCase__		,						"image_mean"    )    )
										self.assertTrue(hasattr(lowerCAmelCase__		,						"image_std"    )    )
										self.assertTrue(hasattr(lowerCAmelCase__		,						"do_normalize"    )    )
										self.assertTrue(hasattr(lowerCAmelCase__		,						"do_resize"    )    )
										self.assertTrue(hasattr(lowerCAmelCase__		,						"do_center_crop"    )    )
										self.assertTrue(hasattr(lowerCAmelCase__		,						"size"    )    )





						def 					SCREAMING_SNAKE_CASE( self       :str    )     ->Tuple:
										lowercase						    =			self.image_processing_class.from_dict(self.image_processor_dict    )
										self.assertEqual(image_processor.size		,						{"shortest_edge": 18}    )
										self.assertEqual(image_processor.crop_size		,						{"height": 18, "width": 18}    )

										lowercase						    =			self.image_processing_class.from_dict(self.image_processor_dict		,						size=42		,						crop_size=84    )
										self.assertEqual(image_processor.size		,						{"shortest_edge": 42}    )
										self.assertEqual(image_processor.crop_size		,						{"height": 84, "width": 84}    )





						def 					SCREAMING_SNAKE_CASE( self       :int    )     ->Any:
										pass





						def 					SCREAMING_SNAKE_CASE( self       :List[Any]    )     ->List[Any]:
										# Initialize image_processing
										lowercase						    =			self.image_processing_class(**self.image_processor_dict    )
										# create random PIL videos
										lowercase						    =			prepare_video_inputs(self.image_processor_tester		,						equal_resolution=lowerCAmelCase__    )
										for video in video_inputs:
														self.assertIsInstance(lowerCAmelCase__		,						lowerCAmelCase__    )
														self.assertIsInstance(video[0]		,						Image.Image    )

										# Test not batched input
										lowercase						    =			image_processing(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
										lowercase						    =			image_processing(lowerCAmelCase__		,						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 					SCREAMING_SNAKE_CASE( self       :Dict    )     ->Optional[int]:
										# Initialize image_processing
										lowercase						    =			self.image_processing_class(**self.image_processor_dict    )
										# create random numpy tensors
										lowercase						    =			prepare_video_inputs(self.image_processor_tester		,						equal_resolution=lowerCAmelCase__		,						numpify=lowerCAmelCase__    )
										for video in video_inputs:
														self.assertIsInstance(lowerCAmelCase__		,						lowerCAmelCase__    )
														self.assertIsInstance(video[0]		,						np.ndarray    )

										# Test not batched input
										lowercase						    =			image_processing(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
										lowercase						    =			image_processing(lowerCAmelCase__		,						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 					SCREAMING_SNAKE_CASE( self       :Any    )     ->Dict:
										# Initialize image_processing
										lowercase						    =			self.image_processing_class(**self.image_processor_dict    )
										# create random PyTorch tensors
										lowercase						    =			prepare_video_inputs(self.image_processor_tester		,						equal_resolution=lowerCAmelCase__		,						torchify=lowerCAmelCase__    )
										for video in video_inputs:
														self.assertIsInstance(lowerCAmelCase__		,						lowerCAmelCase__    )
														self.assertIsInstance(video[0]		,						torch.Tensor    )

										# Test not batched input
										lowercase						    =			image_processing(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
										lowercase						    =			image_processing(lowerCAmelCase__		,						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"],
										    )		,						)
