





'''simple docstring'''




import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
from transformers.utils import logging


logging.set_verbosity_info()
_A:					Optional[Any]							=				logging.get_logger(__name__)







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase=False    )->     Optional[int]:
 __UpperCAmelCase					=   []
 for i in range(config.num_hidden_layers    ):
  # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
  rename_keys.append((F'blocks.{i}.norm1.weight', F'vit.encoder.layer.{i}.layernorm_before.weight')    )
  rename_keys.append((F'blocks.{i}.norm1.bias', F'vit.encoder.layer.{i}.layernorm_before.bias')    )
  rename_keys.append((F'blocks.{i}.attn.proj.weight', F'vit.encoder.layer.{i}.attention.output.dense.weight')    )
  rename_keys.append((F'blocks.{i}.attn.proj.bias', F'vit.encoder.layer.{i}.attention.output.dense.bias')    )
  rename_keys.append((F'blocks.{i}.norm2.weight', F'vit.encoder.layer.{i}.layernorm_after.weight')    )
  rename_keys.append((F'blocks.{i}.norm2.bias', F'vit.encoder.layer.{i}.layernorm_after.bias')    )
  rename_keys.append((F'blocks.{i}.mlp.fc1.weight', F'vit.encoder.layer.{i}.intermediate.dense.weight')    )
  rename_keys.append((F'blocks.{i}.mlp.fc1.bias', F'vit.encoder.layer.{i}.intermediate.dense.bias')    )
  rename_keys.append((F'blocks.{i}.mlp.fc2.weight', F'vit.encoder.layer.{i}.output.dense.weight')    )
  rename_keys.append((F'blocks.{i}.mlp.fc2.bias', F'vit.encoder.layer.{i}.output.dense.bias')    )

 # projection layer + position embeddings
 rename_keys.extend(
     [
         ('cls_token', 'vit.embeddings.cls_token'),
         ('patch_embed.proj.weight', 'vit.embeddings.patch_embeddings.projection.weight'),
         ('patch_embed.proj.bias', 'vit.embeddings.patch_embeddings.projection.bias'),
         ('pos_embed', 'vit.embeddings.position_embeddings'),
     ]    )

 if base_model:
  # layernorm + pooler
  rename_keys.extend(
      [
          ('norm.weight', 'layernorm.weight'),
          ('norm.bias', 'layernorm.bias'),
      ]    )

  # if just the base model, we should remove "vit" from all keys that start with "vit"
  __UpperCAmelCase					=   [(pair[0], pair[1][4:]) if pair[1].startswith('vit'    ) else pair for pair in rename_keys]
 else:
  # layernorm + classification head
  rename_keys.extend(
      [
          ('norm.weight', 'vit.layernorm.weight'),
          ('norm.bias', 'vit.layernorm.bias'),
          ('head.weight', 'classifier.weight'),
          ('head.bias', 'classifier.bias'),
      ]    )

 return rename_keys







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase=False    )->     Optional[Any]:
 for i in range(config.num_hidden_layers    ):
  if base_model:
   __UpperCAmelCase					=   ''
  else:
   __UpperCAmelCase					=   'vit.'
  # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
  __UpperCAmelCase					=   state_dict.pop(F'blocks.{i}.attn.qkv.weight'    )
  __UpperCAmelCase					=   state_dict.pop(F'blocks.{i}.attn.qkv.bias'    )
  # next, add query, keys and values (in that order) to the state dict
  __UpperCAmelCase					=   in_proj_weight[
      : config.hidden_size, :
  ]
  __UpperCAmelCase					=   in_proj_bias[: config.hidden_size]
  __UpperCAmelCase					=   in_proj_weight[
      config.hidden_size : config.hidden_size * 2, :
  ]
  __UpperCAmelCase					=   in_proj_bias[
      config.hidden_size : config.hidden_size * 2
  ]
  __UpperCAmelCase					=   in_proj_weight[
      -config.hidden_size :, :
  ]
  __UpperCAmelCase					=   in_proj_bias[-config.hidden_size :]







def _lowerCAmelCase     (      _lowerCAmelCase    )->     Tuple:
 __UpperCAmelCase					=   ['head.weight', 'head.bias']
 for k in ignore_keys:
  state_dict.pop(_lowerCAmelCase       ,    _lowerCAmelCase    )







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )->     Optional[int]:
 __UpperCAmelCase					=   dct.pop(_lowerCAmelCase    )
 __UpperCAmelCase					=   val







def _lowerCAmelCase     (      )->     Union[str, Any]:
 __UpperCAmelCase					=   'http://images.cocodataset.org/val2017/000000039769.jpg'
 __UpperCAmelCase					=   Image.open(requests.get(_lowerCAmelCase       ,    stream=_lowerCAmelCase    ).raw    )
 return im







