




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







def       _a (		SCREAMING_SNAKE_CASE_				:							int	):
					__lowerCAmelCase							  =			tf.image.resize(SCREAMING_SNAKE_CASE_ , (3_46, 3_46)	)
					__lowerCAmelCase							  =			tf.image.crop_to_bounding_box(SCREAMING_SNAKE_CASE_ , (3_46 - 2_89) // 2 , (3_46 - 2_89) // 2 , 2_89 , 2_89	)
					return image







def       _a (		):
					__lowerCAmelCase							  =			EfficientNetConfig.from_pretrained("google/efficientnet-b7"	)
					__lowerCAmelCase							  =			2_89
					__lowerCAmelCase							  =			6_40
					__lowerCAmelCase							  =			{"0": "LABEL_0", "1": "LABEL_1"}
					__lowerCAmelCase							  =			{"LABEL_0": 0, "LABEL_1": 1}
					__lowerCAmelCase							  =			[]

					__lowerCAmelCase							  =			BertConfig()
					__lowerCAmelCase							  =			AlignConfig.from_text_vision_configs(
					    text_config=SCREAMING_SNAKE_CASE_ , vision_config=SCREAMING_SNAKE_CASE_ , projection_dim=6_40	)
					return config







def       _a (		):
					__lowerCAmelCase							  =			"http://images.cocodataset.org/val2017/000000039769.jpg"
					__lowerCAmelCase							  =			Image.open(requests.get(SCREAMING_SNAKE_CASE_ , stream=SCREAMING_SNAKE_CASE_	).raw	)
					return im







def       _a (		):
					__lowerCAmelCase							  =			EfficientNetImageProcessor(
					    do_center_crop=SCREAMING_SNAKE_CASE_ , rescale_factor=1 / 1_27.5 , rescale_offset=SCREAMING_SNAKE_CASE_ , do_normalize=SCREAMING_SNAKE_CASE_ , include_top=SCREAMING_SNAKE_CASE_ , resample=Image.BILINEAR , )
					__lowerCAmelCase							  =			BertTokenizer.from_pretrained("bert-base-uncased"	)
					__lowerCAmelCase							  =			64
					__lowerCAmelCase							  =			AlignProcessor(image_processor=SCREAMING_SNAKE_CASE_ , tokenizer=SCREAMING_SNAKE_CASE_	)
					return processor







def       _a (		SCREAMING_SNAKE_CASE_				:							str	):
					# EfficientNet image encoder
					__lowerCAmelCase							  =			[v.split("_"	)[0].split("block"	)[1] for v in original_param_names if v.startswith("block"	)]
					__lowerCAmelCase							  =			list(set(SCREAMING_SNAKE_CASE_	)	)
					__lowerCAmelCase							  =			sorted(SCREAMING_SNAKE_CASE_	)
					__lowerCAmelCase							  =			len(SCREAMING_SNAKE_CASE_	)
					__lowerCAmelCase							  =			{b: str(SCREAMING_SNAKE_CASE_	) for b, i in zip(SCREAMING_SNAKE_CASE_ , range(SCREAMING_SNAKE_CASE_	)	)}

					__lowerCAmelCase							  =			[]
					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:
										__lowerCAmelCase							  =			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""")	)

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

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







def       _a (		SCREAMING_SNAKE_CASE_				:							List[Any] , SCREAMING_SNAKE_CASE_				:							Dict , SCREAMING_SNAKE_CASE_				:							Tuple	):
					list(hf_params.keys()	)

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

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

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







@torch.no_grad()
def       _a (		SCREAMING_SNAKE_CASE_				:							Dict , SCREAMING_SNAKE_CASE_				:							Union[str, Any] , SCREAMING_SNAKE_CASE_				:							Optional[int] , SCREAMING_SNAKE_CASE_				:							Optional[int]	):
					__lowerCAmelCase							  =			64
					__lowerCAmelCase							  =			Tokenizer(SCREAMING_SNAKE_CASE_	)
					__lowerCAmelCase							  =			align.Align("efficientnet-b7" , "bert-base" , 6_40 , SCREAMING_SNAKE_CASE_ , tok.get_vocab_size()	)
					original_model.compile()
					original_model.load_weights(SCREAMING_SNAKE_CASE_	)

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

					# Load HuggingFace model
					__lowerCAmelCase							  =			get_align_config()
					__lowerCAmelCase							  =			AlignModel(SCREAMING_SNAKE_CASE_	).eval()
					__lowerCAmelCase							  =			hf_model.state_dict()

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

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

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

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

					__lowerCAmelCase							  =			original_model.image_encoder(SCREAMING_SNAKE_CASE_ , training=SCREAMING_SNAKE_CASE_	)
					__lowerCAmelCase							  =			original_model.text_encoder(SCREAMING_SNAKE_CASE_ , training=SCREAMING_SNAKE_CASE_	)

					__lowerCAmelCase							  =			tf.nn.la_normalize(SCREAMING_SNAKE_CASE_ , axis=-1	)
					__lowerCAmelCase							  =			tf.nn.la_normalize(SCREAMING_SNAKE_CASE_ , axis=-1	)

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

					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__            =     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__            =     parser.parse_args()
					convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)










import json
import logging
import os
import subprocess
from argparse import ArgumentParser


UpperCamelCase__            =     logging.getLogger(__name__)







def       _a (		):
					__lowerCAmelCase							  =			ArgumentParser()
					__lowerCAmelCase  ,				__lowerCAmelCase							  =			parser.parse_known_args()
					for arg in unknown:
										if arg.startswith(("-", "--")	):
															parser.add_argument(arg.split("="	)[0]	)

					return parser.parse_args()







def       _a (		):
					__lowerCAmelCase							  =			parse_args()
					__lowerCAmelCase							  =			88_88
					__lowerCAmelCase							  =			int(os.environ["SM_NUM_GPUS"]	)
					__lowerCAmelCase							  =			json.loads(os.environ["SM_HOSTS"]	)
					__lowerCAmelCase							  =			len(SCREAMING_SNAKE_CASE_	)
					__lowerCAmelCase							  =			os.environ["SM_CURRENT_HOST"]
					__lowerCAmelCase							  =			hosts.index(SCREAMING_SNAKE_CASE_	)
					__lowerCAmelCase							  =			"INFO"

					if num_nodes > 1:
										__lowerCAmelCase							  =			F"""python -m torch.distributed.launch \
                --nnodes={num_nodes}  \
                --node_rank={rank}  \
                --nproc_per_node={num_gpus}  \
                --master_addr={hosts[0]}  \
                --master_port={port} \
                ./run_glue.py \
                {''.join(['nested fstring' for parameter,value in args.__dict__.items()]	)}"""
					else:
										__lowerCAmelCase							  =			F"""python -m torch.distributed.launch \
            --nproc_per_node={num_gpus}  \
            ./run_glue.py \
            {''.join(['nested fstring' for parameter,value in args.__dict__.items()]	)}"""
					try:
										subprocess.run(SCREAMING_SNAKE_CASE_ , shell=SCREAMING_SNAKE_CASE_	)
					except Exception as e:
										logger.info(SCREAMING_SNAKE_CASE_	)


if __name__ == "__main__":
					main()




