




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						:							int							=  logging.get_logger(__name__)
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE=False   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					[]
			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"
						SCREAMING_SNAKE_CASE           =					[(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 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE=False   ):
			'''simple docstring'''


			for i in range(config.num_hidden_layers   ):
						if base_model:
									SCREAMING_SNAKE_CASE           =					""
						else:
									SCREAMING_SNAKE_CASE           =					"vit."
						# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
						SCREAMING_SNAKE_CASE           =					state_dict.pop(f"""blocks.{i}.attn.qkv.weight"""   )
						SCREAMING_SNAKE_CASE           =					state_dict.pop(f"""blocks.{i}.attn.qkv.bias"""   )
						# next, add query, keys and values (in that order) to the state dict
						SCREAMING_SNAKE_CASE           =					in_proj_weight[
						    : config.hidden_size, :
						]
						SCREAMING_SNAKE_CASE           =					in_proj_bias[: config.hidden_size]
						SCREAMING_SNAKE_CASE           =					in_proj_weight[
						    config.hidden_size : config.hidden_size * 2, :
						]
						SCREAMING_SNAKE_CASE           =					in_proj_bias[
						    config.hidden_size : config.hidden_size * 2
						]
						SCREAMING_SNAKE_CASE           =					in_proj_weight[
						    -config.hidden_size :, :
						]
						SCREAMING_SNAKE_CASE           =					in_proj_bias[-config.hidden_size :]
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					["head.weight", "head.bias"]
			for k in ignore_keys:
						state_dict.pop(_lowerCamelCase					,	_lowerCamelCase   )
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					dct.pop(_lowerCamelCase   )
			SCREAMING_SNAKE_CASE           =					val
def 					lowerCamelCase_    (    ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					"http://images.cocodataset.org/val2017/000000039769.jpg"
			SCREAMING_SNAKE_CASE           =					Image.open(requests.get(_lowerCamelCase					,	stream=_lowerCamelCase   ).raw   )
			return im
@torch.no_grad()
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE=True   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					ViTConfig()
			# patch_size
			if model_name[-1] == "8":
						SCREAMING_SNAKE_CASE           =					8
			# set labels if required
			if not base_model:
						SCREAMING_SNAKE_CASE           =					10_00
						SCREAMING_SNAKE_CASE           =					"huggingface/label-files"
						SCREAMING_SNAKE_CASE           =					"imagenet-1k-id2label.json"
						SCREAMING_SNAKE_CASE           =					json.load(open(hf_hub_download(_lowerCamelCase					,	_lowerCamelCase					,	repo_type="""dataset"""   )					,	"""r"""   )   )
						SCREAMING_SNAKE_CASE           =					{int(_lowerCamelCase   ): v for k, v in idalabel.items()}
						SCREAMING_SNAKE_CASE           =					idalabel
						SCREAMING_SNAKE_CASE           =					{v: k for k, v in idalabel.items()}
			# size of the architecture
			if model_name in ["dino_vits8", "dino_vits16"]:
						SCREAMING_SNAKE_CASE           =					3_84
						SCREAMING_SNAKE_CASE           =					15_36
						SCREAMING_SNAKE_CASE           =					12
						SCREAMING_SNAKE_CASE           =					6

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

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

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

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












import os
from shutil import copyfile
from typing import List, Optional, Tuple

from tokenizers import processors

from ...tokenization_utils import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
		from .tokenization_mbart import MBartTokenizer
else:
		__A						:							Tuple							=  None


__A						:							Any							=  logging.get_logger(__name__)


__A						:							Union[str, Any]							=  {"""vocab_file""": """sentencepiece.bpe.model""", """tokenizer_file""": """tokenizer.json"""}

__A						:							List[Any]							=  {
    """vocab_file""": {
        """facebook/mbart-large-en-ro""": (
            """https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model"""
        ),
        """facebook/mbart-large-cc25""": (
            """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model"""
        ),
    },
    """tokenizer_file""": {
        """facebook/mbart-large-en-ro""": """https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json""",
        """facebook/mbart-large-cc25""": """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json""",
    },
}

__A						:							int							=  {
    """facebook/mbart-large-en-ro""": 1_0_2_4,
    """facebook/mbart-large-cc25""": 1_0_2_4,
}

# fmt: off
__A						:							List[Any]							=  ["""ar_AR""", """cs_CZ""", """de_DE""", """en_XX""", """es_XX""", """et_EE""", """fi_FI""", """fr_XX""", """gu_IN""", """hi_IN""", """it_IT""", """ja_XX""", """kk_KZ""", """ko_KR""", """lt_LT""", """lv_LV""", """my_MM""", """ne_NP""", """nl_XX""", """ro_RO""", """ru_RU""", """si_LK""", """tr_TR""", """vi_VN""", """zh_CN"""]




class 			UpperCAmelCase_      (   A       ):




							'''simple docstring'''



							a__						  =     VOCAB_FILES_NAMES
							a__						  =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							a__						  =     PRETRAINED_VOCAB_FILES_MAP
							a__						  =     ['''input_ids''', '''attention_mask''']
							a__						  =     MBartTokenizer

							a__						  =     []
							a__						  =     []





							def __init__(					self       :	str       ,     a       :	List[Any]=None       ,     a       :	Optional[int]=None       ,     a       :	str="<s>"       ,     a       :	Tuple="</s>"       ,     a       :	Optional[int]="</s>"       ,     a       :	int="<s>"       ,     a       :	List[str]="<unk>"       ,     a       :	Tuple="<pad>"       ,     a       :	Dict="<mask>"       ,     a       :	Optional[Any]=None       ,     a       :	List[Any]=None       ,     a       :	Any=None       ,     **a       :	Optional[Any]       ,     )			->					Any:
										# Mask token behave like a normal word, i.e. include the space before it
										SCREAMING_SNAKE_CASE           =					AddedToken(a       ,     lstrip=a       ,     rstrip=a			) if isinstance(a       ,     a			) else mask_token

										super().__init__(
										    vocab_file=a       ,     tokenizer_file=a       ,     bos_token=a       ,     eos_token=a       ,     sep_token=a       ,     cls_token=a       ,     unk_token=a       ,     pad_token=a       ,     mask_token=a       ,     src_lang=a       ,     tgt_lang=a       ,     additional_special_tokens=a       ,     **a       ,     )

										SCREAMING_SNAKE_CASE           =					vocab_file
										SCREAMING_SNAKE_CASE           =					False if not self.vocab_file else True

										SCREAMING_SNAKE_CASE           =					FAIRSEQ_LANGUAGE_CODES.copy()

										if additional_special_tokens is not None:
													# Only add those special tokens if they are not already there.
													_additional_special_tokens.extend(
													    [t for t in additional_special_tokens if t not in _additional_special_tokens]			)

										self.add_special_tokens({"""additional_special_tokens""": _additional_special_tokens}			)
										SCREAMING_SNAKE_CASE           =					{
										    lang_code: self.convert_tokens_to_ids(a			) for lang_code in FAIRSEQ_LANGUAGE_CODES
										}

										SCREAMING_SNAKE_CASE           =					src_lang if src_lang is not None else """en_XX"""
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(self._src_lang			)
										SCREAMING_SNAKE_CASE           =					tgt_lang
										self.set_src_lang_special_tokens(self._src_lang			)





							@property
							def    _UpperCAmelCase     (					self       :	int			)			->					str:
										return self._src_lang





							@src_lang.setter
							def    _UpperCAmelCase     (					self       :	List[Any]       ,     a       :	str			)			->					None:
										SCREAMING_SNAKE_CASE           =					new_src_lang
										self.set_src_lang_special_tokens(self._src_lang			)





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	List[int]       ,     a       :	Optional[List[int]] = None			)			->					List[int]:
										if token_ids_a is None:
													return self.prefix_tokens + token_ids_a + self.suffix_tokens
										# We don't expect to process pairs, but leave the pair logic for API consistency
										return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens





							def    _UpperCAmelCase     (					self       :	Tuple       ,     a       :	List[int]       ,     a       :	Optional[List[int]] = None			)			->					List[int]:
										SCREAMING_SNAKE_CASE           =					[self.sep_token_id]
										SCREAMING_SNAKE_CASE           =					[self.cls_token_id]

										if token_ids_a is None:
													return len(cls + token_ids_a + sep			) * [0]
										return len(cls + token_ids_a + sep + sep + token_ids_a + sep			) * [0]





							def    _UpperCAmelCase     (					self       :	Optional[Any]       ,     a       :	Optional[int]       ,     a       :	str       ,     a       :	Optional[str]       ,     a       :	Optional[str]       ,     **a       :	Optional[Any]			)			->					Optional[Any]:
										if src_lang is None or tgt_lang is None:
													raise ValueError("""Translation requires a `src_lang` and a `tgt_lang` for this model"""			)
										SCREAMING_SNAKE_CASE           =					src_lang
										SCREAMING_SNAKE_CASE           =					self(a       ,     add_special_tokens=a       ,     return_tensors=a       ,     **a			)
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(a			)
										SCREAMING_SNAKE_CASE           =					tgt_lang_id
										return inputs





							def    _UpperCAmelCase     (					self       :	str       ,     a       :	List[str]       ,     a       :	str = "en_XX"       ,     a       :	Optional[List[str]] = None       ,     a       :	str = "ro_RO"       ,     **a       :	List[str]       ,     )			->					BatchEncoding:
										SCREAMING_SNAKE_CASE           =					src_lang
										SCREAMING_SNAKE_CASE           =					tgt_lang
										return super().prepare_seqaseq_batch(a       ,     a       ,     **a			)





							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					str:
										return self.set_src_lang_special_tokens(self.src_lang			)





							def    _UpperCAmelCase     (					self       :	str			)			->					List[str]:
										return self.set_tgt_lang_special_tokens(self.tgt_lang			)





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	List[str]			)			->					None:
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(a			)
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[self.eos_token_id, self.cur_lang_code]

										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.prefix_tokens			)
										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.suffix_tokens			)

										SCREAMING_SNAKE_CASE           =					processors.TemplateProcessing(
										    single=prefix_tokens_str + ["""$A"""] + suffix_tokens_str       ,     pair=prefix_tokens_str + ["""$A""", """$B"""] + suffix_tokens_str       ,     special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str       ,     self.prefix_tokens + self.suffix_tokens			)			)       ,     )





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str			)			->					None:
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(a			)
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[self.eos_token_id, self.cur_lang_code]

										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.prefix_tokens			)
										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.suffix_tokens			)

										SCREAMING_SNAKE_CASE           =					processors.TemplateProcessing(
										    single=prefix_tokens_str + ["""$A"""] + suffix_tokens_str       ,     pair=prefix_tokens_str + ["""$A""", """$B"""] + suffix_tokens_str       ,     special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str       ,     self.prefix_tokens + self.suffix_tokens			)			)       ,     )







							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str       ,     a       :	Optional[str] = None			)			->					Tuple[str]:
										if not self.can_save_slow_tokenizer:
													raise ValueError(
													    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
													    """tokenizer."""			)

										if not os.path.isdir(a			):
													logger.error(f"""Vocabulary path ({save_directory}) should be a directory."""			)
													return
										SCREAMING_SNAKE_CASE           =					os.path.join(
										    a       ,     (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]			)

										if os.path.abspath(self.vocab_file			) != os.path.abspath(a			):
													copyfile(self.vocab_file       ,     a			)

										return (out_vocab_file,)






