





'''simple docstring'''





import torch

from transformers import AutoTokenizer




class   _UpperCAmelCase	(   A__					):




					def __init__(						self    ,      __lowerCAmelCase       )						->  List[str]:
							UpperCamelCase__         =	AutoTokenizer.from_pretrained(_lowerCAmelCase       )




					def 	snake_case_		(						self    ,      __lowerCAmelCase       )						->  Tuple:

							if isinstance(_lowerCAmelCase    ,      _lowerCAmelCase       ) and all(isinstance(_x    ,      _lowerCAmelCase       ) for _x in x       ):
									UpperCamelCase__         =	None
									for l in x:
											UpperCamelCase__         =	self.tokenizer(
											    _lowerCAmelCase    ,      padding="""max_length"""    ,      max_length=384    ,      truncation=_lowerCAmelCase    ,      return_tensors="""pt"""    ,      )
											UpperCamelCase__         =	torch.tensor([len(_lowerCAmelCase       )]       )
											if d is not None:
													for k in d.keys():
															UpperCamelCase__         =	torch.cat((d[k], t[k])    ,      0       )
											else:
													UpperCamelCase__         =	t

									UpperCamelCase__         =	torch.tensor(self.tokenizer.convert_tokens_to_ids("""[E]"""       )       )
									UpperCamelCase__         =	torch.tensor(self.tokenizer.convert_tokens_to_ids("""[/E]"""       )       )

							elif isinstance(_lowerCAmelCase    ,      _lowerCAmelCase       ) and all(isinstance(_x    ,      _lowerCAmelCase       ) for _x in x       ):
									UpperCamelCase__         =	self.tokenizer(
									    _lowerCAmelCase    ,      padding="""max_length"""    ,      max_length=384    ,      truncation=_lowerCAmelCase    ,      return_tensors="""pt"""    ,      )

							else:
									raise Exception(
									    """Type of parameter x was not recognized! Only `list of strings` for query or `list of lists of"""
									    """ strings` for supports are supported."""       )

							return d




					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase=0.7_0       )						->  List[Any]:
							UpperCamelCase__         =	[]
							for idx in range(len(W_query["""input_ids"""]       )       ):
									UpperCamelCase__         =	UpperCamelCase__         =	range(p_start.shape[1]       )

									UpperCamelCase__         =	[]
									for start_id in start_indexes:
											for end_id in end_indexes:
													if start_id < end_id:
															output.append(
															    (
															        start_id,
															        end_id,
															        p_start[idx][start_id].item(),
															        p_end[idx][end_id].item(),
															    )       )

									output.sort(key=lambda __lowerCAmelCase       : (tup[2] * tup[3])    ,      reverse=_lowerCAmelCase       )
									UpperCamelCase__         =	[]
									for k in range(len(_lowerCAmelCase       )       ):
											if output[k][2] * output[k][3] >= thresh:
													UpperCamelCase__  ,			UpperCamelCase__         =	output[k][0], output[k][1]
													UpperCamelCase__         =	self.tokenizer.decode(W_query["""input_ids"""][idx][c_start_pos:c_end_pos]       )
													temp.append((decoded, output[k][2] * output[k][3])       )

									final_outputs.append(_lowerCAmelCase       )

							return final_outputs












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()
__lowerCAmelCase     =			logging.get_logger(__name__)

def     a						(      _lowercase   :     Union[str, Any]       )     ->str:
		UpperCamelCase__         =	tf.image.resize(_lowercase ,						(3_4_6, 3_4_6)       )
		UpperCamelCase__         =	tf.image.crop_to_bounding_box(_lowercase ,						(3_4_6 - 2_8_9) // 2 ,						(3_4_6 - 2_8_9) // 2 ,						2_8_9 ,						2_8_9       )
		return image

def     a						(      )     ->Optional[int]:
		UpperCamelCase__         =	EfficientNetConfig.from_pretrained("""google/efficientnet-b7"""       )
		UpperCamelCase__         =	2_8_9
		UpperCamelCase__         =	6_4_0
		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_4_0       )
		return config

def     a						(      )     ->Optional[int]:
		UpperCamelCase__         =	"""http://images.cocodataset.org/val2017/000000039769.jpg"""
		UpperCamelCase__         =	Image.open(requests.get(_lowercase ,						stream=_lowercase       ).raw       )
		return im

def     a						(      )     ->Optional[int]:
		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__         =	6_4
		UpperCamelCase__         =	AlignProcessor(image_processor=_lowercase ,						tokenizer=_lowercase       )
		return processor

def     a						(      _lowercase   :     str       )     ->int:
		# EfficientNet image encoder
		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(1_2       ):
				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   :     int ,						_lowercase   :     str ,						_lowercase   :     int       )     ->Optional[Any]:
		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   :     List[str] ,						_lowercase   :     Any ,						_lowercase   :     Dict ,						_lowercase   :     Optional[Any]       )     ->str:
		UpperCamelCase__         =	6_4
		UpperCamelCase__         =	Tokenizer(_lowercase       )
		UpperCamelCase__         =	align.Align("""efficientnet-b7""" ,						"""bert-base""" ,						6_4_0 ,						_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=6_4 ,						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__":
				__lowerCAmelCase     =			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")

				__lowerCAmelCase     =			parser.parse_args()
				convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)





