
import argparse
import json

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

from transformers import ViTImageProcessor, ViTMSNConfig, ViTMSNModel
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD


torch.set_grad_enabled(False)


def 						UpperCAmelCase      (     a_		,       a_=False						)		->     Dict:







				"""simple docstring"""



				__A             =			[]
				for i in range(config.num_hidden_layers						):
								# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
								rename_keys.append((F'''module.blocks.{i}.norm1.weight''', F'''vit.encoder.layer.{i}.layernorm_before.weight''')						)
								rename_keys.append((F'''module.blocks.{i}.norm1.bias''', F'''vit.encoder.layer.{i}.layernorm_before.bias''')						)
								rename_keys.append(
								    (F'''module.blocks.{i}.attn.proj.weight''', F'''vit.encoder.layer.{i}.attention.output.dense.weight''')						)
								rename_keys.append((F'''module.blocks.{i}.attn.proj.bias''', F'''vit.encoder.layer.{i}.attention.output.dense.bias''')						)
								rename_keys.append((F'''module.blocks.{i}.norm2.weight''', F'''vit.encoder.layer.{i}.layernorm_after.weight''')						)
								rename_keys.append((F'''module.blocks.{i}.norm2.bias''', F'''vit.encoder.layer.{i}.layernorm_after.bias''')						)
								rename_keys.append((F'''module.blocks.{i}.mlp.fc1.weight''', F'''vit.encoder.layer.{i}.intermediate.dense.weight''')						)
								rename_keys.append((F'''module.blocks.{i}.mlp.fc1.bias''', F'''vit.encoder.layer.{i}.intermediate.dense.bias''')						)
								rename_keys.append((F'''module.blocks.{i}.mlp.fc2.weight''', F'''vit.encoder.layer.{i}.output.dense.weight''')						)
								rename_keys.append((F'''module.blocks.{i}.mlp.fc2.bias''', F'''vit.encoder.layer.{i}.output.dense.bias''')						)

				# projection layer + position embeddings
				rename_keys.extend(
				    [
				        ("module.cls_token", "vit.embeddings.cls_token"),
				        ("module.patch_embed.proj.weight", "vit.embeddings.patch_embeddings.projection.weight"),
				        ("module.patch_embed.proj.bias", "vit.embeddings.patch_embeddings.projection.bias"),
				        ("module.pos_embed", "vit.embeddings.position_embeddings"),
				    ]						)

				if base_model:
								# layernorm + pooler
								rename_keys.extend(
								    [
								        ("module.norm.weight", "layernorm.weight"),
								        ("module.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 						UpperCAmelCase      (     a_		,       a_		,       a_=False						)		->     List[Any]:







				"""simple docstring"""



				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'''module.blocks.{i}.attn.qkv.weight'''						)
								__A             =			state_dict.pop(F'''module.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 						UpperCAmelCase      (     a_						)		->     List[Any]:







				"""simple docstring"""



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


def 						UpperCAmelCase      (     a_						)		->     Any:







				"""simple docstring"""



				__A             =			[
				    "module.fc.fc1.weight",
				    "module.fc.fc1.bias",
				    "module.fc.bn1.weight",
				    "module.fc.bn1.bias",
				    "module.fc.bn1.running_mean",
				    "module.fc.bn1.running_var",
				    "module.fc.bn1.num_batches_tracked",
				    "module.fc.fc2.weight",
				    "module.fc.fc2.bias",
				    "module.fc.bn2.weight",
				    "module.fc.bn2.bias",
				    "module.fc.bn2.running_mean",
				    "module.fc.bn2.running_var",
				    "module.fc.bn2.num_batches_tracked",
				    "module.fc.fc3.weight",
				    "module.fc.fc3.bias",
				]
				for k in ignore_keys:
								state_dict.pop(a_		,       a_						)


def 						UpperCAmelCase      (     a_		,       a_		,       a_						)		->     List[Any]:







				"""simple docstring"""



				__A             =			dct.pop(a_						)
				__A             =			val


def 						UpperCAmelCase      (     a_		,       a_						)		->     str:







				"""simple docstring"""



				__A             =			ViTMSNConfig()
				__A             =			1_0_0_0

				__A             =			"datasets/huggingface/label-files"
				__A             =			"imagenet-1k-id2label.json"
				__A             =			json.load(open(hf_hub_download(a_		,       a_						)		,       "r"						)						)
				__A             =			{int(a_						): v for k, v in idalabel.items()}
				__A             =			idalabel
				__A             =			{v: k for k, v in idalabel.items()}

				if "s16" in checkpoint_url:
								__A             =			3_8_4
								__A             =			1_5_3_6
								__A             =			6
				elif "l16" in checkpoint_url:
								__A             =			1_0_2_4
								__A             =			4_0_9_6
								__A             =			2_4
								__A             =			1_6
								__A             =			0.1
				elif "b4" in checkpoint_url:
								__A             =			4
				elif "l7" in checkpoint_url:
								__A             =			7
								__A             =			1_0_2_4
								__A             =			4_0_9_6
								__A             =			2_4
								__A             =			1_6
								__A             =			0.1

				__A             =			ViTMSNModel(a_						)

				__A             =			torch.hub.load_state_dict_from_url(a_		,       map_location="cpu"						)["target_encoder"]

				__A             =			ViTImageProcessor(size=config.image_size						)

				remove_projection_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_		,       base_model=a_						)

				model.load_state_dict(a_						)
				model.eval()

				__A             =			"http://images.cocodataset.org/val2017/000000039769.jpg"

				__A             =			Image.open(requests.get(a_		,       stream=a_						).raw						)
				__A             =			ViTImageProcessor(
				    size=config.image_size		,       image_mean=a_		,       image_std=a_						)
				__A             =			image_processor(images=a_		,       return_tensors="pt"						)

				# forward pass
				torch.manual_seed(2						)
				__A             =			model(**a_						)
				__A             =			outputs.last_hidden_state

				# The following Colab Notebook was used to generate these outputs:
				# https://colab.research.google.com/gist/sayakpaul/3672419a04f5997827503fd84079bdd1/scratchpad.ipynb
				if "s16" in checkpoint_url:
								__A             =			torch.tensor([[-1.0_915, -1.4_876, -1.1_809]]						)
				elif "b16" in checkpoint_url:
								__A             =			torch.tensor([[14.2_889, -18.9_045, 11.7_281]]						)
				elif "l16" in checkpoint_url:
								__A             =			torch.tensor([[41.5_028, -22.8_681, 45.6_475]]						)
				elif "b4" in checkpoint_url:
								__A             =			torch.tensor([[-4.3_868, 5.2_932, -0.4_137]]						)
				else:
								__A             =			torch.tensor([[-0.1_792, -0.6_465, 2.4_263]]						)

				# verify logits
				assert torch.allclose(last_hidden_state[:, 0, :3]		,       a_		,       atol=1E-4						)

				print(F'''Saving model 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__":
					SCREAMING_SNAKE_CASE							:Dict										=    argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '--checkpoint_url',
					    default='https://dl.fbaipublicfiles.com/msn/vits16_800ep.pth.tar',
					    type=str,
					    help='URL of the checkpoint you\'d like to convert.',
					)
					parser.add_argument(
					    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
					)

					SCREAMING_SNAKE_CASE							:Dict										=    parser.parse_args()
					convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)


import argparse
from collections import defaultdict

import yaml


SCREAMING_SNAKE_CASE							:str										=    'docs/source/en/_toctree.yml'


def 						UpperCAmelCase      (     a_						)		->     int:







				"""simple docstring"""



				__A             =			defaultdict(a_						)
				for doc in model_doc:
								counts[doc["local"]] += 1
				__A             =			[key for key, value in counts.items() if value > 1]

				__A             =			[]
				for duplicate_key in duplicates:
								__A             =			list({doc["title"] for doc in model_doc if doc["local"] == duplicate_key}						)
								if len(a_						) > 1:
												raise ValueError(
												    F'''{duplicate_key} is present several times in the documentation table of content at '''
												    "`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the "
												    "others."						)
								# Only add this once
								new_doc.append({"local": duplicate_key, "title": titles[0]}						)

				# Add none duplicate-keys
				new_doc.extend([doc for doc in model_doc if counts[doc["local"]] == 1]						)

				# Sort
				return sorted(a_		,       key=lambda a_						: s["title"].lower()						)


def 						UpperCAmelCase      (     a_=False						)		->     List[Any]:







				"""simple docstring"""



				with open(a_		,       encoding="utf-8"						) as f:
								__A             =			yaml.safe_load(f.read()						)

				# Get to the API doc
				__A             =			0
				while content[api_idx]["title"] != "API":
								api_idx += 1
				__A             =			content[api_idx]["sections"]

				# Then to the model doc
				__A             =			0
				while api_doc[model_idx]["title"] != "Models":
								model_idx += 1

				__A             =			api_doc[model_idx]["sections"]

				__A             =			[(idx, section) for idx, section in enumerate(a_						) if "sections" in section]
				__A             =			False
				for idx, modality_doc in modalities_docs:
								__A             =			modality_doc["sections"]
								__A             =			clean_model_doc_toc(a_						)

								if old_modality_doc != new_modality_doc:
												__A             =			True
												if overwrite:
																__A             =			new_modality_doc

				if diff:
								if overwrite:
												__A             =			model_doc
												__A             =			api_doc
												with open(a_		,       "w"		,       encoding="utf-8"						) as f:
																f.write(yaml.dump(a_		,       allow_unicode=a_						)						)
								else:
												raise ValueError(
												    "The model doc part of the table of content is not properly sorted, run `make style` to fix this."						)


if __name__ == "__main__":
					SCREAMING_SNAKE_CASE							:Tuple										=    argparse.ArgumentParser()
					parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
					SCREAMING_SNAKE_CASE							:List[str]										=    parser.parse_args()

					check_model_doc(args.fix_and_overwrite)
