
"""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 ( __a,							__a=False    ):
		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'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"
				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 ( __a,							__a,							__a=False    ):
		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'module.blocks.{i}.attn.qkv.weight'    )
				SCREAMING_SNAKE_CASE_						 = state_dict.pop(F'module.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 ( __a    ):
		SCREAMING_SNAKE_CASE_						 = ['''head.weight''', '''head.bias''']
		for k in ignore_keys:
				state_dict.pop(__a,							__a    )



def        _lowerCamelCase ( __a    ):
		# projection head is used in the self-supervised pre-training in MSN,
		# for downstream task it's not needed.
		SCREAMING_SNAKE_CASE_						 = [
		    '''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        _lowerCamelCase ( __a,							__a,							__a    ):
		SCREAMING_SNAKE_CASE_						 = dct.pop(__a    )
		SCREAMING_SNAKE_CASE_						 = val



def        _lowerCamelCase ( __a,							__a    ):
		SCREAMING_SNAKE_CASE_						 = ViTMSNConfig()
		SCREAMING_SNAKE_CASE_						 = 1_000

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

		if "s16" in checkpoint_url:
				SCREAMING_SNAKE_CASE_						 = 384
				SCREAMING_SNAKE_CASE_						 = 1_536
				SCREAMING_SNAKE_CASE_						 = 6
		elif "l16" in checkpoint_url:
				SCREAMING_SNAKE_CASE_						 = 1_024
				SCREAMING_SNAKE_CASE_						 = 4_096
				SCREAMING_SNAKE_CASE_						 = 24
				SCREAMING_SNAKE_CASE_						 = 16
				SCREAMING_SNAKE_CASE_						 = 0.1
		elif "b4" in checkpoint_url:
				SCREAMING_SNAKE_CASE_						 = 4
		elif "l7" in checkpoint_url:
				SCREAMING_SNAKE_CASE_						 = 7
				SCREAMING_SNAKE_CASE_						 = 1_024
				SCREAMING_SNAKE_CASE_						 = 4_096
				SCREAMING_SNAKE_CASE_						 = 24
				SCREAMING_SNAKE_CASE_						 = 16
				SCREAMING_SNAKE_CASE_						 = 0.1

		SCREAMING_SNAKE_CASE_						 = ViTMSNModel(__a    )

		SCREAMING_SNAKE_CASE_						 = torch.hub.load_state_dict_from_url(__a,							map_location='''cpu'''    )['''target_encoder''']

		SCREAMING_SNAKE_CASE_						 = ViTImageProcessor(size=config.image_size    )

		remove_projection_head(__a    )
		SCREAMING_SNAKE_CASE_						 = 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()

		SCREAMING_SNAKE_CASE_						 = '''http://images.cocodataset.org/val2017/000000039769.jpg'''

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

		# forward pass
		torch.manual_seed(2    )
		SCREAMING_SNAKE_CASE_						 = model(**__a    )
		SCREAMING_SNAKE_CASE_						 = 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:
				SCREAMING_SNAKE_CASE_						 = torch.tensor([[-1.0_9_1_5, -1.4_8_7_6, -1.1_8_0_9]]    )
		elif "b16" in checkpoint_url:
				SCREAMING_SNAKE_CASE_						 = torch.tensor([[1_4.2_8_8_9, -1_8.9_0_4_5, 1_1.7_2_8_1]]    )
		elif "l16" in checkpoint_url:
				SCREAMING_SNAKE_CASE_						 = torch.tensor([[4_1.5_0_2_8, -2_2.8_6_8_1, 4_5.6_4_7_5]]    )
		elif "b4" in checkpoint_url:
				SCREAMING_SNAKE_CASE_						 = torch.tensor([[-4.3_8_6_8, 5.2_9_3_2, -0.4_1_3_7]]    )
		else:
				SCREAMING_SNAKE_CASE_						 = torch.tensor([[-0.1_7_9_2, -0.6_4_6_5, 2.4_2_6_3]]    )

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

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

"""simple docstring"""




from __future__ import annotations

import typing
from collections import Counter



def        _lowerCamelCase ( __a    ):
		SCREAMING_SNAKE_CASE_						 = Counter()
		for base in range(1,							max_perimeter + 1    ):
				for perpendicular in range(__a,							max_perimeter + 1    ):
						SCREAMING_SNAKE_CASE_						 = (base * base + perpendicular * perpendicular) ** 0.5
						if hypotenuse == int(__a    ):
								SCREAMING_SNAKE_CASE_						 = int(base + perpendicular + hypotenuse    )
								if perimeter > max_perimeter:
										continue
								triplets[perimeter] += 1
		return triplets



def        _lowerCamelCase ( __a = 1_000    ):
		SCREAMING_SNAKE_CASE_						 = pythagorean_triple(__a    )
		return triplets.most_common(1    )[0][0]


if __name__ == "__main__":
						print(f'''Perimeter {solution()} has maximum solutions''')