"""simple docstring"""






import argparse
import json
import os

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

from transformers import ConvNextImageProcessor, ConvNextVaConfig, ConvNextVaForImageClassification
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
UpperCamelCase     					=     logging.get_logger(__name__)

def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:Tuple  )				-> Tuple:
						a_							:			Union[str, Any]     		=					ConvNextVaConfig()

						if "atto" in checkpoint_url:
												a_							:			Union[str, Any]     		=					[2, 2, 6, 2]
												a_							:			List[Any]     		=					[40, 80, 160, 320]
						if "femto" in checkpoint_url:
												a_							:			int     		=					[2, 2, 6, 2]
												a_							:			Union[str, Any]     		=					[48, 96, 192, 384]
						if "pico" in checkpoint_url:
												a_							:			Optional[Any]     		=					[2, 2, 6, 2]
												a_							:			str     		=					[64, 128, 256, 512]
						if "nano" in checkpoint_url:
												a_							:			Union[str, Any]     		=					[2, 2, 8, 2]
												a_							:			Union[str, Any]     		=					[80, 160, 320, 640]
						if "tiny" in checkpoint_url:
												a_							:			Any     		=					[3, 3, 9, 3]
												a_							:			Optional[int]     		=					[96, 192, 384, 768]
						if "base" in checkpoint_url:
												a_							:			List[Any]     		=					[3, 3, 27, 3]
												a_							:			List[str]     		=					[128, 256, 512, 1024]
						if "large" in checkpoint_url:
												a_							:			int     		=					[3, 3, 27, 3]
												a_							:			List[str]     		=					[192, 384, 768, 1536]
						if "huge" in checkpoint_url:
												a_							:			List[Any]     		=					[3, 3, 27, 3]
												a_							:			str     		=					[352, 704, 1408, 2816]

						a_							:			Tuple     		=					1000
						a_							:			Tuple     		=					'''imagenet-1k-id2label.json'''
						a_							:			List[str]     		=					(1, 1000)

						a_							:			Optional[int]     		=					'''huggingface/label-files'''
						a_							:			List[str]     		=					num_labels
						a_							:			List[str]     		=					json.load(open(hf_hub_download(UpperCamelCase__		,			UpperCamelCase__		,			repo_type="dataset"  )		,			"r"  )  )
						a_							:			Union[str, Any]     		=					{int(UpperCamelCase__  ): v for k, v in idalabel.items()}

						a_							:			List[str]     		=					idalabel
						a_							:			Tuple     		=					{v: k for k, v in idalabel.items()}
						a_							:			int     		=					hidden_sizes
						a_							:			Optional[int]     		=					depths

						return config, expected_shape

def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:List[Any]  )				-> Any:
						if "downsample_layers.0.0" in name:
												a_							:			Tuple     		=					name.replace("downsample_layers.0.0"		,			"embeddings.patch_embeddings"  )
						if "downsample_layers.0.1" in name:
												a_							:			str     		=					name.replace("downsample_layers.0.1"		,			"embeddings.norm"  )  # we rename to layernorm later on
						if "downsample_layers.1.0" in name:
												a_							:			Optional[int]     		=					name.replace("downsample_layers.1.0"		,			"stages.1.downsampling_layer.0"  )
						if "downsample_layers.1.1" in name:
												a_							:			Any     		=					name.replace("downsample_layers.1.1"		,			"stages.1.downsampling_layer.1"  )
						if "downsample_layers.2.0" in name:
												a_							:			Optional[int]     		=					name.replace("downsample_layers.2.0"		,			"stages.2.downsampling_layer.0"  )
						if "downsample_layers.2.1" in name:
												a_							:			Tuple     		=					name.replace("downsample_layers.2.1"		,			"stages.2.downsampling_layer.1"  )
						if "downsample_layers.3.0" in name:
												a_							:			Tuple     		=					name.replace("downsample_layers.3.0"		,			"stages.3.downsampling_layer.0"  )
						if "downsample_layers.3.1" in name:
												a_							:			Optional[Any]     		=					name.replace("downsample_layers.3.1"		,			"stages.3.downsampling_layer.1"  )
						if "stages" in name and "downsampling_layer" not in name:
												# stages.0.0. for instance should be renamed to stages.0.layers.0.
												a_							:			Tuple     		=					name[: len("stages.0"  )] + '''.layers''' + name[len("stages.0"  ) :]
						if "gamma" in name:
												a_							:			int     		=					name.replace("gamma"		,			"weight"  )
						if "beta" in name:
												a_							:			Any     		=					name.replace("beta"		,			"bias"  )
						if "stages" in name:
												a_							:			Dict     		=					name.replace("stages"		,			"encoder.stages"  )
						if "norm" in name:
												a_							:			Any     		=					name.replace("norm"		,			"layernorm"  )
						if "head" in name:
												a_							:			Tuple     		=					name.replace("head"		,			"classifier"  )

						return name

