
import argparse
import json

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

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling


def      UpperCamelCase   (       __lowerCamelCase	:					Optional[int]       ):
       snake_case			:  Dict     							= [2, 2, 6, 2] if "tiny" in model_name else [2, 2, 18, 2]
       snake_case			:  List[str]     							= True if "large" in model_name or "huge" in model_name else False
       snake_case			:  int     							= True if "large" in model_name or "huge" in model_name else False
       snake_case			:  Dict     							= True if "large" in model_name or "huge" in model_name else False

       if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
              if "fl3" in model_name:
                     snake_case			:  Optional[Any]     							= [3, 3, 3, 3]
                     snake_case			:  Any     							= [5, 5, 5, 5]
              elif "fl4" in model_name:
                     snake_case			:  Dict     							= [4, 4, 4, 4]
                     snake_case			:  Optional[Any]     							= [3, 3, 3, 3]

       if "tiny" in model_name or "small" in model_name or "base" in model_name:
              snake_case			:  List[Any]     							= [3, 3, 3, 3]
              if "lrf" in model_name:
                     snake_case			:  str     							= [3, 3, 3, 3]
              else:
                     snake_case			:  int     							= [2, 2, 2, 2]

       if "tiny" in model_name:
              snake_case			:  Tuple     							= 96
       elif "small" in model_name:
              snake_case			:  List[Any]     							= 96
       elif "base" in model_name:
              snake_case			:  List[Any]     							= 128
       elif "large" in model_name:
              snake_case			:  int     							= 192
       elif "xlarge" in model_name:
              snake_case			:  Optional[int]     							= 256
       elif "huge" in model_name:
              snake_case			:  Union[str, Any]     							= 352

       # set label information
       snake_case			:  Tuple     							= "huggingface/label-files"
       if "large" in model_name or "huge" in model_name:
              snake_case			:  Union[str, Any]     							= "imagenet-22k-id2label.json"
       else:
              snake_case			:  Any     							= "imagenet-1k-id2label.json"

       snake_case			:  Tuple     							= json.load(open(hf_hub_download(__lowerCamelCase							,   __lowerCamelCase							,   repo_type="dataset"       )							,   "r"       )       )
       snake_case			:  str     							= {int(__lowerCamelCase       ): v for k, v in idalabel.items()}
       snake_case			:  Any     							= {v: k for k, v in idalabel.items()}

       snake_case			:  Tuple     							= FocalNetConfig(
           embed_dim=__lowerCamelCase							,   depths=__lowerCamelCase							,   focal_levels=__lowerCamelCase							,   focal_windows=__lowerCamelCase							,   use_conv_embed=__lowerCamelCase							,   idalabel=__lowerCamelCase							,   labelaid=__lowerCamelCase							,   use_post_layernorm=__lowerCamelCase							,   use_layerscale=__lowerCamelCase							,   )

       return config


def      UpperCamelCase   (       __lowerCamelCase	:					List[Any]       ):
       if "patch_embed.proj" in name:
              snake_case			:  Union[str, Any]     							= name.replace("patch_embed.proj"							,   "embeddings.patch_embeddings.projection"       )
       if "patch_embed.norm" in name:
              snake_case			:  Dict     							= name.replace("patch_embed.norm"							,   "embeddings.norm"       )
       if "layers" in name:
              snake_case			:  List[Any]     							= "encoder." + name
       if "encoder.layers" in name:
              snake_case			:  Union[str, Any]     							= name.replace("encoder.layers"							,   "encoder.stages"       )
       if "downsample.proj" in name:
              snake_case			:  int     							= name.replace("downsample.proj"							,   "downsample.projection"       )
       if "blocks" in name:
              snake_case			:  Optional[Any]     							= name.replace("blocks"							,   "layers"       )
       if "modulation.f.weight" in name or "modulation.f.bias" in name:
              snake_case			:  List[Any]     							= name.replace("modulation.f"							,   "modulation.projection_in"       )
       if "modulation.h.weight" in name or "modulation.h.bias" in name:
              snake_case			:  Union[str, Any]     							= name.replace("modulation.h"							,   "modulation.projection_context"       )
       if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
              snake_case			:  List[Any]     							= name.replace("modulation.proj"							,   "modulation.projection_out"       )

       if name == "norm.weight":
              snake_case			:  int     							= "layernorm.weight"
       if name == "norm.bias":
              snake_case			:  Union[str, Any]     							= "layernorm.bias"

       if "head" in name:
              snake_case			:  List[Any]     							= name.replace("head"							,   "classifier"       )
       else:
              snake_case			:  int     							= "focalnet." + name

       return name


