





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



def _a							(      lowerCamelCase:  str					)      ->		List[str]:







      '''simple docstring'''






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



def _a							(      )      ->		int:







      '''simple docstring'''






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

      __A			  =							BertConfig()
      __A			  =							AlignConfig.from_text_vision_configs(
          text_config=lowerCamelCase   ,							vision_config=lowerCamelCase   ,							projection_dim=6_40					)
      return config



def _a							(      )      ->		Optional[int]:







      '''simple docstring'''






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



def _a							(      )      ->		int:







      '''simple docstring'''






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



def _a							(      lowerCamelCase:  str					)      ->		Dict:







      '''simple docstring'''






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

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

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

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



def _a							(      lowerCamelCase:  Dict   ,							lowerCamelCase:  Dict   ,							lowerCamelCase:  Dict					)      ->		Union[str, Any]:







      '''simple docstring'''






      list(hf_params.keys()					)

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

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

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



@torch.no_grad()
def _a							(      lowerCamelCase:  Optional[Any]   ,							lowerCamelCase:  List[Any]   ,							lowerCamelCase:  Any   ,							lowerCamelCase:  Any					)      ->		int:







      '''simple docstring'''






      __A			  =							64
      __A			  =							Tokenizer(lowerCamelCase					)
      __A			  =							align.Align('''efficientnet-b7'''   ,							'''bert-base'''   ,							6_40   ,							lowerCamelCase   ,							tok.get_vocab_size()					)
      original_model.compile()
      original_model.load_weights(lowerCamelCase					)

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

      # Load HuggingFace model
      __A			  =							get_align_config()
      __A			  =							AlignModel(lowerCamelCase					).eval()
      __A			  =							hf_model.state_dict()

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

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

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

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

      __A			  =							original_model.image_encoder(lowerCamelCase   ,							training=lowerCamelCase					)
      __A			  =							original_model.text_encoder(lowerCamelCase   ,							training=lowerCamelCase					)

      __A			  =							tf.nn.la_normalize(lowerCamelCase   ,							axis=-1					)
      __A			  =							tf.nn.la_normalize(lowerCamelCase   ,							axis=-1					)

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

      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__":
       snake_case__   :				Any						=	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')

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












def _a							(      lowerCamelCase:  List[Any]					)      ->		Optional[Any]:







      '''simple docstring'''






      __A			  =							[7_01, 3_01, 1_32, 57, 23, 10, 4, 1]
      for gap in gaps:
            for i in range(lowerCamelCase   ,							len(lowerCamelCase					)					):
                  __A			  =							collection[i]
                  __A			  =							i
                  while j >= gap and collection[j - gap] > insert_value:
                        __A			  =							collection[j - gap]
                        j -= gap
                  if j != i:
                        __A			  =							insert_value
      return collection


if __name__ == "__main__":
       from doctest import testmod

       testmod()
       snake_case__   :				Optional[int]						=	input('Enter numbers separated by a comma:\n').strip()
       snake_case__   :				int						=	[int(item) for item in user_input.split(',')]
       print(shell_sort(unsorted))





