



"""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()
lowerCamelCase  			=		logging.get_logger(__name__)
def   a__      ( lowerCAmelCase__      ,     lowerCAmelCase__=False ):
      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   a__      ( lowerCAmelCase__      ,     lowerCAmelCase__      ,     lowerCAmelCase__=False ):
      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   a__      ( lowerCAmelCase__ ):
      UpperCAmelCase_     					=				["head.weight", "head.bias"]
      for k in ignore_keys:
            state_dict.pop(lowerCAmelCase__      ,     lowerCAmelCase__ )
def   a__      ( lowerCAmelCase__      ,     lowerCAmelCase__      ,     lowerCAmelCase__ ):
      UpperCAmelCase_     					=				dct.pop(lowerCAmelCase__ )
      UpperCAmelCase_     					=				val
def   a__      ( ):
      UpperCAmelCase_     					=				"http://images.cocodataset.org/val2017/000000039769.jpg"
      UpperCAmelCase_     					=				Image.open(requests.get(lowerCAmelCase__      ,     stream=lowerCAmelCase__ ).raw )
      return im
@torch.no_grad()
def   a__      ( lowerCAmelCase__      ,     lowerCAmelCase__      ,     lowerCAmelCase__=True ):
      UpperCAmelCase_     					=				ViTConfig()
      # patch_size
      if model_name[-1] == "8":
            UpperCAmelCase_     					=				8
      # set labels if required
      if not base_model:
            UpperCAmelCase_     					=				1000
            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_     					=				384
            UpperCAmelCase_     					=				1536
            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__":
  lowerCamelCase  			=		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)
  lowerCamelCase  			=		parser.parse_args()
  convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__a:     int   					=					{
    '''configuration_mvp''': ['''MVP_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MvpConfig''', '''MvpOnnxConfig'''],
    '''tokenization_mvp''': ['''MvpTokenizer'''],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a:     Dict   					=					['''MvpTokenizerFast''']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a:     Tuple   					=					[
      '''MVP_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''MvpForCausalLM''',
      '''MvpForConditionalGeneration''',
      '''MvpForQuestionAnswering''',
      '''MvpForSequenceClassification''',
      '''MvpModel''',
      '''MvpPreTrainedModel''',
  ]

if TYPE_CHECKING:
  from .configuration_mvp import MVP_PRETRAINED_CONFIG_ARCHIVE_MAP, MvpConfig, MvpOnnxConfig
  from .tokenization_mvp import MvpTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_mvp_fast import MvpTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_mvp import (
        MVP_PRETRAINED_MODEL_ARCHIVE_LIST,
        MvpForCausalLM,
        MvpForConditionalGeneration,
        MvpForQuestionAnswering,
        MvpForSequenceClassification,
        MvpModel,
        MvpPreTrainedModel,
    )

else:
  import sys

  __a:     Optional[Any]   					=					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)