




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()
__A						:		Dict          =						logging.get_logger(__name__)





def      UpperCAmelCase  (						UpperCamelCase__   )     ->     List[str]:







				'''simple docstring'''


				__lowerCAmelCase					=  tf.image.resize(UpperCamelCase__						,			(3_46, 3_46)   )
				__lowerCAmelCase					=  tf.image.crop_to_bounding_box(UpperCamelCase__						,			(3_46 - 2_89) // 2						,			(3_46 - 2_89) // 2						,			2_89						,			2_89   )
				return image





def      UpperCAmelCase  (						)     ->     Optional[Any]:







				'''simple docstring'''


				__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=UpperCamelCase__						,			vision_config=UpperCamelCase__						,			projection_dim=6_40   )
				return config





def      UpperCAmelCase  (						)     ->     Dict:







				'''simple docstring'''


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





def      UpperCAmelCase  (						)     ->     Optional[Any]:







				'''simple docstring'''


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





def      UpperCAmelCase  (						UpperCamelCase__   )     ->     Tuple:







				'''simple docstring'''


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

				__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      UpperCAmelCase  (						UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__   )     ->     Optional[Any]:







				'''simple docstring'''


				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(UpperCamelCase__   ).permute(3						,			2						,			0						,			1   )
								elif "embeddings" in key:
												__lowerCAmelCase					=  torch.from_numpy(UpperCamelCase__   )
								elif "depthwise_kernel" in key:
												__lowerCAmelCase					=  torch.from_numpy(UpperCamelCase__   ).permute(2						,			3						,			0						,			1   )
								elif "kernel" in key:
												__lowerCAmelCase					=  torch.from_numpy(np.transpose(UpperCamelCase__   )   )
								elif "temperature" in key:
												__lowerCAmelCase					=  value
								elif "bn/gamma" or "bn/beta" in key:
												__lowerCAmelCase					=  torch.from_numpy(np.transpose(UpperCamelCase__   )   ).squeeze()
								else:
												__lowerCAmelCase					=  torch.from_numpy(UpperCamelCase__   )

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





@torch.no_grad()
def      UpperCAmelCase  (						UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__   )     ->     List[str]:







				'''simple docstring'''


				__lowerCAmelCase					=  64
				__lowerCAmelCase					=  Tokenizer(UpperCamelCase__   )
				__lowerCAmelCase					=  align.Align("""efficientnet-b7"""						,			"""bert-base"""						,			6_40						,			UpperCamelCase__						,			tok.get_vocab_size()   )
				original_model.compile()
				original_model.load_weights(UpperCamelCase__   )

				__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(UpperCamelCase__   ).eval()
				__lowerCAmelCase					=  hf_model.state_dict()

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

				# 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(**UpperCamelCase__   )

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

				# Original model inference
				__lowerCAmelCase					=  False
				__lowerCAmelCase					=  EfficientNetImageProcessor(
				    do_center_crop=UpperCamelCase__						,			do_rescale=UpperCamelCase__						,			do_normalize=UpperCamelCase__						,			include_top=UpperCamelCase__						,			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(UpperCamelCase__						,			training=UpperCamelCase__   )
				__lowerCAmelCase					=  original_model.text_encoder(UpperCamelCase__						,			training=UpperCamelCase__   )

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

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

				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__":
	__A						:		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")

	__A						:		Union[str, Any]          =						parser.parse_args()
	convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)












import numpy as np
import requests


def      SCREAMING_SNAKE_CASE      (   ):
       _UpperCamelCase														=    requests.get(
           '''https://raw.githubusercontent.com/yashLadha/The_Math_of_Intelligence/'''
           '''master/Week1/ADRvsRating.csv'''       )
       _UpperCamelCase														=    response.text.splitlines()
       _UpperCamelCase														=    []
       for item in lines:
              _UpperCamelCase														=    item.split(''','''       )
              data.append(lowerCAmelCase       )
       data.pop(0       )  # This is for removing the labels from the list
       _UpperCamelCase														=    np.matrix(lowerCAmelCase       )
       return dataset


def      SCREAMING_SNAKE_CASE      (   lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase       ):
       _UpperCamelCase														=    len_data

       _UpperCamelCase														=    np.dot(lowerCAmelCase     ,							data_x.transpose()       )
       prod -= data_y.transpose()
       _UpperCamelCase														=    np.dot(lowerCAmelCase     ,							lowerCAmelCase       )
       _UpperCamelCase														=    theta - (alpha / n) * sum_grad
       return theta


def      SCREAMING_SNAKE_CASE      (   lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase       ):
       _UpperCamelCase														=    np.dot(lowerCAmelCase     ,							data_x.transpose()       )
       prod -= data_y.transpose()
       _UpperCamelCase														=    np.sum(np.square(lowerCAmelCase       )       )
       _UpperCamelCase														=    sum_elem / (2 * len_data)
       return error


def      SCREAMING_SNAKE_CASE      (   lowerCAmelCase     ,							lowerCAmelCase       ):
       _UpperCamelCase														=    100_000
       _UpperCamelCase														=    0.0_0_0_1_5_5_0

       _UpperCamelCase														=    data_x.shape[1]
       _UpperCamelCase														=    data_x.shape[0] - 1

       _UpperCamelCase														=    np.zeros((1, no_features)       )

       for i in range(0     ,							lowerCAmelCase       ):
              _UpperCamelCase														=    run_steep_gradient_descent(lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase       )
              _UpperCamelCase														=    sum_of_square_error(lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase     ,							lowerCAmelCase       )
              print(f'''At Iteration {i + 1} - Error is {error:.5f}'''       )

       return theta


def      SCREAMING_SNAKE_CASE      (   lowerCAmelCase     ,							lowerCAmelCase       ):
       _UpperCamelCase														=    sum(abs(y - predicted_y[i]       ) for i, y in enumerate(lowerCAmelCase       )       )
       return total / len(lowerCAmelCase       )


def      SCREAMING_SNAKE_CASE      (   ):
       _UpperCamelCase														=    collect_dataset()

       _UpperCamelCase														=    data.shape[0]
       _UpperCamelCase														=    np.c_[np.ones(lowerCAmelCase       ), data[:, :-1]].astype(lowerCAmelCase       )
       _UpperCamelCase														=    data[:, -1].astype(lowerCAmelCase       )

       _UpperCamelCase														=    run_linear_regression(lowerCAmelCase     ,							lowerCAmelCase       )
       _UpperCamelCase														=    theta.shape[1]
       print('''Resultant Feature vector : '''       )
       for i in range(0     ,							lowerCAmelCase       ):
              print(f'''{theta[0, i]:.5f}'''       )


if __name__ == "__main__":
       main()






