




import argparse
import json
import os.path
from collections import OrderedDict

import numpy as np
import requests
import torch
from flax.training.checkpoints import restore_checkpoint
from huggingface_hub import hf_hub_download

from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
from transformers.image_utils import PILImageResampling




def     __SCREAMING_SNAKE_CASE      (     lowercase_					)				->		Union[str, Any]:

    """simple docstring"""


    __UpperCamelCase     						=  '''https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint'''

    with open(__UpperCamelCase    ,   '''wb'''					) as f:
        with requests.get(__UpperCamelCase    ,   stream=__UpperCamelCase					) as req:
            for chunk in req.iter_content(chunk_size=20_48					):
                f.write(__UpperCamelCase					)




def     __SCREAMING_SNAKE_CASE      (     )				->		VivitConfig:

    """simple docstring"""


    __UpperCamelCase     						=  VivitConfig()

    __UpperCamelCase     						=  4_00
    __UpperCamelCase     						=  '''huggingface/label-files'''
    __UpperCamelCase     						=  '''kinetics400-id2label.json'''

    __UpperCamelCase     						=  json.load(open(hf_hub_download(__UpperCamelCase    ,   __UpperCamelCase    ,   repo_type='''dataset'''					)    ,   '''r'''					)					)
    __UpperCamelCase     						=  {int(__UpperCamelCase					): v for k, v in idalabel.items()}
    __UpperCamelCase     						=  idalabel
    __UpperCamelCase     						=  {v: k for k, v in idalabel.items()}
    return config




def     __SCREAMING_SNAKE_CASE      (     )				->		Union[str, Any]:

    """simple docstring"""


    __UpperCamelCase     						=  hf_hub_download(
        repo_id='''hf-internal-testing/spaghetti-video'''    ,   filename='''eating_spaghetti_32_frames.npy'''    ,   repo_type='''dataset'''					)
    __UpperCamelCase     						=  np.load(__UpperCamelCase					)
    return list(__UpperCamelCase					)




def     __SCREAMING_SNAKE_CASE      (     lowercase_					)				->		Optional[Any]:

    """simple docstring"""


    if np.ndim(__UpperCamelCase					) == 2:
        return transform_attention_bias(__UpperCamelCase					)

    elif np.ndim(__UpperCamelCase					) == 3:
        return transform_attention_kernel(__UpperCamelCase					)

    else:
        raise Exception(F"Invalid number of dimesions: {np.ndim(__UpperCamelCase					)}"					)




def     __SCREAMING_SNAKE_CASE      (     lowercase_					)				->		Tuple:

    """simple docstring"""


    return current.flatten()




def     __SCREAMING_SNAKE_CASE      (     lowercase_					)				->		Any:

    """simple docstring"""


    return np.reshape(__UpperCamelCase    ,   (current.shape[0], current.shape[1] * current.shape[2])					).T




def     __SCREAMING_SNAKE_CASE      (     lowercase_					)				->		Any:

    """simple docstring"""


    return np.reshape(__UpperCamelCase    ,   (current.shape[0] * current.shape[1], current.shape[2])					).T




