





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__:  Union[str, Any]       					=					logging.get_logger(__name__)



def 							lowerCAmelCase_				(    A_):
    UpperCamelCase__:					List[Any]												=      tf.image.resize(lowercase__  ,(3_46, 3_46))
    UpperCamelCase__:					List[Any]												=      tf.image.crop_to_bounding_box(lowercase__  ,(3_46 - 2_89) // 2  ,(3_46 - 2_89) // 2  ,2_89  ,2_89)
    return image



def 							lowerCAmelCase_				(    ):
    UpperCamelCase__:					List[Any]												=      EfficientNetConfig.from_pretrained("google/efficientnet-b7")
    UpperCamelCase__:					Optional[int]												=      2_89
    UpperCamelCase__:					str												=      6_40
    UpperCamelCase__:					List[str]												=      {"0": "LABEL_0", "1": "LABEL_1"}
    UpperCamelCase__:					int												=      {"LABEL_0": 0, "LABEL_1": 1}
    UpperCamelCase__:					List[Any]												=      []

    UpperCamelCase__:					int												=      BertConfig()
    UpperCamelCase__:					str												=      AlignConfig.from_text_vision_configs(
        text_config=lowercase__  ,vision_config=lowercase__  ,projection_dim=6_40)
    return config



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



def 							lowerCAmelCase_				(    ):
    UpperCamelCase__:					str												=      EfficientNetImageProcessor(
        do_center_crop=lowercase__  ,rescale_factor=1 / 1_27.5  ,rescale_offset=lowercase__  ,do_normalize=lowercase__  ,include_top=lowercase__  ,resample=Image.BILINEAR  ,)
    UpperCamelCase__:					List[str]												=      BertTokenizer.from_pretrained("bert-base-uncased")
    UpperCamelCase__:					List[Any]												=      64
    UpperCamelCase__:					Union[str, Any]												=      AlignProcessor(image_processor=lowercase__  ,tokenizer=lowercase__)
    return processor



def 							lowerCAmelCase_				(    A_):
    # EfficientNet image encoder
    UpperCamelCase__:					Dict												=      [v.split("_")[0].split("block")[1] for v in original_param_names if v.startswith("block")]
    UpperCamelCase__:					Dict												=      list(set(lowercase__))
    UpperCamelCase__:					Optional[int]												=      sorted(lowercase__)
    UpperCamelCase__:					List[Any]												=      len(lowercase__)
    UpperCamelCase__:					int												=      {b: str(lowercase__) for b, i in zip(lowercase__  ,range(lowercase__))}

    UpperCamelCase__:					Optional[int]												=      []
    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__:					List[Any]												=      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__:					Tuple												=      {}
    for item in rename_keys:
        if item[0] in original_param_names:
            UpperCamelCase__:					Optional[int]												=      "vision_model." + item[1]

    # BERT text encoder
    UpperCamelCase__:					List[Any]												=      []
    UpperCamelCase__:					str												=      "tf_bert_model/bert"
    UpperCamelCase__:					List[Any]												=      "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__:					int												=      item[1]
    return key_mapping



def 							lowerCAmelCase_				(    A_  ,A_  ,A_):
    list(hf_params.keys())

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

        UpperCamelCase__:					Optional[Any]												=      key_mapping[key]
        if "_conv" in key and "kernel" in key:
            UpperCamelCase__:					Optional[Any]												=      torch.from_numpy(lowercase__).permute(3  ,2  ,0  ,1)
        elif "embeddings" in key:
            UpperCamelCase__:					Any												=      torch.from_numpy(lowercase__)
        elif "depthwise_kernel" in key:
            UpperCamelCase__:					Tuple												=      torch.from_numpy(lowercase__).permute(2  ,3  ,0  ,1)
        elif "kernel" in key:
            UpperCamelCase__:					str												=      torch.from_numpy(np.transpose(lowercase__))
        elif "temperature" in key:
            UpperCamelCase__:					Optional[Any]												=      value
        elif "bn/gamma" or "bn/beta" in key:
            UpperCamelCase__:					Optional[int]												=      torch.from_numpy(np.transpose(lowercase__)).squeeze()
        else:
            UpperCamelCase__:					List[str]												=      torch.from_numpy(lowercase__)

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



@torch.no_grad()
def 							lowerCAmelCase_				(    A_  ,A_  ,A_  ,A_):
    UpperCamelCase__:					Optional[Any]												=      64
    UpperCamelCase__:					str												=      Tokenizer(lowercase__)
    UpperCamelCase__:					Tuple												=      align.Align("efficientnet-b7"  ,"bert-base"  ,6_40  ,lowercase__  ,tok.get_vocab_size())
    original_model.compile()
    original_model.load_weights(lowercase__)

    UpperCamelCase__:					int												=      original_model.trainable_variables
    UpperCamelCase__:					Tuple												=      original_model.non_trainable_variables
    UpperCamelCase__:					Optional[Any]												=      {param.name: param.numpy() for param in tf_params}
    for param in tf_non_train_params:
        UpperCamelCase__:					Dict												=      param.numpy()
    UpperCamelCase__:					List[str]												=      list(tf_params.keys())

    # Load HuggingFace model
    UpperCamelCase__:					int												=      get_align_config()
    UpperCamelCase__:					Tuple												=      AlignModel(lowercase__).eval()
    UpperCamelCase__:					int												=      hf_model.state_dict()

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

    # Initialize processor
    UpperCamelCase__:					Union[str, Any]												=      get_processor()
    UpperCamelCase__:					Dict												=      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__:					int												=      hf_model(**lowercase__)

    UpperCamelCase__:					Dict												=      outputs.image_embeds.detach().numpy()
    UpperCamelCase__:					Dict												=      outputs.text_embeds.detach().numpy()

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

    UpperCamelCase__:					Dict												=      original_model.image_encoder(lowercase__  ,training=lowercase__)
    UpperCamelCase__:					str												=      original_model.text_encoder(lowercase__  ,training=lowercase__)

    UpperCamelCase__:					Dict												=      tf.nn.la_normalize(lowercase__  ,axis=-1)
    UpperCamelCase__:					str												=      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__":
   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__:  List[Any]       					=					parser.parse_args()
   convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A__:  List[str]       					=					{
    '''configuration_wav2vec2_conformer''': [
        '''WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Wav2Vec2ConformerConfig''',
    ],
}


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A__:  int       					=					[
       '''WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''Wav2Vec2ConformerForAudioFrameClassification''',
       '''Wav2Vec2ConformerForCTC''',
       '''Wav2Vec2ConformerForPreTraining''',
       '''Wav2Vec2ConformerForSequenceClassification''',
       '''Wav2Vec2ConformerForXVector''',
       '''Wav2Vec2ConformerModel''',
       '''Wav2Vec2ConformerPreTrainedModel''',
   ]

if TYPE_CHECKING:
   from .configuration_wavaveca_conformer import (
       WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
       WavaVecaConformerConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_wavaveca_conformer import (
          WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          WavaVecaConformerForAudioFrameClassification,
          WavaVecaConformerForCTC,
          WavaVecaConformerForPreTraining,
          WavaVecaConformerForSequenceClassification,
          WavaVecaConformerForXVector,
          WavaVecaConformerModel,
          WavaVecaConformerPreTrainedModel,
      )

else:
   import sys

   A__:  Dict       					=					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

