
'''simple docstring'''
import requests

lowercase__						       =      ""  # <-- Put your OpenWeatherMap appid here!
lowercase__						       =      "https://api.openweathermap.org/data/2.5/"




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ = "Chicago" ,       SCREAMING_SNAKE_CASE__ = APPID			)  ->							Dict:


		'''simple docstring'''


		return requests.get(URL_BASE + '''weather''' ,       params=locals()			).json()




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ = "Kolkata, India" ,       SCREAMING_SNAKE_CASE__ = APPID			)  ->							int:


		'''simple docstring'''


		return requests.get(URL_BASE + '''forecast''' ,       params=locals()			).json()




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ = 55.68 ,       SCREAMING_SNAKE_CASE__ = 12.57 ,       SCREAMING_SNAKE_CASE__ = APPID			)  ->							str:


		'''simple docstring'''


		return requests.get(URL_BASE + '''onecall''' ,       params=locals()			).json()


if __name__ == "__main__":
						from pprint import pprint

						while True:
												lowercase__						       =      input("Enter a location:").strip()
												if location:
																		pprint(current_weather(location))
												else:
																		break






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     lowercase	(    a     , a=False ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				: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"
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						[(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     lowercase	(    a     , a     , a=False ):



		'''simple docstring'''




		for i in range(config.num_hidden_layers ):
				if base_model:
						SCREAMING_SNAKE_CASE_				:List[Any]				     =						""
				else:
						SCREAMING_SNAKE_CASE_				:List[Any]				     =						"vit."
				# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
				SCREAMING_SNAKE_CASE_				:str				     =						state_dict.pop(F"module.blocks.{i}.attn.qkv.weight" )
				SCREAMING_SNAKE_CASE_				:Dict				     =						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_				:Union[str, Any]				     =						in_proj_weight[
				    : config.hidden_size, :
				]
				SCREAMING_SNAKE_CASE_				:Tuple				     =						in_proj_bias[: config.hidden_size]
				SCREAMING_SNAKE_CASE_				:Dict				     =						in_proj_weight[
				    config.hidden_size : config.hidden_size * 2, :
				]
				SCREAMING_SNAKE_CASE_				:Any				     =						in_proj_bias[
				    config.hidden_size : config.hidden_size * 2
				]
				SCREAMING_SNAKE_CASE_				:str				     =						in_proj_weight[
				    -config.hidden_size :, :
				]
				SCREAMING_SNAKE_CASE_				:int				     =						in_proj_bias[-config.hidden_size :]


def     lowercase	(    a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						["head.weight", "head.bias"]
		for k in ignore_keys:
				state_dict.pop(a     , a )


def     lowercase	(    a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:int				     =						[
		    "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     lowercase	(    a     , a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						dct.pop(a )
		SCREAMING_SNAKE_CASE_				:Dict				     =						val


def     lowercase	(    a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:List[str]				     =						ViTMSNConfig()
		SCREAMING_SNAKE_CASE_				:Tuple				     =						1000

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

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

		SCREAMING_SNAKE_CASE_				:List[Any]				     =						ViTMSNModel(a )

		SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						torch.hub.load_state_dict_from_url(a     , map_location="cpu" )["target_encoder"]

		SCREAMING_SNAKE_CASE_				:Tuple				     =						ViTImageProcessor(size=config.image_size )

		remove_projection_head(a )
		SCREAMING_SNAKE_CASE_				:int				     =						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_				:List[Any]				     =						"http://images.cocodataset.org/val2017/000000039769.jpg"

		SCREAMING_SNAKE_CASE_				:Dict				     =						Image.open(requests.get(a     , stream=a ).raw )
		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						ViTImageProcessor(
		    size=config.image_size     , image_mean=a     , image_std=a )
		SCREAMING_SNAKE_CASE_				:Any				     =						image_processor(images=a     , return_tensors="pt" )

		# forward pass
		torch.manual_seed(2 )
		SCREAMING_SNAKE_CASE_				:Tuple				     =						model(**a )
		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						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_				:Dict				     =						torch.tensor([[-1.0_915, -1.4_876, -1.1_809]] )
		elif "b16" in checkpoint_url:
				SCREAMING_SNAKE_CASE_				:Dict				     =						torch.tensor([[14.2_889, -18.9_045, 11.7_281]] )
		elif "l16" in checkpoint_url:
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						torch.tensor([[41.5_028, -22.8_681, 45.6_475]] )
		elif "b4" in checkpoint_url:
				SCREAMING_SNAKE_CASE_				:List[str]				     =						torch.tensor([[-4.3_868, 5.2_932, -0.4_137]] )
		else:
				SCREAMING_SNAKE_CASE_				:List[str]				     =						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__     					=			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__     					=			parser.parse_args()
		convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)