def     __SCREAMING_SNAKE_CASE      (     lowercase_    ,   lowercase_					)				->		Optional[Any]:

    """simple docstring"""


    __UpperCamelCase     						=  state_dict['''optimizer''']['''target''']['''Transformer'''][F"encoderblock_{i}"]

    __UpperCamelCase     						=  F"encoder.layer.{i}."
    __UpperCamelCase     						=  {
        prefix + '''intermediate.dense.bias''': state['''MlpBlock_0''']['''Dense_0''']['''bias'''],
        prefix + '''intermediate.dense.weight''': np.transpose(state['''MlpBlock_0''']['''Dense_0''']['''kernel''']					),
        prefix + '''output.dense.bias''': state['''MlpBlock_0''']['''Dense_1''']['''bias'''],
        prefix + '''output.dense.weight''': np.transpose(state['''MlpBlock_0''']['''Dense_1''']['''kernel''']					),
        prefix + '''layernorm_before.bias''': state['''LayerNorm_0''']['''bias'''],
        prefix + '''layernorm_before.weight''': state['''LayerNorm_0''']['''scale'''],
        prefix + '''layernorm_after.bias''': state['''LayerNorm_1''']['''bias'''],
        prefix + '''layernorm_after.weight''': state['''LayerNorm_1''']['''scale'''],
        prefix
        + '''attention.attention.query.bias''': transform_attention(
            state['''MultiHeadDotProductAttention_0''']['''query''']['''bias''']					),
        prefix
        + '''attention.attention.query.weight''': transform_attention(
            state['''MultiHeadDotProductAttention_0''']['''query''']['''kernel''']					),
        prefix
        + '''attention.attention.key.bias''': transform_attention(state['''MultiHeadDotProductAttention_0''']['''key''']['''bias''']					),
        prefix
        + '''attention.attention.key.weight''': transform_attention(
            state['''MultiHeadDotProductAttention_0''']['''key''']['''kernel''']					),
        prefix
        + '''attention.attention.value.bias''': transform_attention(
            state['''MultiHeadDotProductAttention_0''']['''value''']['''bias''']					),
        prefix
        + '''attention.attention.value.weight''': transform_attention(
            state['''MultiHeadDotProductAttention_0''']['''value''']['''kernel''']					),
        prefix + '''attention.output.dense.bias''': state['''MultiHeadDotProductAttention_0''']['''out''']['''bias'''],
        prefix
        + '''attention.output.dense.weight''': transform_attention_output_weight(
            state['''MultiHeadDotProductAttention_0''']['''out''']['''kernel''']					),
    }

    return new_state




def     __SCREAMING_SNAKE_CASE      (     lowercase_					)				->		Optional[int]:

    """simple docstring"""


    return sum([1 if '''encoderblock_''' in k else 0 for k in state_dict['''optimizer''']['''target''']['''Transformer'''].keys()]					)




def     __SCREAMING_SNAKE_CASE      (     lowercase_    ,   lowercase_=False					)				->		Dict:

    """simple docstring"""


    __UpperCamelCase     						=  get_n_layers(__UpperCamelCase					)

    __UpperCamelCase     						=  OrderedDict()

    __UpperCamelCase     						=  state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''bias''']
    __UpperCamelCase     						=  state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''scale''']

    __UpperCamelCase     						=  np.transpose(
        state_dict['''optimizer''']['''target''']['''embedding''']['''kernel''']    ,   (4, 3, 0, 1, 2)					)
    __UpperCamelCase     						=  state_dict['''optimizer''']['''target''']['''embedding''']['''bias''']

    __UpperCamelCase     						=  state_dict['''optimizer''']['''target''']['''cls''']
    __UpperCamelCase     						=  state_dict['''optimizer''']['''target''']['''Transformer''']['''posembed_input'''][
        '''pos_embedding'''
    ]

    for i in range(__UpperCamelCase					):
        new_state.update(transform_state_encoder_block(__UpperCamelCase    ,   __UpperCamelCase					)					)

    if classification_head:
        __UpperCamelCase     						=  {'''vivit.''' + k: v for k, v in new_state.items()}
        __UpperCamelCase     						=  np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''kernel''']					)
        __UpperCamelCase     						=  np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''bias''']					)

    return {k: torch.tensor(__UpperCamelCase					) for k, v in new_state.items()}




def     __SCREAMING_SNAKE_CASE      (     )				->		VivitImageProcessor:

    """simple docstring"""


    __UpperCamelCase     						=  VivitImageProcessor()

    assert extractor.do_resize is True
    assert extractor.size == {"shortest_edge": 2_56}
    assert extractor.do_center_crop is True
    assert extractor.crop_size == {"width": 2_24, "height": 2_24}
    assert extractor.resample == PILImageResampling.BILINEAR

    # here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
    # one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
    # which effectively means no normalization (and ViViT does not overwrite those when calling this func)
    assert extractor.do_normalize is False
    assert extractor.do_rescale is True
    assert extractor.rescale_factor == 1 / 2_55

    # zero-centering = True in original implementation
    assert extractor.do_zero_centering is True

    return extractor




