



"""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   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__=False			) ->							Optional[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"""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   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__=False			) ->							Dict:
							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   lowerCAmelCase__			(     lowerCamelCase__			) ->							int:
							A         =					['head.weight', 'head.bias']
							for k in ignore_keys:
														state_dict.pop(lowerCamelCase__				,      lowerCamelCase__			)

def   lowerCAmelCase__			(     lowerCamelCase__			) ->							Optional[int]:
							# projection head is used in the self-supervised pre-training in MSN,
							# for downstream task it's not needed.
							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(lowerCamelCase__				,      lowerCamelCase__			)

def   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__			) ->							Optional[int]:
							A         =					dct.pop(lowerCamelCase__			)
							A         =					val

def   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__			) ->							Optional[Any]:
							A         =					ViTMSNConfig()
							A         =					1000

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

							if "s16" in checkpoint_url:
														A         =					384
														A         =					1536
														A         =					6
							elif "l16" in checkpoint_url:
														A         =					1024
														A         =					4096
														A         =					24
														A         =					16
														A         =					0.1
							elif "b4" in checkpoint_url:
														A         =					4
							elif "l7" in checkpoint_url:
														A         =					7
														A         =					1024
														A         =					4096
														A         =					24
														A         =					16
														A         =					0.1

							A         =					ViTMSNModel(lowerCamelCase__			)

							A         =					torch.hub.load_state_dict_from_url(lowerCamelCase__				,      map_location='cpu'			)['target_encoder']

							A         =					ViTImageProcessor(size=config.image_size			)

							remove_projection_head(lowerCamelCase__			)
							A         =					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         =					'http://images.cocodataset.org/val2017/000000039769.jpg'

							A         =					Image.open(requests.get(lowerCamelCase__				,      stream=lowerCamelCase__			).raw			)
							A         =					ViTImageProcessor(
							    size=config.image_size				,      image_mean=lowerCamelCase__				,      image_std=lowerCamelCase__			)
							A         =					image_processor(images=lowerCamelCase__				,      return_tensors='pt'			)

							# forward pass
							torch.manual_seed(2			)
							A         =					model(**lowerCamelCase__			)
							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.09_15, -1.48_76, -1.18_09]]			)
							elif "b16" in checkpoint_url:
														A         =					torch.tensor([[14.28_89, -18.90_45, 11.72_81]]			)
							elif "l16" in checkpoint_url:
														A         =					torch.tensor([[41.50_28, -22.86_81, 45.64_75]]			)
							elif "b4" in checkpoint_url:
														A         =					torch.tensor([[-4.38_68, 5.29_32, -0.41_37]]			)
							else:
														A         =					torch.tensor([[-0.17_92, -0.64_65, 2.42_63]]			)

							# 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__":
							A    =			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.'
							)

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








"""simple docstring"""







import os
import unittest

from transformers import LayoutLMTokenizer, LayoutLMTokenizerFast
from transformers.models.layoutlm.tokenization_layoutlm import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class      UpperCAmelCase__		(      UpperCamelCase   ,unittest.TestCase     ):
		lowerCAmelCase_       :	Tuple 							=     LayoutLMTokenizer
		lowerCAmelCase_       :	Any 							=     LayoutLMTokenizerFast
		lowerCAmelCase_       :	Optional[int] 							=     True
		lowerCAmelCase_       :	List[Any] 							=     True



		def 					A_		( self  :    Optional[Any]				)			->						Optional[Any]:






									'''simple docstring'''

									super().setUp()

									A         =					[
									    '[UNK]',
									    '[CLS]',
									    '[SEP]',
									    'want',
									    '##want',
									    '##ed',
									    'wa',
									    'un',
									    'runn',
									    '##ing',
									    ',',
									    'low',
									    'lowest',
									]
									A         =					os.path.join(self.tmpdirname      ,							VOCAB_FILES_NAMES['vocab_file']				)
									with open(self.vocab_file      ,							'w'      ,							encoding='utf-8'				) as vocab_writer:
																vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]				)				)



		def 					A_		( self  :    str      ,							**snake_case  :    Tuple				)			->						Union[str, Any]:






									'''simple docstring'''

									return LayoutLMTokenizer.from_pretrained(self.tmpdirname      ,							**snake_case				)



		def 					A_		( self  :    List[str]      ,							snake_case  :    int				)			->						List[Any]:






									'''simple docstring'''

									A         =					'UNwant\u00E9d,running'
									A         =					'unwanted, running'
									return input_text, output_text



		def 					A_		( self  :    Tuple				)			->						Optional[int]:






									'''simple docstring'''

									A         =					self.tokenizer_class(self.vocab_file				)

									A         =					tokenizer.tokenize('UNwant\u00E9d,running'				)
									self.assertListEqual(snake_case      ,							['un', '##want', '##ed', ',', 'runn', '##ing']				)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case				)      ,							[7, 4, 5, 10, 8, 9]				)



		def 					A_		( self  :    Any				)			->						List[Any]:






									'''simple docstring'''

									pass



