




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




def        __SCREAMING_SNAKE_CASE (	lowercase_ = np.pi / 2       ,  lowercase_ = np.pi / 2       ,  lowercase_ = np.pi / 2   )							->						qiskit.result.counts.Counts:

    """simple docstring"""


    __UpperCamelCase			=    QuantumRegister(3       ,  '''qr'''   )  # Define the number of quantum bits
    __UpperCamelCase			=    ClassicalRegister(1       ,  '''cr'''   )  # Define the number of classical bits

    __UpperCamelCase			=    QuantumCircuit(lowercase_       ,  lowercase_   )  # Define the quantum circuit.

    # Build the circuit
    quantum_circuit.u(lowercase_       ,  lowercase_       ,  lowercase_       ,  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
    __UpperCamelCase			=    Aer.get_backend('''aer_simulator'''   )
    __UpperCamelCase			=    execute(lowercase_       ,  lowercase_       ,  shots=10_00   )

    return job.result().get_counts(lowercase_   )


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








import argparse
import os
import pathlib

import fairseq
import torch
from fairseq.modules import TransformerSentenceEncoderLayer
from packaging import version

from transformers import (
    DataaVecTextConfig,
    DataaVecTextForMaskedLM,
    DataaVecTextForSequenceClassification,
    DataaVecTextModel,
)
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertSelfAttention,
    BertSelfOutput,
)

# IMPORTANT: In order for this script to run, please make sure to download the dictionary: `dict.txt` from wget https://dl.fbaipublicfiles.com/fairseq/models/roberta.large.tar.gz
# File copied from https://github.com/pytorch/fairseq/blob/main/examples/data2vec/models/data2vec_text.py
from transformers.utils import logging


if version.parse(fairseq.__version__) < version.parse('''0.9.0'''):
      raise Exception('''requires fairseq >= 0.9.0''')


logging.set_verbosity_info()
a__				:      Dict    		=     logging.get_logger(__name__)

a__				:      str    		=     '''Hello world! cécé herlolip'''