def      UpperCamelCase   (       __lowerCamelCase	:					Tuple							,   __lowerCamelCase	:					Tuple							,   __lowerCamelCase	:					Optional[int]=False       ):
       # fmt: off
       snake_case			:  Tuple     							= {
           "focalnet-tiny": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth",
           "focalnet-tiny-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth",
           "focalnet-small": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth",
           "focalnet-small-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth",
           "focalnet-base": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth",
           "focalnet-base-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth",
           "focalnet-large-lrf-fl3": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth",
           "focalnet-large-lrf-fl4": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth",
           "focalnet-xlarge-lrf-fl3": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth",
           "focalnet-xlarge-lrf-fl4": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth",
       }
       # fmt: on

       snake_case			:  int     							= model_name_to_url[model_name]
       print("Checkpoint URL: "							,   __lowerCamelCase       )
       snake_case			:  int     							= torch.hub.load_state_dict_from_url(__lowerCamelCase							,   map_location="cpu"       )["model"]

       # rename keys
       for key in state_dict.copy().keys():
              snake_case			:  Optional[int]     							= state_dict.pop(__lowerCamelCase       )
              snake_case			:  List[Any]     							= val

       snake_case			:  List[str]     							= get_focalnet_config(__lowerCamelCase       )
       snake_case			:  List[str]     							= FocalNetForImageClassification(__lowerCamelCase       )
       model.eval()

       # load state dict
       model.load_state_dict(__lowerCamelCase       )

       # verify conversion
       snake_case			:  str     							= "http://images.cocodataset.org/val2017/000000039769.jpg"

       snake_case			:  Union[str, Any]     							= BitImageProcessor(
           do_resize=__lowerCamelCase							,   size={"shortest_edge": 256}							,   resample=PILImageResampling.BILINEAR							,   do_center_crop=__lowerCamelCase							,   crop_size=224							,   do_normalize=__lowerCamelCase							,   image_mean=__lowerCamelCase							,   image_std=__lowerCamelCase							,   )
       snake_case			:  Dict     							= Image.open(requests.get(__lowerCamelCase							,   stream=__lowerCamelCase       ).raw       )
       snake_case			:  Optional[Any]     							= processor(images=__lowerCamelCase							,   return_tensors="pt"       )

       snake_case			:  List[Any]     							= transforms.Compose(
           [
               transforms.Resize(256       ),
               transforms.CenterCrop(224       ),
               transforms.ToTensor(),
               transforms.Normalize(mean=[0.485, 0.456, 0.406]							,   std=[0.229, 0.224, 0.225]       ),
           ]       )

       snake_case			:  Union[str, Any]     							= image_transforms(__lowerCamelCase       ).unsqueeze(0       )

       # verify pixel_values
       assert torch.allclose(inputs.pixel_values							,   __lowerCamelCase							,   atol=1E-4       )

       snake_case			:  List[Any]     							= model(**__lowerCamelCase       )

       snake_case			:  Optional[int]     							= outputs.logits.argmax(-1       ).item()
       print("Predicted class:"							,   model.config.idalabel[predicted_class_idx]       )

       print("First values of logits:"							,   outputs.logits[0, :3]       )

       if model_name == "focalnet-tiny":
              snake_case			:  int     							= torch.tensor([0.2166, -0.4368, 0.2191]       )
       elif model_name == "focalnet-tiny-lrf":
              snake_case			:  Any     							= torch.tensor([1.1669, 0.0125, -0.1695]       )
       elif model_name == "focalnet-small":
              snake_case			:  Any     							= torch.tensor([0.4917, -0.0430, 0.1341]       )
       elif model_name == "focalnet-small-lrf":
              snake_case			:  int     							= torch.tensor([-0.2588, -0.5342, -0.2331]       )
       elif model_name == "focalnet-base":
              snake_case			:  Union[str, Any]     							= torch.tensor([-0.1655, -0.4090, -0.1730]       )
       elif model_name == "focalnet-base-lrf":
              snake_case			:  str     							= torch.tensor([0.5306, -0.0483, -0.3928]       )
       assert torch.allclose(outputs.logits[0, :3]							,   __lowerCamelCase							,   atol=1E-4       )
       print("Looks ok!"       )

       if pytorch_dump_folder_path is not None:
              print(f"""Saving model and processor of {model_name} to {pytorch_dump_folder_path}"""       )
              model.save_pretrained(__lowerCamelCase       )
              processor.save_pretrained(__lowerCamelCase       )

       if push_to_hub:
              print(f"""Pushing model and processor of {model_name} to the hub..."""       )
              model.push_to_hub(f"""{model_name}"""       )
              processor.push_to_hub(f"""{model_name}"""       )


if __name__ == "__main__":
   __lowerCamelCase				=			argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--model_name""",
       default="""focalnet-tiny""",
       type=str,
       help="""Name of the FocalNet model 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(
       """--push_to_hub""",
       action="""store_true""",
       help="""Whether to push the model and processor to the hub.""",
   )

   __lowerCamelCase				=			parser.parse_args()
   convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







import qiskit


def      UpperCamelCase   (       __lowerCamelCase	:					int							,   __lowerCamelCase	:					int       ):
       snake_case			:  int     							= qiskit.Aer.get_backend("aer_simulator"       )

       # Create a Quantum Circuit acting on the q register
       snake_case			:  Dict     							= qiskit.QuantumCircuit(__lowerCamelCase							,   __lowerCamelCase       )

       # Apply X (NOT) Gate to Qubits 0 & 1
       circuit.x(0       )
       circuit.x(1       )

       # Map the quantum measurement to the classical bits
       circuit.measure([0, 1]							,   [0, 1]       )

       # Execute the circuit on the qasm simulator
       snake_case			:  Dict     							= qiskit.execute(__lowerCamelCase							,   __lowerCamelCase							,   shots=1000       )

       # Return the histogram data of the results of the experiment.
       return job.result().get_counts(__lowerCamelCase       )


if __name__ == "__main__":
   __lowerCamelCase				=			single_qubit_measure(2, 2)
   print(F'Total count for various states are: {counts}')