@torch.no_grad()
def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase=True    )->     List[Any]:
 __UpperCAmelCase					=   ViTConfig()
 # patch_size
 if model_name[-1] == "8":
  __UpperCAmelCase					=   8
 # set labels if required
 if not base_model:
  __UpperCAmelCase					=   10_00
  __UpperCAmelCase					=   'huggingface/label-files'
  __UpperCAmelCase					=   'imagenet-1k-id2label.json'
  __UpperCAmelCase					=   json.load(open(hf_hub_download(_lowerCAmelCase       ,    _lowerCAmelCase       ,    repo_type='dataset'    )       ,    'r'    )    )
  __UpperCAmelCase					=   {int(_lowerCAmelCase    ): v for k, v in idalabel.items()}
  __UpperCAmelCase					=   idalabel
  __UpperCAmelCase					=   {v: k for k, v in idalabel.items()}
 # size of the architecture
 if model_name in ["dino_vits8", "dino_vits16"]:
  __UpperCAmelCase					=   3_84
  __UpperCAmelCase					=   15_36
  __UpperCAmelCase					=   12
  __UpperCAmelCase					=   6

 # load original model from torch hub
 __UpperCAmelCase					=   torch.hub.load('facebookresearch/dino:main'       ,    _lowerCAmelCase    )
 original_model.eval()

 # load state_dict of original model, remove and rename some keys
 __UpperCAmelCase					=   original_model.state_dict()
 if base_model:
  remove_classification_head_(_lowerCAmelCase    )
 __UpperCAmelCase					=   create_rename_keys(_lowerCAmelCase       ,    base_model=_lowerCAmelCase    )
 for src, dest in rename_keys:
  rename_key(_lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )
 read_in_q_k_v(_lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )

 # load HuggingFace model
 if base_model:
  __UpperCAmelCase					=   ViTModel(_lowerCAmelCase       ,    add_pooling_layer=_lowerCAmelCase    ).eval()
 else:
  __UpperCAmelCase					=   ViTForImageClassification(_lowerCAmelCase    ).eval()
 model.load_state_dict(_lowerCAmelCase    )

 # Check outputs on an image, prepared by ViTImageProcessor
 __UpperCAmelCase					=   ViTImageProcessor()
 __UpperCAmelCase					=   image_processor(images=prepare_img()       ,    return_tensors='pt'    )
 __UpperCAmelCase					=   encoding['pixel_values']
 __UpperCAmelCase					=   model(_lowerCAmelCase    )

 if base_model:
  __UpperCAmelCase					=   original_model(_lowerCAmelCase    )
  assert torch.allclose(_lowerCAmelCase       ,    outputs.last_hidden_state[:, 0, :]       ,    atol=1e-1    )
 else:
  __UpperCAmelCase					=   original_model(_lowerCAmelCase    )
  assert logits.shape == outputs.logits.shape
  assert torch.allclose(_lowerCAmelCase       ,    outputs.logits       ,    atol=1e-3    )

 Path(_lowerCAmelCase    ).mkdir(exist_ok=_lowerCAmelCase    )
 print(F'Saving model {model_name} to {pytorch_dump_folder_path}'    )
 model.save_pretrained(_lowerCAmelCase    )
 print(F'Saving image processor to {pytorch_dump_folder_path}'    )
 image_processor.save_pretrained(_lowerCAmelCase    )


if __name__ == "__main__":
    _A:					List[str]							=				argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        """--model_name""",
        default="""dino_vitb16""",
        type=str,
        help="""Name of the model trained with DINO you'd like to convert.""",
    )
    parser.add_argument(
        """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
    )
    parser.add_argument(
        """--base_model""",
        action="""store_true""",
        help="""Whether to only convert the base model (no projection head weights).""",
    )

    parser.set_defaults(base_model=True)
    _A:					Optional[int]							=				parser.parse_args()
    convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)












'''simple docstring'''




import math

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







def _lowerCAmelCase     (      _lowerCAmelCase = 3    )->     qiskit.result.counts.Counts:
 if isinstance(_lowerCAmelCase       ,    _lowerCAmelCase    ):
  raise TypeError('number of qubits must be a integer.'    )
 if number_of_qubits <= 0:
  raise ValueError('number of qubits must be > 0.'    )
 if math.floor(_lowerCAmelCase    ) != number_of_qubits:
  raise ValueError('number of qubits must be exact integer.'    )
 if number_of_qubits > 10:
  raise ValueError('number of qubits too large to simulate(>10).'    )

 __UpperCAmelCase					=   QuantumRegister(_lowerCAmelCase       ,    'qr'    )
 __UpperCAmelCase					=   ClassicalRegister(_lowerCAmelCase       ,    'cr'    )

 __UpperCAmelCase					=   QuantumCircuit(_lowerCAmelCase       ,    _lowerCAmelCase    )

 __UpperCAmelCase					=   number_of_qubits

 for i in range(_lowerCAmelCase    ):
  quantum_circuit.h(number_of_qubits - i - 1    )
  counter -= 1
  for j in range(_lowerCAmelCase    ):
   quantum_circuit.cp(np.pi / 2 ** (counter - j)       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )

 for k in range(number_of_qubits // 2    ):
  quantum_circuit.swap(_lowerCAmelCase       ,    number_of_qubits - k - 1    )

 # measure all the qubits
 quantum_circuit.measure(_lowerCAmelCase       ,    _lowerCAmelCase    )
 # simulate with 10000 shots
 __UpperCAmelCase					=   Aer.get_backend('qasm_simulator'    )
 __UpperCAmelCase					=   execute(_lowerCAmelCase       ,    _lowerCAmelCase       ,    shots=1_00_00    )

 return job.result().get_counts(_lowerCAmelCase    )


if __name__ == "__main__":
    print(
        F"""Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}"""
    )





