





'''simple docstring'''






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_     			=						logging.get_logger(__name__)
def 				_lowerCamelCase(	UpperCamelCase__     :			Optional[Any]		)		->	str:
    A							:							Dict				=    tf.image.resize(UpperCamelCase__     ,							(346, 346)		)
    A							:							Union[str, Any]				=    tf.image.crop_to_bounding_box(UpperCamelCase__     ,							(346 - 289) // 2     ,							(346 - 289) // 2     ,							289     ,							289		)
    return image
def 				_lowerCamelCase(	)		->	Any:
    A							:							List[Any]				=    EfficientNetConfig.from_pretrained('''google/efficientnet-b7'''		)
    A							:							Any				=    289
    A							:							Optional[Any]				=    640
    A							:							Tuple				=    {'''0''': '''LABEL_0''', '''1''': '''LABEL_1'''}
    A							:							Optional[int]				=    {'''LABEL_0''': 0, '''LABEL_1''': 1}
    A							:							Union[str, Any]				=    []

    A							:							Dict				=    BertConfig()
    A							:							Any				=    AlignConfig.from_text_vision_configs(
        text_config=UpperCamelCase__     ,							vision_config=UpperCamelCase__     ,							projection_dim=640		)
    return config
def 				_lowerCamelCase(	)		->	str:
    A							:							Union[str, Any]				=    '''http://images.cocodataset.org/val2017/000000039769.jpg'''
    A							:							List[str]				=    Image.open(requests.get(UpperCamelCase__     ,							stream=UpperCamelCase__		).raw		)
    return im
def 				_lowerCamelCase(	)		->	List[Any]:
    A							:							Union[str, Any]				=    EfficientNetImageProcessor(
        do_center_crop=UpperCamelCase__     ,							rescale_factor=1 / 1_2_7.5     ,							rescale_offset=UpperCamelCase__     ,							do_normalize=UpperCamelCase__     ,							include_top=UpperCamelCase__     ,							resample=Image.BILINEAR     ,							)
    A							:							Dict				=    BertTokenizer.from_pretrained('''bert-base-uncased'''		)
    A							:							int				=    64
    A							:							Union[str, Any]				=    AlignProcessor(image_processor=UpperCamelCase__     ,							tokenizer=UpperCamelCase__		)
    return processor
def 				_lowerCamelCase(	UpperCamelCase__     :			Optional[Any]		)		->	List[Any]:
    # EfficientNet image encoder
    A							:							List[str]				=    [v.split('''_'''		)[0].split('''block'''		)[1] for v in original_param_names if v.startswith('''block'''		)]
    A							:							int				=    list(set(UpperCamelCase__		)		)
    A							:							Union[str, Any]				=    sorted(UpperCamelCase__		)
    A							:							List[str]				=    len(UpperCamelCase__		)
    A							:							List[Any]				=    {b: str(UpperCamelCase__		) for b, i in zip(UpperCamelCase__     ,							range(UpperCamelCase__		)		)}

    A							:							Any				=    []
    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							:							Dict				=    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							:							Union[str, Any]				=    {}
    for item in rename_keys:
        if item[0] in original_param_names:
            A							:							List[str]				=    '''vision_model.''' + item[1]

    # BERT text encoder
    A							:							List[str]				=    []
    A							:							Optional[Any]				=    '''tf_bert_model/bert'''
    A							:							List[str]				=    '''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							:							Dict				=    item[1]
    return key_mapping
def 				_lowerCamelCase(	UpperCamelCase__     :			List[str]     ,							UpperCamelCase__     :			Tuple     ,							UpperCamelCase__     :			Dict		)		->	str:
    list(hf_params.keys()		)

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

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

        # Replace HF parameters with original TF model parameters
        hf_params[hf_key].copy_(UpperCamelCase__		)
@torch.no_grad()
def 				_lowerCamelCase(	UpperCamelCase__     :			Tuple     ,							UpperCamelCase__     :			List[str]     ,							UpperCamelCase__     :			Dict     ,							UpperCamelCase__     :			Union[str, Any]		)		->	Dict:
    A							:							List[Any]				=    64
    A							:							int				=    Tokenizer(UpperCamelCase__		)
    A							:							Dict				=    align.Align('''efficientnet-b7'''     ,							'''bert-base'''     ,							640     ,							UpperCamelCase__     ,							tok.get_vocab_size()		)
    original_model.compile()
    original_model.load_weights(UpperCamelCase__		)

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

    # Load HuggingFace model
    A							:							Union[str, Any]				=    get_align_config()
    A							:							Optional[int]				=    AlignModel(UpperCamelCase__		).eval()
    A							:							Any				=    hf_model.state_dict()

    # Create src-to-dst parameter name mapping dictionary
    print('''Converting parameters...'''		)
    A							:							Optional[int]				=    rename_keys(UpperCamelCase__		)
    replace_params(UpperCamelCase__     ,							UpperCamelCase__     ,							UpperCamelCase__		)

    # Initialize processor
    A							:							str				=    get_processor()
    A							:							int				=    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							:							Any				=    hf_model(**UpperCamelCase__		)

    A							:							Union[str, Any]				=    outputs.image_embeds.detach().numpy()
    A							:							List[str]				=    outputs.text_embeds.detach().numpy()

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

    A							:							Any				=    original_model.image_encoder(UpperCamelCase__     ,							training=UpperCamelCase__		)
    A							:							Optional[Any]				=    original_model.text_encoder(UpperCamelCase__     ,							training=UpperCamelCase__		)

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







'''simple docstring'''






import timeit


class 	_lowercase    :


   def __init__(			self     , _UpperCAmelCase       ):
       if isinstance(_UpperCAmelCase     , _UpperCAmelCase       ):  # Initializes a matrix identical to the one provided.
           A							:							List[Any]				=    arg
           A							:							Dict				=    len(_UpperCAmelCase       )
       else:  # Initializes a square matrix of the given size and set values to zero.
           A							:							str				=    arg
           A							:							Union[str, Any]				=    [[0 for _ in range(self.n       )] for _ in range(self.n       )]


   def __mul__(			self     , _UpperCAmelCase       ):
       A							:							List[str]				=    Matrix(self.n       )
       for i in range(self.n       ):
           for j in range(self.n       ):
               for k in range(self.n       ):
                   matrix.t[i][j] += self.t[i][k] * b.t[k][j]
       return matrix







def 				_lowerCamelCase(	UpperCamelCase__     :			Union[str, Any]     ,							UpperCamelCase__     :			int		)		->	Union[str, Any]:
    A							:							Tuple				=    Matrix([[1, 0], [0, 1]]		)
    while b > 0:
        if b & 1:
            matrix *= a
        a *= a
        b >>= 1
    return matrix
def 				_lowerCamelCase(	UpperCamelCase__     :			int     ,							UpperCamelCase__     :			Tuple     ,							UpperCamelCase__     :			Any		)		->	Any:
    # Trivial Cases
    if n == 1:
        return fa
    elif n == 2:
        return fa
    A							:							Optional[Any]				=    Matrix([[1, 1], [1, 0]]		)
    A							:							int				=    modular_exponentiation(UpperCamelCase__     ,							n - 2		)
    return fa * matrix.t[0][0] + fa * matrix.t[0][1]
def 				_lowerCamelCase(	UpperCamelCase__     :			str     ,							UpperCamelCase__     :			Optional[Any]     ,							UpperCamelCase__     :			Any		)		->	List[Any]:
    # Trivial Cases
    if n == 1:
        return fa
    elif n == 2:
        return fa

    A							:							str				=    fa
    A							:							List[Any]				=    fa
    n -= 2

    while n > 0:
        A,						A							:							List[str]				=    fn_a + fn_a, fn_a
        n -= 1

    return fn_a
def 				_lowerCamelCase(	)		->	Union[str, Any]:
    A							:							Any				=    '''
from random import randint
from __main__ import fibonacci_with_matrix_exponentiation
'''
    A							:							Optional[int]				=    '''fibonacci_with_matrix_exponentiation(randint(1,70000), 1, 1)'''
    A							:							List[Any]				=    timeit.timeit(setup=UpperCamelCase__     ,							stmt=UpperCamelCase__     ,							number=100		)
    print('''With matrix exponentiation the average execution time is '''     ,							exec_time / 100		)
    return exec_time
def 				_lowerCamelCase(	)		->	List[Any]:
    A							:							str				=    '''
from random import randint
from __main__ import simple_fibonacci
'''
    A							:							Any				=    '''simple_fibonacci(randint(1,70000), 1, 1)'''
    A							:							str				=    timeit.timeit(setup=UpperCamelCase__     ,							stmt=UpperCamelCase__     ,							number=100		)
    print(
        '''Without matrix exponentiation the average execution time is '''     ,							exec_time / 100		)
    return exec_time
def 				_lowerCamelCase(	)		->	Optional[Any]:
    matrix_exponentiation_time()
    simple_fibonacci_time()


if __name__ == "__main__":
     main()