def  lowerCAmelCase_      ()				-> Tuple:
						a_							:			Tuple     		=					'''http://images.cocodataset.org/val2017/000000039769.jpg'''
						a_							:			Optional[Any]     		=					Image.open(requests.get(UpperCamelCase__		,			stream=UpperCamelCase__  ).raw  )
						return im

def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:int  )				-> Union[str, Any]:
						if "224" in checkpoint_url:
												a_							:			Any     		=					224
												a_							:			List[Any]     		=					224 / 256
						elif "384" in checkpoint_url:
												a_							:			Union[str, Any]     		=					384
												a_							:			List[Any]     		=					None
						else:
												a_							:			Tuple     		=					512
												a_							:			str     		=					None

						return ConvNextImageProcessor(
						    size=UpperCamelCase__		,			crop_pct=UpperCamelCase__		,			image_mean=[0.485, 0.456, 0.406]		,			image_std=[0.229, 0.224, 0.225]		,			resample=PILImageResampling.BICUBIC		,			)

@torch.no_grad()
def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:Union[str, Any]		,			_SCREAMING_SNAKE_CASE	:Dict		,			_SCREAMING_SNAKE_CASE	:List[Any]		,			_SCREAMING_SNAKE_CASE	:Optional[Any]  )				-> Union[str, Any]:
						print("Downloading original model from checkpoint..."  )
						# define ConvNeXTV2 configuration based on URL
						a_							:			Any     		=					get_convnextva_config(UpperCamelCase__  )
						# load original state_dict from URL
						a_							:			List[str]     		=					torch.hub.load_state_dict_from_url(UpperCamelCase__  )['''model''']

						print("Converting model parameters..."  )
						# rename keys
						for key in state_dict.copy().keys():
												a_							:			str     		=					state_dict.pop(UpperCamelCase__  )
												a_							:			Tuple     		=					val
						# add prefix to all keys expect classifier head
						for key in state_dict.copy().keys():
												a_							:			Union[str, Any]     		=					state_dict.pop(UpperCamelCase__  )
												if not key.startswith("classifier"  ):
																		a_							:			Optional[int]     		=					'''convnextv2.''' + key
												a_							:			List[Any]     		=					val

						# load HuggingFace model
						a_							:			Dict     		=					ConvNextVaForImageClassification(UpperCamelCase__  )
						model.load_state_dict(UpperCamelCase__  )
						model.eval()

						# Check outputs on an image, prepared by ConvNextImageProcessor
						a_							:			List[Any]     		=					convert_preprocessor(UpperCamelCase__  )
						a_							:			Union[str, Any]     		=					preprocessor(images=prepare_img()		,			return_tensors="pt"  )
						a_							:			Any     		=					model(**UpperCamelCase__  ).logits

						# note: the logits below were obtained without center cropping
						if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt":
												a_							:			Union[str, Any]     		=					torch.tensor([-0.3930, 0.1747, -0.5246, 0.4177, 0.4295]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_femto_1k_224_ema.pt":
												a_							:			str     		=					torch.tensor([-0.1727, -0.5341, -0.7818, -0.4745, -0.6566]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_pico_1k_224_ema.pt":
												a_							:			Union[str, Any]     		=					torch.tensor([-0.0333, 0.1563, -0.9137, 0.1054, 0.0381]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_nano_1k_224_ema.pt":
												a_							:			Dict     		=					torch.tensor([-0.1744, -0.1555, -0.0713, 0.0950, -0.1431]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_tiny_1k_224_ema.pt":
												a_							:			Optional[Any]     		=					torch.tensor([0.9996, 0.1966, -0.4386, -0.3472, 0.6661]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_base_1k_224_ema.pt":
												a_							:			List[Any]     		=					torch.tensor([-0.2553, -0.6708, -0.1359, 0.2518, -0.2488]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_large_1k_224_ema.pt":
												a_							:			Dict     		=					torch.tensor([-0.0673, -0.5627, -0.3753, -0.2722, 0.0178]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_huge_1k_224_ema.pt":
												a_							:			str     		=					torch.tensor([-0.6377, -0.7458, -0.2150, 0.1184, -0.0597]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_224_ema.pt":
												a_							:			Optional[int]     		=					torch.tensor([1.0799, 0.2322, -0.8860, 1.0219, 0.6231]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_384_ema.pt":
												a_							:			List[str]     		=					torch.tensor([0.3766, 0.4917, -1.1426, 0.9942, 0.6024]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_224_ema.pt":
												a_							:			str     		=					torch.tensor([0.4220, -0.6919, -0.4317, -0.2881, -0.6609]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_384_ema.pt":
												a_							:			List[Any]     		=					torch.tensor([0.1082, -0.8286, -0.5095, 0.4681, -0.8085]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_224_ema.pt":
												a_							:			Any     		=					torch.tensor([-0.2419, -0.6221, 0.2176, -0.0980, -0.7527]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_384_ema.pt":
												a_							:			Optional[Any]     		=					torch.tensor([0.0391, -0.4371, 0.3786, 0.1251, -0.2784]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_224_ema.pt":
												a_							:			str     		=					torch.tensor([-0.0504, 0.5636, -0.1729, -0.6507, -0.3949]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_384_ema.pt":
												a_							:			List[str]     		=					torch.tensor([0.3560, 0.9486, 0.3149, -0.2667, -0.5138]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_384_ema.pt":
												a_							:			str     		=					torch.tensor([-0.2469, -0.4550, -0.5853, -0.0810, 0.0309]  )
						elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_512_ema.pt":
												a_							:			List[str]     		=					torch.tensor([-0.3090, 0.0802, -0.0682, -0.1979, -0.2826]  )
						else:
												raise ValueError(F'''Unknown URL: {checkpoint_url}'''  )

						assert torch.allclose(logits[0, :5]		,			UpperCamelCase__		,			atol=1E-3  )
						assert logits.shape == expected_shape
						print("Model outputs match the original results!"  )

						if save_model:
												print("Saving model to local..."  )
												# Create folder to save model
												if not os.path.isdir(UpperCamelCase__  ):
																		os.mkdir(UpperCamelCase__  )

												model.save_pretrained(UpperCamelCase__  )
												preprocessor.save_pretrained(UpperCamelCase__  )

						a_							:			int     		=					'''convnextv2'''
						if "atto" in checkpoint_url:
												model_name += "-atto"
						if "femto" in checkpoint_url:
												model_name += "-femto"
						if "pico" in checkpoint_url:
												model_name += "-pico"
						if "nano" in checkpoint_url:
												model_name += "-nano"
						elif "tiny" in checkpoint_url:
												model_name += "-tiny"
						elif "base" in checkpoint_url:
												model_name += "-base"
						elif "large" in checkpoint_url:
												model_name += "-large"
						elif "huge" in checkpoint_url:
												model_name += "-huge"
						if "22k" in checkpoint_url and "1k" not in checkpoint_url:
												model_name += "-22k"
						elif "22k" in checkpoint_url and "1k" in checkpoint_url:
												model_name += "-22k-1k"
						elif "1k" in checkpoint_url:
												model_name += "-1k"
						if "224" in checkpoint_url:
												model_name += "-224"
						elif "384" in checkpoint_url:
												model_name += "-384"
						elif "512" in checkpoint_url:
												model_name += "-512"

						if push_to_hub:
												print(F'''Pushing {model_name} to the hub...'''  )
												model.push_to_hub(UpperCamelCase__  )
												preprocessor.push_to_hub(UpperCamelCase__  )


if __name__ == "__main__":
		UpperCamelCase     					=     argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '--checkpoint_url',
		    default='https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt',
		    type=str,
		    help='URL of the original ConvNeXTV2 checkpoint you\'d like to convert.',
		)
		parser.add_argument(
		    '--pytorch_dump_folder_path',
		    default='model',
		    type=str,
		    help='Path to the output PyTorch model directory.',
		)
		parser.add_argument('--save_model', action='store_true', help='Save model to local')
		parser.add_argument('--push_to_hub', action='store_true', help='Push model and image preprocessor to the hub')

		UpperCamelCase     					=     parser.parse_args()
		convert_convnextva_checkpoint(
		    args.checkpoint_url, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub
		)





"""simple docstring"""






import numpy as np

UpperCamelCase     					=     [
    ['a', 'b', 'c', 'd', 'e'],
    ['f', 'g', 'h', 'i', 'k'],
    ['l', 'm', 'n', 'o', 'p'],
    ['q', 'r', 's', 't', 'u'],
    ['v', 'w', 'x', 'y', 'z'],
]
class   UpperCAmelCase__				:


	"""simple docstring"""







	def __init__(			self )    ->	None:
							a_							:			List[Any]     		=					np.array(_SCREAMING_SNAKE_CASE )







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE )    ->	np.ndarray:
							a_		,					a_							:			List[str]     		=					np.where(letter == self.SQUARE )
							a_							:			Union[str, Any]     		=					np.concatenate([indexa + 1, indexa + 1] )
							return indexes







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE )    ->	str:
							return self.SQUARE[indexa - 1, indexa - 1]







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE )    ->	str:
							a_							:			List[str]     		=					message.lower()
							a_							:			Union[str, Any]     		=					message.replace("j"       ,     "i" )

							a_							:			Tuple     		=					""
							for letter_index in range(len(_SCREAMING_SNAKE_CASE ) ):
													if message[letter_index] != " ":
																			a_							:			Dict     		=					self.letter_to_numbers(message[letter_index] )
																			a_							:			str     		=					encoded_message + str(numbers[0] ) + str(numbers[1] )
													elif message[letter_index] == " ":
																			a_							:			Any     		=					encoded_message + " "

							return encoded_message







	def       A    (			self       ,     _SCREAMING_SNAKE_CASE )    ->	str:
							a_							:			Dict     		=					message.replace(" "       ,     "  " )
							a_							:			str     		=					""
							for numbers_index in range(int(len(_SCREAMING_SNAKE_CASE ) / 2 ) ):
													if message[numbers_index * 2] != " ":
																			a_							:			str     		=					message[numbers_index * 2]
																			a_							:			str     		=					message[numbers_index * 2 + 1]

																			a_							:			Optional[Any]     		=					self.numbers_to_letter(int(_SCREAMING_SNAKE_CASE )       ,     int(_SCREAMING_SNAKE_CASE ) )
																			a_							:			Optional[Any]     		=					decoded_message + letter
													elif message[numbers_index * 2] == " ":
																			a_							:			str     		=					decoded_message + " "

							return decoded_message




