"""simple docstring"""



import builtins
import sys

from ...utils.imports import _is_package_available
from . import cursor, input
from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor
from .keymap import KEYMAP


_UpperCamelCase								=		False
try:
				_UpperCamelCase								=		_is_package_available("google.colab")
except ModuleNotFoundError:
				pass
@input.register
class 						__UpperCAmelCase    :







			'''simple docstring'''





			def __init__(			self   ,      snake_case_ = None   ,      snake_case_ = []							):







										'''simple docstring'''


										A__       :     Optional[int]								=			0
										A__       :     int								=			choices
										A__       :     List[Any]								=			prompt
										if sys.platform == "win32":
																	A__       :     Tuple								=			"""*"""
										else:
																	A__       :     str								=			"""➔ """





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_ = ""							):







										'''simple docstring'''


										if sys.platform != "win32":
																	writeColor(self.choices[index]   ,      32   ,      snake_case_							)
										else:
																	forceWrite(self.choices[index]   ,      snake_case_							)





			def 		lowerCamelCase					(			self   ,      snake_case_							):







										'''simple docstring'''


										if index == self.position:
																	forceWrite(F''' {self.arrow_char} '''							)
																	self.write_choice(snake_case_							)
										else:
																	forceWrite(F'''    {self.choices[index]}'''							)
										reset_cursor()





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_ = 1							):







										'''simple docstring'''


										A__       :     List[Any]								=			self.position
										if direction == Direction.DOWN:
																	if self.position + 1 >= len(self.choices							):
																								return
																	self.position += num_spaces
										else:
																	if self.position - 1 < 0:
																								return
																	self.position -= num_spaces
										clear_line()
										self.print_choice(snake_case_							)
										move_cursor(snake_case_   ,      direction.name							)
										self.print_choice(self.position							)





			@input.mark(KEYMAP["""up"""]							)
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										self.move_direction(Direction.UP							)





			@input.mark(KEYMAP["""down"""]							)
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										self.move_direction(Direction.DOWN							)





			@input.mark(KEYMAP["""newline"""]							)
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										move_cursor(len(self.choices							) - self.position   ,      """DOWN"""							)
										return self.position





			@input.mark(KEYMAP["""interrupt"""]							)
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										move_cursor(len(self.choices							) - self.position   ,      """DOWN"""							)
										raise KeyboardInterrupt





			@input.mark_multiple(*[KEYMAP[str(snake_case_							)] for number in range(10							)]							)
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			int(chr(self.current_selection							)							)
										A__       :     Any								=			index - self.position
										if index == self.position:
																	return
										if index < len(self.choices							):
																	if self.position > index:
																								self.move_direction(Direction.UP   ,      -movement							)
																	elif self.position < index:
																								self.move_direction(Direction.DOWN   ,      snake_case_							)
																	else:
																								return
										else:
																	return





			def 		lowerCamelCase					(			self   ,      snake_case_ = 0							):







										'''simple docstring'''


										if self.prompt:
																	linebreak()
																	forceWrite(self.prompt   ,      """\n"""							)
																	if in_colab:
																								forceWrite("""Please input a choice index (starting from 0), and press enter"""   ,      """\n"""							)
																	else:
																								forceWrite("""Please select a choice using the arrow or number keys, and selecting with enter"""   ,      """\n"""							)
										A__       :     Optional[Any]								=			default_choice
										for i in range(len(self.choices							)							):
																	self.print_choice(snake_case_							)
																	forceWrite("""\n"""							)
										move_cursor(len(self.choices							) - self.position   ,      """UP"""							)
										with cursor.hide():
																	while True:
																								if in_colab:
																															try:
																																						A__       :     Union[str, Any]								=			int(builtins.input()							)
																															except ValueError:
																																						A__       :     Optional[int]								=			default_choice
																								else:
																															A__       :     Any								=			self.handle_input()
																								if choice is not None:
																															reset_cursor()
																															for _ in range(len(self.choices							) + 1							):
																																						move_cursor(1   ,      """UP"""							)
																																						clear_line()
																															self.write_choice(snake_case_   ,      """\n"""							)
																															return choice






