





'''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 (
    SwiftFormerConfig,
    SwiftFormerForImageClassification,
    ViTImageProcessor,
)
from transformers.utils import logging


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

_A:					List[Any]							=				torch.device("""cpu""")







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







def _lowerCAmelCase     (      _lowerCAmelCase    )->     List[str]:
 if swiftformer_name == "swiftformer_xs":
  return torch.tensor([-2.1_7_0_3e0_0, 2.1_1_0_7e0_0, -2.0_8_1_1e0_0, 8.8_6_8_5e-0_1, 2.4_3_6_0e-0_1]    )

 elif swiftformer_name == "swiftformer_s":
  return torch.tensor([3.9_6_3_6e-0_1, 2.3_4_7_8e-0_1, -1.6_9_6_3e0_0, -1.7_3_8_1e0_0, -8.6_3_3_7e-0_1]    )

 elif swiftformer_name == "swiftformer_l1":
  return torch.tensor([-4.2_7_6_8e-0_1, -4.7_4_2_9e-0_1, -1.0_8_9_7e0_0, -1.0_2_4_8e0_0, 3.5_5_2_3e-0_2]    )

 elif swiftformer_name == "swiftformer_l3":
  return torch.tensor([-2.5_3_3_0e-0_1, 2.4_2_1_1e-0_1, -6.0_1_8_5e-0_1, -8.2_7_8_9e-0_1, -6.0_4_4_6e-0_2]    )







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







def _lowerCAmelCase     (      _lowerCAmelCase    )->     str:
 __UpperCAmelCase					=   []
 for k in state_dict.keys():
  __UpperCAmelCase					=   k
  if ".pwconv" in k:
   __UpperCAmelCase					=   k_new.replace('.pwconv'       ,    '.point_wise_conv'    )
  if ".dwconv" in k:
   __UpperCAmelCase					=   k_new.replace('.dwconv'       ,    '.depth_wise_conv'    )
  if ".Proj." in k:
   __UpperCAmelCase					=   k_new.replace('.Proj.'       ,    '.proj.'    )
  if "patch_embed" in k_new:
   __UpperCAmelCase					=   k_new.replace('patch_embed'       ,    'swiftformer.patch_embed.patch_embedding'    )
  if "network" in k_new:
   __UpperCAmelCase					=   k_new.split('.'    )
   if ls[2].isdigit():
    __UpperCAmelCase					=   'swiftformer.encoder.network.' + ls[1] + '.blocks.' + ls[2] + '.' + '.'.join(ls[3:]    )
   else:
    __UpperCAmelCase					=   k_new.replace('network'       ,    'swiftformer.encoder.network'    )
  rename_keys.append((k, k_new)    )
 return rename_keys







@torch.no_grad()
def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )->     Union[str, Any]:
 __UpperCAmelCase					=   SwiftFormerConfig()

 # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
 __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 swiftformer_name == "swiftformer_xs":
  __UpperCAmelCase					=   [3, 3, 6, 4]
  __UpperCAmelCase					=   [48, 56, 1_12, 2_20]

 elif swiftformer_name == "swiftformer_s":
  __UpperCAmelCase					=   [3, 3, 9, 6]
  __UpperCAmelCase					=   [48, 64, 1_68, 2_24]

 elif swiftformer_name == "swiftformer_l1":
  __UpperCAmelCase					=   [4, 3, 10, 5]
  __UpperCAmelCase					=   [48, 96, 1_92, 3_84]

 elif swiftformer_name == "swiftformer_l3":
  __UpperCAmelCase					=   [4, 4, 12, 6]
  __UpperCAmelCase					=   [64, 1_28, 3_20, 5_12]

 # load state_dict of original model, remove and rename some keys
 if original_ckpt:
  if original_ckpt.startswith('https'    ):
   __UpperCAmelCase					=   torch.hub.load_state_dict_from_url(_lowerCAmelCase       ,    map_location='cpu'       ,    check_hash=_lowerCAmelCase    )
  else:
   __UpperCAmelCase					=   torch.load(_lowerCAmelCase       ,    map_location='cpu'    )
 __UpperCAmelCase					=   checkpoint

 __UpperCAmelCase					=   create_rename_keys(_lowerCAmelCase    )
 for rename_key_src, rename_key_dest in rename_keys:
  rename_key(_lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )

 # load HuggingFace model
 __UpperCAmelCase					=   SwiftFormerForImageClassification(_lowerCAmelCase    ).eval()
 hf_model.load_state_dict(_lowerCAmelCase    )

 # prepare test inputs
 __UpperCAmelCase					=   prepare_img()
 __UpperCAmelCase					=   ViTImageProcessor.from_pretrained('preprocessor_config'    )
 __UpperCAmelCase					=   processor(images=_lowerCAmelCase       ,    return_tensors='pt'    )

 # compare outputs from both models
 __UpperCAmelCase					=   get_expected_output(_lowerCAmelCase    )
 __UpperCAmelCase					=   hf_model(inputs['pixel_values']    ).logits

 assert hf_logits.shape == torch.Size([1, 10_00]    )
 assert torch.allclose(hf_logits[0, 0:5]       ,    _lowerCAmelCase       ,    atol=1e-3    )

 Path(_lowerCAmelCase    ).mkdir(exist_ok=_lowerCAmelCase    )
 print(F'Saving model {swiftformer_name} to {pytorch_dump_folder_path}'    )
 hf_model.save_pretrained(_lowerCAmelCase    )


if __name__ == "__main__":
    _A:					List[Any]							=				argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        """--swiftformer_name""",
        default="""swiftformer_xs""",
        choices=["""swiftformer_xs""", """swiftformer_s""", """swiftformer_l1""", """swiftformer_l3"""],
        type=str,
        help="""Name of the SwiftFormer model you'd like to convert.""",
    )
    parser.add_argument(
        """--pytorch_dump_folder_path""",
        default="""./converted_outputs/""",
        type=str,
        help="""Path to the output PyTorch model directory.""",
    )
    parser.add_argument("""--original_ckpt""", default=None, type=str, help="""Path to the original model checkpoint.""")

    _A:					List[Any]							=				parser.parse_args()
    convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)












'''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)}"""
    )





