



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_    :  Union[str, Any]						  =		logging.get_logger(__name__)

def      __lowercase(						UpperCAmelCase__ , UpperCAmelCase__=False			):


      """simple docstring"""



      lowerCamelCase             =		[]
      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"
            lowerCamelCase             =		[(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      __lowercase(						UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__=False			):


      """simple docstring"""



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

def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



      lowerCamelCase             =		["head.weight", "head.bias"]
      for k in ignore_keys:
            state_dict.pop(_a , _a			)

def      __lowercase(						UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__			):


      """simple docstring"""



      lowerCamelCase             =		dct.pop(_a			)
      lowerCamelCase             =		val

def      __lowercase(						):


      """simple docstring"""



      lowerCamelCase             =		"http://images.cocodataset.org/val2017/000000039769.jpg"
      lowerCamelCase             =		Image.open(requests.get(_a , stream=_a			).raw			)
      return im

@torch.no_grad()
def      __lowercase(						UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__=True			):


      """simple docstring"""



      lowerCamelCase             =		ViTConfig()
      # patch_size
      if model_name[-1] == "8":
            lowerCamelCase             =		8
      # set labels if required
      if not base_model:
            lowerCamelCase             =		1000
            lowerCamelCase             =		"huggingface/label-files"
            lowerCamelCase             =		"imagenet-1k-id2label.json"
            lowerCamelCase             =		json.load(open(hf_hub_download(_a , _a , repo_type="dataset"			) , "r"			)			)
            lowerCamelCase             =		{int(_a			): v for k, v in idalabel.items()}
            lowerCamelCase             =		idalabel
            lowerCamelCase             =		{v: k for k, v in idalabel.items()}
      # size of the architecture
      if model_name in ["dino_vits8", "dino_vits16"]:
            lowerCamelCase             =		384
            lowerCamelCase             =		1536
            lowerCamelCase             =		12
            lowerCamelCase             =		6

      # load original model from torch hub
      lowerCamelCase             =		torch.hub.load("facebookresearch/dino:main" , _a			)
      original_model.eval()

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

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

      # Check outputs on an image, prepared by ViTImageProcessor
      lowerCamelCase             =		ViTImageProcessor()
      lowerCamelCase             =		image_processor(images=prepare_img() , return_tensors="pt"			)
      lowerCamelCase             =		encoding["pixel_values"]
      lowerCamelCase             =		model(_a			)

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

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


if __name__ == "__main__":
     a_    :  Tuple						  =		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_    :  Dict						  =		parser.parse_args()
     convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)


"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


UpperCAmelCase													={
    "configuration_mega": ["MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP", "MegaConfig", "MegaOnnxConfig"],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase													=[
      "MEGA_PRETRAINED_MODEL_ARCHIVE_LIST",
      "MegaForCausalLM",
      "MegaForMaskedLM",
      "MegaForMultipleChoice",
      "MegaForQuestionAnswering",
      "MegaForSequenceClassification",
      "MegaForTokenClassification",
      "MegaModel",
      "MegaPreTrainedModel",
  ]

if TYPE_CHECKING:
  from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_mega import (
        MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
        MegaForCausalLM,
        MegaForMaskedLM,
        MegaForMultipleChoice,
        MegaForQuestionAnswering,
        MegaForSequenceClassification,
        MegaForTokenClassification,
        MegaModel,
        MegaPreTrainedModel,
    )

else:
  import sys

  UpperCAmelCase													=_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




