






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()
lowerCamelCase					    =	logging.get_logger(__name__)
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						tf.image.resize(A_,   (346, 346)   )
    _lowercase     			=						tf.image.crop_to_bounding_box(A_,   (346 - 289) // 2,   (346 - 289) // 2,   289,   289   )
    return image
def 							UpperCAmelCase   ( ):


    '''simple docstring'''



    _lowercase     			=						EfficientNetConfig.from_pretrained('google/efficientnet-b7'   )
    _lowercase     			=						289
    _lowercase     			=						640
    _lowercase     			=						{'''0''': '''LABEL_0''', '''1''': '''LABEL_1'''}
    _lowercase     			=						{'''LABEL_0''': 0, '''LABEL_1''': 1}
    _lowercase     			=						[]

    _lowercase     			=						BertConfig()
    _lowercase     			=						AlignConfig.from_text_vision_configs(
        text_config=A_,   vision_config=A_,   projection_dim=640   )
    return config
def 							UpperCAmelCase   ( ):


    '''simple docstring'''



    _lowercase     			=						'''http://images.cocodataset.org/val2017/000000039769.jpg'''
    _lowercase     			=						Image.open(requests.get(A_,   stream=A_   ).raw   )
    return im
def 							UpperCAmelCase   ( ):


    '''simple docstring'''



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


    '''simple docstring'''



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

    _lowercase     			=						[]
    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:
        _lowercase     			=						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''')   )

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

    # BERT text encoder
    _lowercase     			=						[]
    _lowercase     			=						'''tf_bert_model/bert'''
    _lowercase     			=						'''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:
            _lowercase     			=						item[1]
    return key_mapping
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase   ):


    '''simple docstring'''



    list(hf_params.keys()   )

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

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

        # Replace HF parameters with original TF model parameters
        hf_params[hf_key].copy_(A_   )
@torch.no_grad()
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase,   _lowercase   ):


    '''simple docstring'''



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

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

    # Load HuggingFace model
    _lowercase     			=						get_align_config()
    _lowercase     			=						AlignModel(A_   ).eval()
    _lowercase     			=						hf_model.state_dict()

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

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

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

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

    _lowercase     			=						original_model.image_encoder(A_,   training=A_   )
    _lowercase     			=						original_model.text_encoder(A_,   training=A_   )

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

   lowerCamelCase					    =	parser.parse_args()
   convert_align_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)


'''simple docstring'''





import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute

def   A			(							A_				:       float = np.pi / 2     ,				A_				:       float = np.pi / 2     ,				A_				:       float = np.pi / 2							):
						snake_case							:  List[Any]			=     QuantumRegister(3     ,				'''qr'''							)  # Define the number of quantum bits
						snake_case							:  List[Any]			=     ClassicalRegister(1     ,				'''cr'''							)  # Define the number of classical bits

						snake_case							:  Dict			=     QuantumCircuit(A_     ,				A_							)  # Define the quantum circuit.

						# Build the circuit
						quantum_circuit.u(A_     ,				A_     ,				A_     ,				0							)  # Quantum State to teleport
						quantum_circuit.h(1							)  # add hadamard gate
						quantum_circuit.cx(
						    1     ,				2							)  # add control gate with qubit 1 as control and 2 as target.
						quantum_circuit.cx(0     ,				1							)
						quantum_circuit.h(0							)
						quantum_circuit.cz(0     ,				2							)  # add control z gate.
						quantum_circuit.cx(1     ,				2							)

						quantum_circuit.measure([2]     ,				[0]							)  # measure the qubit.

						# Simulate the circuit using qasm simulator
						snake_case							:  str			=     Aer.get_backend('''aer_simulator'''							)
						snake_case							:  List[str]			=     execute(A_     ,				A_     ,				shots=1000							)

						return job.result().get_counts(A_							)


if __name__ == "__main__":
						print(
						    "Total count for teleported state is: "
						    f'''{quantum_teleportation(np.pi/2, np.pi/2, np.pi/2)}'''
						)