def     __SCREAMING_SNAKE_CASE      (     lowercase_					)				->		List[str]:

    """simple docstring"""


    __UpperCamelCase     						=  '''checkpoint'''

    if not os.path.exists(__UpperCamelCase					):
        download_checkpoint(__UpperCamelCase					)

    __UpperCamelCase     						=  restore_checkpoint(__UpperCamelCase    ,   __UpperCamelCase					)
    __UpperCamelCase     						=  transform_state(__UpperCamelCase    ,   classification_head=__UpperCamelCase					)

    __UpperCamelCase     						=  get_vivit_config()

    assert config.image_size == 2_24
    assert config.num_frames == 32

    __UpperCamelCase     						=  VivitForVideoClassification(__UpperCamelCase					)
    model.load_state_dict(__UpperCamelCase					)
    model.eval()

    __UpperCamelCase     						=  get_processor()

    __UpperCamelCase     						=  prepare_video()
    __UpperCamelCase     						=  extractor(__UpperCamelCase    ,   return_tensors='''pt'''					)

    __UpperCamelCase     						=  model(**__UpperCamelCase					)

    __UpperCamelCase     						=  torch.Size([1, 4_00]					)
    __UpperCamelCase     						=  torch.tensor([-1.0543, 2.0764, -0.2104, 0.4439, -0.9658]					)

    assert outputs.logits.shape == expected_shape
    assert torch.allclose(outputs.logits[0, :5]    ,   __UpperCamelCase    ,   atol=1E-4					), outputs.logits[0, :5]

    model.save_pretrained(__UpperCamelCase					)
    extractor.save_pretrained(__UpperCamelCase					)


if __name__ == "__main__":
 a_      						=   argparse.ArgumentParser()

 parser.add_argument("--output_model_name", "-o", type=str, help="Output path for the converted HuggingFace model")

 a_      						=   parser.parse_args()
 convert(args.output_model_name)












import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						int = 1       ,     __UpperCamelCase			:						int = 1      )  ->							qiskit.result.counts.Counts:
    if isinstance(__UpperCamelCase       ,     __UpperCamelCase      ) or isinstance(__UpperCamelCase       ,     __UpperCamelCase      ):
        raise TypeError('''inputs must be integers.'''      )
    if (bit_a < 0) or (bit_a < 0):
        raise ValueError('''inputs must be positive.'''      )
    if (math.floor(__UpperCamelCase      ) != bit_a) or (math.floor(__UpperCamelCase      ) != bit_a):
        raise ValueError('''inputs must be exact integers.'''      )
    if (bit_a > 1) or (bit_a > 1):
        raise ValueError('''inputs must be less or equal to 1.'''      )

    # build registers
    UpperCAmelCase_							 =     QuantumRegister(2       ,     '''qr'''      )
    UpperCAmelCase_							 =     ClassicalRegister(2       ,     '''cr'''      )

    UpperCAmelCase_							 =     QuantumCircuit(__UpperCamelCase       ,     __UpperCamelCase      )

    # entanglement the qubits
    quantum_circuit.h(1      )
    quantum_circuit.cx(1       ,     0      )

    # send the information
    UpperCAmelCase_							 =     str(__UpperCamelCase      ) + str(__UpperCamelCase      )

    if c_information == "11":
        quantum_circuit.x(1      )
        quantum_circuit.z(1      )
    elif c_information == "10":
        quantum_circuit.z(1      )
    elif c_information == "01":
        quantum_circuit.x(1      )
    else:
        quantum_circuit.i(1      )

    # unentangled the circuit
    quantum_circuit.cx(1       ,     0      )
    quantum_circuit.h(1      )

    # measure the circuit
    quantum_circuit.measure(__UpperCamelCase       ,     __UpperCamelCase      )

    UpperCAmelCase_							 =     Aer.get_backend('''aer_simulator'''      )
    UpperCAmelCase_							 =     execute(__UpperCamelCase       ,     __UpperCamelCase       ,     shots=1000      )

    return job.result().get_counts(__UpperCamelCase      )


if __name__ == "__main__":
 print(F"Counts for classical state send: {superdense_coding(1,1)}")