"""simple docstring"""



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  _A(		lowerCAmelCase			,  lowerCAmelCase=False							):
							A__       :     Dict								=			[]
							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__       :     Dict								=			[(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:
																					A__       :     List[str]								=			""""""
														else:
																					A__       :     Dict								=			"""vit."""
														# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
														A__       :     List[str]								=			state_dict.pop(F'''module.blocks.{i}.attn.qkv.weight'''							)
														A__       :     Tuple								=			state_dict.pop(F'''module.blocks.{i}.attn.qkv.bias'''							)
														# next, add query, keys and values (in that order) to the state dict
														A__       :     Tuple								=			in_proj_weight[
														    : config.hidden_size, :
														]
														A__       :     Union[str, Any]								=			in_proj_bias[: config.hidden_size]
														A__       :     List[str]								=			in_proj_weight[
														    config.hidden_size : config.hidden_size * 2, :
														]
														A__       :     int								=			in_proj_bias[
														    config.hidden_size : config.hidden_size * 2
														]
														A__       :     int								=			in_proj_weight[
														    -config.hidden_size :, :
														]
														A__       :     List[Any]								=			in_proj_bias[-config.hidden_size :]

def  _A(		lowerCAmelCase							):
							A__       :     str								=			["""head.weight""", """head.bias"""]
							for k in ignore_keys:
														state_dict.pop(lowerCAmelCase			,  lowerCAmelCase							)

def  _A(		lowerCAmelCase							):
							# projection head is used in the self-supervised pre-training in MSN,
							# for downstream task it's not needed.
							A__       :     Dict								=			[
							    """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(lowerCAmelCase			,  lowerCAmelCase							)

def  _A(		lowerCAmelCase			,  lowerCAmelCase			,  lowerCAmelCase							):
							A__       :     Optional[Any]								=			dct.pop(lowerCAmelCase							)
							A__       :     List[Any]								=			val

def  _A(		lowerCAmelCase			,  lowerCAmelCase							):
							A__       :     str								=			ViTMSNConfig()
							A__       :     List[str]								=			1000

							A__       :     Optional[int]								=			"""datasets/huggingface/label-files"""
							A__       :     Optional[int]								=			"""imagenet-1k-id2label.json"""
							A__       :     str								=			json.load(open(hf_hub_download(lowerCAmelCase			,  lowerCAmelCase							)			,  """r"""							)							)
							A__       :     Tuple								=			{int(lowerCAmelCase							): v for k, v in idalabel.items()}
							A__       :     Optional[Any]								=			idalabel
							A__       :     List[Any]								=			{v: k for k, v in idalabel.items()}

							if "s16" in checkpoint_url:
														A__       :     Tuple								=			384
														A__       :     int								=			1536
														A__       :     Union[str, Any]								=			6
							elif "l16" in checkpoint_url:
														A__       :     int								=			1024
														A__       :     int								=			4096
														A__       :     Any								=			24
														A__       :     int								=			16
														A__       :     Union[str, Any]								=			0.1
							elif "b4" in checkpoint_url:
														A__       :     Dict								=			4
							elif "l7" in checkpoint_url:
														A__       :     List[str]								=			7
														A__       :     Optional[int]								=			1024
														A__       :     Optional[int]								=			4096
														A__       :     Any								=			24
														A__       :     Union[str, Any]								=			16
														A__       :     Tuple								=			0.1

							A__       :     List[str]								=			ViTMSNModel(lowerCAmelCase							)

							A__       :     Any								=			torch.hub.load_state_dict_from_url(lowerCAmelCase			,  map_location="""cpu"""							)["""target_encoder"""]

							A__       :     List[str]								=			ViTImageProcessor(size=config.image_size							)

							remove_projection_head(lowerCAmelCase							)
							A__       :     List[str]								=			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			,  base_model=lowerCAmelCase							)

							model.load_state_dict(lowerCAmelCase							)
							model.eval()

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

							A__       :     int								=			Image.open(requests.get(lowerCAmelCase			,  stream=lowerCAmelCase							).raw							)
							A__       :     List[Any]								=			ViTImageProcessor(
							    size=config.image_size			,  image_mean=lowerCAmelCase			,  image_std=lowerCAmelCase							)
							A__       :     Any								=			image_processor(images=lowerCAmelCase			,  return_tensors="""pt"""							)

							# forward pass
							torch.manual_seed(2							)
							A__       :     Tuple								=			model(**lowerCAmelCase							)
							A__       :     Union[str, Any]								=			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__       :     Union[str, Any]								=			torch.tensor([[-1.0915, -1.4876, -1.1809]]							)
							elif "b16" in checkpoint_url:
														A__       :     int								=			torch.tensor([[14.2889, -18.9045, 11.7281]]							)
							elif "l16" in checkpoint_url:
														A__       :     List[Any]								=			torch.tensor([[41.5028, -22.8681, 45.6475]]							)
							elif "b4" in checkpoint_url:
														A__       :     Optional[Any]								=			torch.tensor([[-4.3868, 5.2932, -0.4137]]							)
							else:
														A__       :     str								=			torch.tensor([[-0.1792, -0.6465, 2.4263]]							)

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

							print(F'''Saving model 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__":
				_UpperCamelCase								=		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."
				)

				_UpperCamelCase								=		parser.parse_args()
				convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)





