




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


def   A		(__A  :       str			)  -> str:







     """simple docstring"""


     UpperCAmelCase_		=				tf.image.resize(__A  ,							(346, 346)			)
     UpperCAmelCase_		=				tf.image.crop_to_bounding_box(__A  ,							(346 - 289) // 2  ,							(346 - 289) // 2  ,							289  ,							289			)
     return image


def   A		()  -> Tuple:







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


def   A		()  -> str:







     """simple docstring"""


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


def   A		()  -> Optional[Any]:







     """simple docstring"""


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


def   A		(__A  :       Any			)  -> Any:







     """simple docstring"""


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

     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		(__A  :       List[Any]  ,							__A  :       Optional[Any]  ,							__A  :       Any			)  -> int:







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

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


@torch.no_grad()
def   A		(__A  :       Dict  ,							__A  :       Dict  ,							__A  :       List[Any]  ,							__A  :       Union[str, Any]			)  -> Tuple:







     """simple docstring"""


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

     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(__A			).eval()
     UpperCAmelCase_		=				hf_model.state_dict()

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

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

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

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

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

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

     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_					:					List[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")

    snake_case_					:					str       						=			parser.parse_args()
    convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)












import warnings

from ...utils import logging
from .image_processing_levit import LevitImageProcessor


snake_case_					:					Dict       						=			logging.get_logger(__name__)







class __snake_case     (     a						):







   def __init__( self						:		Union[str, Any]   ,		*_snake_case						:		int   ,		**_snake_case						:		List[str]):

        """simple docstring"""


        warnings.warn(
            '''The class LevitFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
            ''' use LevitImageProcessor instead.'''   ,		_snake_case   ,		)
        super().__init__(*_snake_case   ,		**_snake_case)






