



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      (	_UpperCAmelCase							:  Dict       )							->					List[str]:







			'''simple docstring'''
			_UpperCAmelCase									=  tf.image.resize(_UpperCAmelCase				,  (346, 346)       )
			_UpperCAmelCase									=  tf.image.crop_to_bounding_box(_UpperCAmelCase				,  (346 - 289) // 2				,  (346 - 289) // 2				,  289				,  289       )
			return image





def 				A      (	)							->					Optional[int]:







			'''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=_UpperCAmelCase				,  vision_config=_UpperCAmelCase				,  projection_dim=640       )
			return config





def 				A      (	)							->					List[Any]:







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





def 				A      (	)							->					List[Any]:







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





def 				A      (	_UpperCAmelCase							:  int       )							->					List[str]:







			'''simple docstring'''
			# EfficientNet image encoder
			_UpperCAmelCase									=  [v.split('_'       )[0].split('block'       )[1] for v in original_param_names if v.startswith('block'       )]
			_UpperCAmelCase									=  list(set(_UpperCAmelCase       )       )
			_UpperCAmelCase									=  sorted(_UpperCAmelCase       )
			_UpperCAmelCase									=  len(_UpperCAmelCase       )
			_UpperCAmelCase									=  {b: str(_UpperCAmelCase       ) for b, i in zip(_UpperCAmelCase				,  range(_UpperCAmelCase       )       )}

			_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      (	_UpperCAmelCase							:  List[str]				,  _UpperCAmelCase							:  Union[str, Any]				,  _UpperCAmelCase							:  Dict       )							->					List[Any]:







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

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





@torch.no_grad()
def 				A      (	_UpperCAmelCase							:  Any				,  _UpperCAmelCase							:  Union[str, Any]				,  _UpperCAmelCase							:  Optional[int]				,  _UpperCAmelCase							:  List[Any]       )							->					List[Any]:







			'''simple docstring'''
			_UpperCAmelCase									=  64
			_UpperCAmelCase									=  Tokenizer(_UpperCAmelCase       )
			_UpperCAmelCase									=  align.Align('efficientnet-b7'				,  'bert-base'				,  640				,  _UpperCAmelCase				,  tok.get_vocab_size()       )
			original_model.compile()
			original_model.load_weights(_UpperCAmelCase       )

			_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(_UpperCAmelCase       ).eval()
			_UpperCAmelCase									=  hf_model.state_dict()

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

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

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

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

			_UpperCAmelCase									=  tf.nn.la_normalize(_UpperCAmelCase				,  axis=-1       )
			_UpperCAmelCase									=  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__":
							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)





UpperCAmelCase__  =			10**8





def 				A      (	_UpperCAmelCase							:  int       )							->					bool:







			'''simple docstring'''
			if n % 10 == 0:
						return False
			_UpperCAmelCase									=  str(_UpperCAmelCase       )
			return s == s[::-1]





def 				A      (	)							->					int:







			'''simple docstring'''
			_UpperCAmelCase									=  set()
			_UpperCAmelCase									=  1
			_UpperCAmelCase									=  5
			while sum_squares < LIMIT:
						_UpperCAmelCase									=  first_square + 1
						while sum_squares < LIMIT:
									if is_palindrome(_UpperCAmelCase       ):
												answer.add(_UpperCAmelCase       )
									last_square += 1
									sum_squares += last_square**2
						first_square += 1
						_UpperCAmelCase									=  first_square**2 + (first_square + 1) ** 2

			return sum(_UpperCAmelCase       )


if __name__ == "__main__":
							print(solution())