def 				UpperCAmelCase_(    a__ ,						a__ ,						a__   ):



    """simple docstring"""



    SCREAMING_SNAKE_CASE      ,							SCREAMING_SNAKE_CASE				:				List[str]				      = os.path.split(a__   )
    SCREAMING_SNAKE_CASE				:				Any				      = DataaVecTextModel.from_pretrained(
        a__ ,						checkpoint_file=a__   )
    dataavec.eval()  # disable dropout
    SCREAMING_SNAKE_CASE				:				Optional[Any]				      = dataavec.models[0]
    SCREAMING_SNAKE_CASE				:				Optional[Any]				      = dataavec_model.encoder.sentence_encoder
    SCREAMING_SNAKE_CASE				:				List[str]				      = DataaVecTextConfig(
        vocab_size=dataavec_sent_encoder.embed_tokens.num_embeddings ,						hidden_size=dataavec_model.args.encoder_embed_dim ,						num_hidden_layers=dataavec_model.args.encoder_layers ,						num_attention_heads=dataavec_model.args.encoder_attention_heads ,						intermediate_size=dataavec_model.args.encoder_ffn_embed_dim ,						max_position_embeddings=514 ,						type_vocab_size=1 ,						layer_norm_eps=1e-5 ,						)
    if classification_head:
        SCREAMING_SNAKE_CASE				:				Optional[int]				      = dataavec.model.classification_heads['''mnli'''].out_proj.weight.shape[0]
    print('''Our BERT config:''' ,						a__   )

    SCREAMING_SNAKE_CASE				:				Optional[Any]				      = DataaVecTextForSequenceClassification(a__   ) if classification_head else DataaVecTextForMaskedLM(a__   )
    model.eval()

    # Now let's copy all the weights.
    # Embeddings
    SCREAMING_SNAKE_CASE				:				Tuple				      = dataavec_sent_encoder.embed_tokens.weight
    SCREAMING_SNAKE_CASE				:				int				      = dataavec_sent_encoder.embed_positions.weight
    SCREAMING_SNAKE_CASE				:				int				      = torch.zeros_like(
        model.dataavec_text.embeddings.token_type_embeddings.weight   )  # just zero them out b/c data2vec doesn't use them.
    SCREAMING_SNAKE_CASE				:				Dict				      = dataavec_sent_encoder.layernorm_embedding.weight
    SCREAMING_SNAKE_CASE				:				Optional[Any]				      = dataavec_sent_encoder.layernorm_embedding.bias

    for i in range(config.num_hidden_layers   ):
        # Encoder: start of layer
        SCREAMING_SNAKE_CASE				:				BertLayer				      = model.dataavec_text.encoder.layer[i]
        SCREAMING_SNAKE_CASE				:				TransformerSentenceEncoderLayer				      = dataavec_sent_encoder.layers[i]

        # self attention
        SCREAMING_SNAKE_CASE				:				BertSelfAttention				      = layer.attention.self
        assert dataavec_layer.self_attn.k_proj.weight.data.shape == torch.Size(
            (config.hidden_size, config.hidden_size)   ), (
            "Shape for data2vec_layer.self_attn.k_proj.weight.data should be"
            F""" {torch.Size((config.hidden_size, config.hidden_size)   )}"""
        )
        assert dataavec_layer.self_attn.q_proj.weight.data.shape == torch.Size(
            (config.hidden_size, config.hidden_size)   ), (
            "Shape for data2vec_layer.self_attn.q_proj.weight.data should be"
            F""" {torch.Size((config.hidden_size, config.hidden_size)   )}"""
        )
        assert dataavec_layer.self_attn.v_proj.weight.data.shape == torch.Size(
            (config.hidden_size, config.hidden_size)   ), (
            "Shape for data2vec_layer.self_attn.v_proj.weight.data should be"
            F""" {torch.Size((config.hidden_size, config.hidden_size)   )}"""
        )

        SCREAMING_SNAKE_CASE				:				str				      = dataavec_layer.self_attn.q_proj.weight
        SCREAMING_SNAKE_CASE				:				Dict				      = dataavec_layer.self_attn.q_proj.bias
        SCREAMING_SNAKE_CASE				:				str				      = dataavec_layer.self_attn.k_proj.weight
        SCREAMING_SNAKE_CASE				:				Optional[Any]				      = dataavec_layer.self_attn.k_proj.bias
        SCREAMING_SNAKE_CASE				:				List[Any]				      = dataavec_layer.self_attn.v_proj.weight
        SCREAMING_SNAKE_CASE				:				Any				      = dataavec_layer.self_attn.v_proj.bias

        # self-attention output
        SCREAMING_SNAKE_CASE				:				BertSelfOutput				      = layer.attention.output
        assert (
            self_output.dense.weight.shape == dataavec_layer.self_attn.out_proj.weight.shape
        ), F"""Shape for self_output.dense.weight should be {dataavec_layer.self_attn.out_proj.weight.shape}"""
        SCREAMING_SNAKE_CASE				:				List[Any]				      = dataavec_layer.self_attn.out_proj.weight
        SCREAMING_SNAKE_CASE				:				Dict				      = dataavec_layer.self_attn.out_proj.bias
        SCREAMING_SNAKE_CASE				:				List[str]				      = dataavec_layer.self_attn_layer_norm.weight
        SCREAMING_SNAKE_CASE				:				List[str]				      = dataavec_layer.self_attn_layer_norm.bias

        # intermediate
        SCREAMING_SNAKE_CASE				:				BertIntermediate				      = layer.intermediate
        assert (
            intermediate.dense.weight.shape == dataavec_layer.fca.weight.shape
        ), F"""Shape for intermediate.dense.weight should be {dataavec_layer.fca.weight.shape}"""
        SCREAMING_SNAKE_CASE				:				List[str]				      = dataavec_layer.fca.weight
        SCREAMING_SNAKE_CASE				:				Optional[int]				      = dataavec_layer.fca.bias

        # output
        SCREAMING_SNAKE_CASE				:				BertOutput				      = layer.output
        assert (
            bert_output.dense.weight.shape == dataavec_layer.fca.weight.shape
        ), F"""Shape for bert_output.dense.weight should be {dataavec_layer.fca.weight.shape}"""
        SCREAMING_SNAKE_CASE				:				int				      = dataavec_layer.fca.weight
        SCREAMING_SNAKE_CASE				:				Any				      = dataavec_layer.fca.bias
        SCREAMING_SNAKE_CASE				:				Any				      = dataavec_layer.final_layer_norm.weight
        SCREAMING_SNAKE_CASE				:				Optional[Any]				      = dataavec_layer.final_layer_norm.bias
        # end of layer

    if classification_head:
        SCREAMING_SNAKE_CASE				:				Tuple				      = dataavec.model.classification_heads['''mnli'''].dense.weight
        SCREAMING_SNAKE_CASE				:				Tuple				      = dataavec.model.classification_heads['''mnli'''].dense.bias
        SCREAMING_SNAKE_CASE				:				Optional[Any]				      = dataavec.model.classification_heads['''mnli'''].out_proj.weight
        SCREAMING_SNAKE_CASE				:				Tuple				      = dataavec.model.classification_heads['''mnli'''].out_proj.bias
    else:
        # LM Head
        SCREAMING_SNAKE_CASE				:				Optional[int]				      = dataavec_model.encoder.lm_head.dense.weight
        SCREAMING_SNAKE_CASE				:				Optional[int]				      = dataavec_model.encoder.lm_head.dense.bias
        SCREAMING_SNAKE_CASE				:				Dict				      = dataavec_model.encoder.lm_head.layer_norm.weight
        SCREAMING_SNAKE_CASE				:				Optional[Any]				      = dataavec_model.encoder.lm_head.layer_norm.bias
        SCREAMING_SNAKE_CASE				:				Any				      = dataavec_model.encoder.lm_head.weight
        SCREAMING_SNAKE_CASE				:				List[str]				      = dataavec_model.encoder.lm_head.bias

    # Let's check that we get the same results.
    SCREAMING_SNAKE_CASE				:				torch.Tensor				      = dataavec.encode(a__   ).unsqueeze(0   )  # batch of size 1

    SCREAMING_SNAKE_CASE				:				List[str]				      = model(a__   )[0]
    if classification_head:
        SCREAMING_SNAKE_CASE				:				Tuple				      = dataavec.model.classification_heads['''mnli'''](dataavec.extract_features(a__   )   )
    else:
        SCREAMING_SNAKE_CASE				:				List[str]				      = dataavec_model(a__   )[0]
    print(our_output.shape ,						their_output.shape   )
    SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = torch.max(torch.abs(our_output - their_output   )   ).item()
    print(F"""max_absolute_diff = {max_absolute_diff}"""   )  # ~ 1e-7
    SCREAMING_SNAKE_CASE				:				Union[str, Any]				      = torch.allclose(a__ ,						a__ ,						atol=1e-3   )
    print('''Do both models output the same tensors?''' ,						'''🔥''' if success else '''💩'''   )
    if not success:
        raise Exception('''Something went wRoNg'''   )

    pathlib.Path(a__   ).mkdir(parents=a__ ,						exist_ok=a__   )
    print(F"""Saving model to {pytorch_dump_folder_path}"""   )
    model.save_pretrained(a__   )


if __name__ == "__main__":
      a__				:      str    		=     argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '''--checkpoint_path''', default=None, type=str, required=True, help='''Path the official PyTorch dump.'''
      )
      parser.add_argument(
          '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
      )
      parser.add_argument(
          '''--classification_head''', action='''store_true''', help='''Whether to convert a final classification head.'''
      )
      a__				:      int    		=     parser.parse_args()
      convert_dataavec_checkpoint_to_pytorch(
          args.checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
      )
