






from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase__							  =						logging.get_logger(__name__)

UpperCAmelCase__							  =						{
    "facebook/dpr-ctx_encoder-single-nq-base": (
        "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/config.json"
    ),
    "facebook/dpr-question_encoder-single-nq-base": (
        "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/config.json"
    ),
    "facebook/dpr-reader-single-nq-base": (
        "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/config.json"
    ),
    "facebook/dpr-ctx_encoder-multiset-base": (
        "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/config.json"
    ),
    "facebook/dpr-question_encoder-multiset-base": (
        "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/config.json"
    ),
    "facebook/dpr-reader-multiset-base": (
        "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/config.json"
    ),
}






class 						lowercase_   (      lowercase  ):






      '''simple docstring'''




      __snake_case	    =    '''dpr'''







      def __init__( self :		List[Any]					,   __UpperCAmelCase :		List[Any]=30_522					,   __UpperCAmelCase :		Tuple=768					,   __UpperCAmelCase :		List[Any]=12					,   __UpperCAmelCase :		List[Any]=12					,   __UpperCAmelCase :		int=3_072					,   __UpperCAmelCase :		Union[str, Any]="gelu"					,   __UpperCAmelCase :		List[str]=0.1					,   __UpperCAmelCase :		int=0.1					,   __UpperCAmelCase :		List[str]=512					,   __UpperCAmelCase :		str=2					,   __UpperCAmelCase :		str=0.02					,   __UpperCAmelCase :		Optional[Any]=1e-1_2					,   __UpperCAmelCase :		List[str]=0					,   __UpperCAmelCase :		str="absolute"					,   __UpperCAmelCase :		int = 0					,   **__UpperCAmelCase :		Union[str, Any]					,   )       ->Tuple:




       """simple docstring"""


       super().__init__(pad_token_id=__UpperCAmelCase					,   **__UpperCAmelCase    )

       a						    = vocab_size
       a						    = hidden_size
       a						    = num_hidden_layers
       a						    = num_attention_heads
       a						    = hidden_act
       a						    = intermediate_size
       a						    = hidden_dropout_prob
       a						    = attention_probs_dropout_prob
       a						    = max_position_embeddings
       a						    = type_vocab_size
       a						    = initializer_range
       a						    = layer_norm_eps
       a						    = projection_dim
       a						    = position_embedding_type










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()
UpperCAmelCase__							  =						logging.get_logger(__name__)
def 		_a       ( a					:List[str]      ,				a					:Tuple=False					)				->     List[Any]:
 a						    = []
 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"
  a						    = [(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       ( a					:List[str]      ,				a					:int      ,				a					:Tuple=False					)				->     Any:
 for i in range(config.num_hidden_layers					):
  if base_model:
   a						    = ''''''
  else:
   a						    = '''vit.'''
  # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
  a						    = state_dict.pop(F"""blocks.{i}.attn.qkv.weight"""					)
  a						    = state_dict.pop(F"""blocks.{i}.attn.qkv.bias"""					)
  # next, add query, keys and values (in that order) to the state dict
  a						    = in_proj_weight[
      : config.hidden_size, :
  ]
  a						    = in_proj_bias[: config.hidden_size]
  a						    = in_proj_weight[
      config.hidden_size : config.hidden_size * 2, :
  ]
  a						    = in_proj_bias[
      config.hidden_size : config.hidden_size * 2
  ]
  a						    = in_proj_weight[
      -config.hidden_size :, :
  ]
  a						    = in_proj_bias[-config.hidden_size :]
def 		_a       ( a					:List[Any]					)				->     Dict:
 a						    = ['''head.weight''', '''head.bias''']
 for k in ignore_keys:
  state_dict.pop(a      ,				a					)
def 		_a       ( a					:Union[str, Any]      ,				a					:str      ,				a					:List[Any]					)				->     str:
 a						    = dct.pop(a					)
 a						    = val
def 		_a       ( )				->     Optional[Any]:
 a						    = '''http://images.cocodataset.org/val2017/000000039769.jpg'''
 a						    = Image.open(requests.get(a      ,				stream=a					).raw					)
 return im
@torch.no_grad()
def 		_a       ( a					:Tuple      ,				a					:str      ,				a					:Optional[int]=True					)				->     Dict:
 a						    = ViTConfig()
 # patch_size
 if model_name[-1] == "8":
  a						    = 8
 # set labels if required
 if not base_model:
  a						    = 1_000
  a						    = '''huggingface/label-files'''
  a						    = '''imagenet-1k-id2label.json'''
  a						    = json.load(open(hf_hub_download(a      ,				a      ,				repo_type='''dataset'''					)      ,				'''r'''					)					)
  a						    = {int(a					): v for k, v in idalabel.items()}
  a						    = idalabel
  a						    = {v: k for k, v in idalabel.items()}
 # size of the architecture
 if model_name in ["dino_vits8", "dino_vits16"]:
  a						    = 384
  a						    = 1_536
  a						    = 12
  a						    = 6

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

 # load state_dict of original model, remove and rename some keys
 a						    = original_model.state_dict()
 if base_model:
  remove_classification_head_(a					)
 a						    = 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:
  a						    = ViTModel(a      ,				add_pooling_layer=a					).eval()
 else:
  a						    = ViTForImageClassification(a					).eval()
 model.load_state_dict(a					)

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

 if base_model:
  a						    = original_model(a					)
  assert torch.allclose(a      ,				outputs.last_hidden_state[:, 0, :]      ,				atol=1e-1					)
 else:
  a						    = 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__":
     UpperCAmelCase__							  =						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)
     UpperCAmelCase__							  =						parser.parse_args()
     convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)


