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


def  A			(   lowercase					)  ->    List[str]:
		'''simple docstring'''

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


def  A			(   )  ->    List[str]:
		'''simple docstring'''

		UpperCamelCase            =	EfficientNetConfig.from_pretrained('google/efficientnet-b7'					)
		UpperCamelCase            =	289
		UpperCamelCase            =	640
		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=640					)
		return config


def  A			(   )  ->    Union[str, Any]:
		'''simple docstring'''

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


def  A			(   )  ->    Tuple:
		'''simple docstring'''

		UpperCamelCase            =	EfficientNetImageProcessor(
		    do_center_crop=lowercase       ,			rescale_factor=1 / 127.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					)  ->    Tuple:
		'''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					)  ->    int:
		'''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					)  ->    List[str]:
		'''simple docstring'''

		UpperCamelCase            =	64
		UpperCamelCase            =	Tokenizer(lowercase					)
		UpperCamelCase            =	align.Align('efficientnet-b7'       ,			'bert-base'       ,			640       ,			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__":
					_UpperCAmelCase   :					Tuple    =			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")

					_UpperCAmelCase   :					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_image_inputs


if is_torch_available():
						import torch

if is_vision_available():
						from PIL import Image

						from transformers import DeiTImageProcessor


class 	UpperCamelCase__       (  unittest.TestCase):

						'''simple docstring'''



						def __init__(  self  , A  , A=7  , A=3  , A=18  , A=30  , A=4_00  , A=True  , A=None  , A=True  , A=None  , A=True  , A=[0.5, 0.5, 0.5]  , A=[0.5, 0.5, 0.5]  , )  ->Any:
									UpperCAmelCase__		:Optional[int] 		=    size if size is not None else {'height': 20, 'width': 20}
									UpperCAmelCase__		:str 		=    crop_size if crop_size is not None else {'height': 18, 'width': 18}

									UpperCAmelCase__		:Dict 		=    parent
									UpperCAmelCase__		:Optional[Any] 		=    batch_size
									UpperCAmelCase__		:Optional[Any] 		=    num_channels
									UpperCAmelCase__		:str 		=    image_size
									UpperCAmelCase__		:Optional[Any] 		=    min_resolution
									UpperCAmelCase__		:Optional[int] 		=    max_resolution
									UpperCAmelCase__		:Dict 		=    do_resize
									UpperCAmelCase__		:Any 		=    size
									UpperCAmelCase__		:Any 		=    do_center_crop
									UpperCAmelCase__		:Optional[int] 		=    crop_size
									UpperCAmelCase__		:Dict 		=    do_normalize
									UpperCAmelCase__		:List[Any] 		=    image_mean
									UpperCAmelCase__		:Tuple 		=    image_std


						def    A__       (  self	)  ->str:
									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 	UpperCamelCase__       (  UpperCAmelCase__						,			unittest.TestCase):

						'''simple docstring'''



						__a     :    Tuple												=			DeiTImageProcessor if is_vision_available() else None
						__a     :    Tuple												=			True


						def    A__       (  self	)  ->Optional[int]:
									UpperCAmelCase__		:int 		=    DeiTImageProcessingTester(self	)


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


						def    A__       (  self	)  ->Optional[Any]:
									UpperCAmelCase__		:Tuple 		=    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    A__       (  self	)  ->Tuple:
									UpperCAmelCase__		:Union[str, Any] 		=    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__		:List[Any] 		=    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    A__       (  self	)  ->List[str]:
									pass


						def    A__       (  self	)  ->List[str]:
									# Initialize image_processing
									UpperCAmelCase__		:int 		=    self.image_processing_class(**self.image_processor_dict	)
									# create random PIL images
									UpperCAmelCase__		:Tuple 		=    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__		:int 		=    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__		:List[str] 		=    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    A__       (  self	)  ->str:
									# Initialize image_processing
									UpperCAmelCase__		:Tuple 		=    self.image_processing_class(**self.image_processor_dict	)
									# create random numpy tensors
									UpperCAmelCase__		:Dict 		=    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__		:List[str] 		=    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__		:Optional[Any] 		=    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    A__       (  self	)  ->Tuple:
									# Initialize image_processing
									UpperCAmelCase__		:List[Any] 		=    self.image_processing_class(**self.image_processor_dict	)
									# create random PyTorch tensors
									UpperCAmelCase__		:str 		=    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__		:List[str] 		=    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__		:Optional[int] 		=    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'],
									    )  , )





