



import warnings
from typing import List, Optional, Union

import numpy as np
import PIL
import torch
from PIL import Image

from .configuration_utils import ConfigMixin, register_to_config
from .utils import CONFIG_NAME, PIL_INTERPOLATION, deprecate





class 							lowerCAmelCase_		(		lowercase_     ):
		SCREAMING_SNAKE_CASE_       :			Tuple					       =	CONFIG_NAME







		@register_to_config
		def __init__(    self  :   Optional[Any]       ,		UpperCAmelCase_  :   bool = True       ,		UpperCAmelCase_  :   int = 8       ,		UpperCAmelCase_  :   str = "lanczos"       ,		UpperCAmelCase_  :   bool = True       ,		UpperCAmelCase_  :   bool = False       ,		)       ->		Optional[Any]:


						'''simple docstring'''







						super().__init__()







		@staticmethod
		def 					a_  (    UpperCAmelCase_  :   np.ndarray					)       ->		PIL.Image.Image:


						'''simple docstring'''







						if images.ndim == 3:
										_UpperCAmelCase						:  Optional[int]     					=	images[None, ...]
						_UpperCAmelCase						:  List[Any]     					=	(images * 255).round().astype('''uint8'''					)
						if images.shape[-1] == 1:
										# special case for grayscale (single channel) images
										_UpperCAmelCase						:  Union[str, Any]     					=	[Image.fromarray(image.squeeze()       ,		mode='''L'''					) for image in images]
						else:
										_UpperCAmelCase						:  Optional[Any]     					=	[Image.fromarray(UpperCAmelCase_					) for image in images]

						return pil_images







		@staticmethod
		def 					a_  (    UpperCAmelCase_  :   Union[List[PIL.Image.Image], PIL.Image.Image]					)       ->		np.ndarray:


						'''simple docstring'''







						if not isinstance(UpperCAmelCase_       ,		UpperCAmelCase_					):
										_UpperCAmelCase						:  Any     					=	[images]
						_UpperCAmelCase						:  Any     					=	[np.array(UpperCAmelCase_					).astype(np.floataa					) / 255.0 for image in images]
						_UpperCAmelCase						:  Any     					=	np.stack(UpperCAmelCase_       ,		axis=0					)

						return images







		@staticmethod
		def 					a_  (    UpperCAmelCase_  :   np.ndarray					)       ->		torch.FloatTensor:


						'''simple docstring'''







						if images.ndim == 3:
										_UpperCAmelCase						:  Optional[Any]     					=	images[..., None]

						_UpperCAmelCase						:  Optional[Any]     					=	torch.from_numpy(images.transpose(0       ,		3       ,		1       ,		2					)					)
						return images







		@staticmethod
		def 					a_  (    UpperCAmelCase_  :   torch.FloatTensor					)       ->		np.ndarray:


						'''simple docstring'''







						_UpperCAmelCase						:  Optional[Any]     					=	images.cpu().permute(0       ,		2       ,		3       ,		1					).float().numpy()
						return images







		@staticmethod
		def 					a_  (    UpperCAmelCase_  :   int					)       ->		int:


						'''simple docstring'''







						return 2.0 * images - 1.0







		@staticmethod
		def 					a_  (    UpperCAmelCase_  :   Dict					)       ->		Optional[Any]:


						'''simple docstring'''







						return (images / 2 + 0.5).clamp(0       ,		1					)







		@staticmethod
		def 					a_  (    UpperCAmelCase_  :   PIL.Image.Image					)       ->		PIL.Image.Image:


						'''simple docstring'''







						_UpperCAmelCase						:  Optional[int]     					=	image.convert('''RGB'''					)
						return image







		def 					a_  (    self  :   Tuple       ,		UpperCAmelCase_  :   PIL.Image.Image       ,		UpperCAmelCase_  :   Optional[int] = None       ,		UpperCAmelCase_  :   Optional[int] = None       ,		)       ->		PIL.Image.Image:


						'''simple docstring'''







						if height is None:
										_UpperCAmelCase						:  int     					=	image.height
						if width is None:
										_UpperCAmelCase						:  Tuple     					=	image.width

						_UpperCAmelCase					, _UpperCAmelCase						:  Any     					=	(
						    x - x % self.config.vae_scale_factor for x in (width, height)
						)  # resize to integer multiple of vae_scale_factor
						_UpperCAmelCase						:  Optional[int]     					=	image.resize((width, height)       ,		resample=PIL_INTERPOLATION[self.config.resample]					)
						return image







		def 					a_  (    self  :   List[Any]       ,		UpperCAmelCase_  :   Union[torch.FloatTensor, PIL.Image.Image, np.ndarray]       ,		UpperCAmelCase_  :   Optional[int] = None       ,		UpperCAmelCase_  :   Optional[int] = None       ,		)       ->		torch.Tensor:


						'''simple docstring'''







						_UpperCAmelCase						:  Dict     					=	(PIL.Image.Image, np.ndarray, torch.Tensor)
						if isinstance(UpperCAmelCase_       ,		UpperCAmelCase_					):
										_UpperCAmelCase						:  Optional[int]     					=	[image]
						elif not (isinstance(UpperCAmelCase_       ,		UpperCAmelCase_					) and all(isinstance(UpperCAmelCase_       ,		UpperCAmelCase_					) for i in image					)):
										raise ValueError(
										    F'''Input is in incorrect format: {[type(UpperCAmelCase_					) for i in image]}. Currently, we only support {', '.join(UpperCAmelCase_					)}'''					)

						if isinstance(image[0]       ,		PIL.Image.Image					):
										if self.config.do_convert_rgb:
														_UpperCAmelCase						:  Optional[Any]     					=	[self.convert_to_rgb(UpperCAmelCase_					) for i in image]
										if self.config.do_resize:
														_UpperCAmelCase						:  Optional[Any]     					=	[self.resize(UpperCAmelCase_       ,		UpperCAmelCase_       ,		UpperCAmelCase_					) for i in image]
										_UpperCAmelCase						:  Tuple     					=	self.pil_to_numpy(UpperCAmelCase_					)  # to np
										_UpperCAmelCase						:  List[Any]     					=	self.numpy_to_pt(UpperCAmelCase_					)  # to pt

						elif isinstance(image[0]       ,		np.ndarray					):
										_UpperCAmelCase						:  List[str]     					=	np.concatenate(UpperCAmelCase_       ,		axis=0					) if image[0].ndim == 4 else np.stack(UpperCAmelCase_       ,		axis=0					)
										_UpperCAmelCase						:  int     					=	self.numpy_to_pt(UpperCAmelCase_					)
										_UpperCAmelCase					, _UpperCAmelCase					, _UpperCAmelCase					, _UpperCAmelCase						:  int     					=	image.shape
										if self.config.do_resize and (
										    height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
										):
														raise ValueError(
														    F'''Currently we only support resizing for PIL image - please resize your numpy array to be divisible by {self.config.vae_scale_factor}'''
														    F'''currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'''					)

						elif isinstance(image[0]       ,		torch.Tensor					):
										_UpperCAmelCase						:  str     					=	torch.cat(UpperCAmelCase_       ,		axis=0					) if image[0].ndim == 4 else torch.stack(UpperCAmelCase_       ,		axis=0					)
										_UpperCAmelCase					, _UpperCAmelCase					, _UpperCAmelCase					, _UpperCAmelCase						:  str     					=	image.shape

										# don't need any preprocess if the image is latents
										if channel == 4:
														return image

										if self.config.do_resize and (
										    height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
										):
														raise ValueError(
														    F'''Currently we only support resizing for PIL image - please resize your pytorch tensor to be divisible by {self.config.vae_scale_factor}'''
														    F'''currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'''					)

        # expected range [0,1], normalize to [-1,1]
						_UpperCAmelCase						:  Union[str, Any]     					=	self.config.do_normalize
						if image.min() < 0:
										warnings.warn(
										    '''Passing `image` as torch tensor with value range in [-1,1] is deprecated. The expected value range for image tensor is [0,1] '''
										    F'''when passing as pytorch tensor or numpy Array. You passed `image` with value range [{image.min()},{image.max()}]'''       ,		UpperCAmelCase_       ,		)
										_UpperCAmelCase						:  Union[str, Any]     					=	False

						if do_normalize:
										_UpperCAmelCase						:  List[str]     					=	self.normalize(UpperCAmelCase_					)

						return image







		def 					a_  (    self  :   List[str]       ,		UpperCAmelCase_  :   torch.FloatTensor       ,		UpperCAmelCase_  :   str = "pil"       ,		UpperCAmelCase_  :   Optional[List[bool]] = None       ,		)       ->		Optional[int]:


						'''simple docstring'''







						if not isinstance(UpperCAmelCase_       ,		torch.Tensor					):
										raise ValueError(
										    F'''Input for postprocessing is in incorrect format: {type(UpperCAmelCase_					)}. We only support pytorch tensor'''					)
						if output_type not in ["latent", "pt", "np", "pil"]:
										_UpperCAmelCase						:  Tuple     					=	(
										    F'''the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '''
										    '''`pil`, `np`, `pt`, `latent`'''
										)
										deprecate('''Unsupported output_type'''       ,		'''1.0.0'''       ,		UpperCAmelCase_       ,		standard_warn=UpperCAmelCase_					)
										_UpperCAmelCase						:  Tuple     					=	'''np'''

						if output_type == "latent":
										return image

						if do_denormalize is None:
										_UpperCAmelCase						:  Dict     					=	[self.config.do_normalize] * image.shape[0]

						_UpperCAmelCase						:  Any     					=	torch.stack(
						    [self.denormalize(image[i]					) if do_denormalize[i] else image[i] for i in range(image.shape[0]					)]					)

						if output_type == "pt":
										return image

						_UpperCAmelCase						:  Any     					=	self.pt_to_numpy(UpperCAmelCase_					)

						if output_type == "np":
										return image

						if output_type == "pil":
										return self.numpy_to_pil(UpperCAmelCase_					)





class 							lowerCAmelCase_		(		lowercase_     ):
		SCREAMING_SNAKE_CASE_       :			int					       =	CONFIG_NAME







		@register_to_config
		def __init__(    self  :   Dict       ,		UpperCAmelCase_  :   bool = True       ,		UpperCAmelCase_  :   int = 8       ,		UpperCAmelCase_  :   str = "lanczos"       ,		UpperCAmelCase_  :   bool = True       ,		)       ->		Optional[Any]:


						'''simple docstring'''







						super().__init__()







		@staticmethod
		def 					a_  (    UpperCAmelCase_  :   List[Any]					)       ->		List[str]:


						'''simple docstring'''







						if images.ndim == 3:
										_UpperCAmelCase						:  Dict     					=	images[None, ...]
						_UpperCAmelCase						:  str     					=	(images * 255).round().astype('''uint8'''					)
						if images.shape[-1] == 1:
										# special case for grayscale (single channel) images
										_UpperCAmelCase						:  Union[str, Any]     					=	[Image.fromarray(image.squeeze()       ,		mode='''L'''					) for image in images]
						else:
										_UpperCAmelCase						:  Optional[int]     					=	[Image.fromarray(image[:, :, :3]					) for image in images]

						return pil_images







		@staticmethod
		def 					a_  (    UpperCAmelCase_  :   Tuple					)       ->		Dict:


						'''simple docstring'''







						return image[:, :, 1] * 2**8 + image[:, :, 2]







		def 					a_  (    self  :   List[Any]       ,		UpperCAmelCase_  :   int					)       ->		Optional[Any]:


						'''simple docstring'''







						if images.ndim == 3:
										_UpperCAmelCase						:  int     					=	images[None, ...]
						_UpperCAmelCase						:  str     					=	images[:, :, :, 3:]
						if images.shape[-1] == 6:
										_UpperCAmelCase						:  Tuple     					=	(images_depth * 255).round().astype('''uint8'''					)
										_UpperCAmelCase						:  List[str]     					=	[
										    Image.fromarray(self.rgblike_to_depthmap(UpperCAmelCase_					)       ,		mode='''I;16'''					) for image_depth in images_depth
										]
						elif images.shape[-1] == 4:
										_UpperCAmelCase						:  List[str]     					=	(images_depth * 65_535.0).astype(np.uintaa					)
										_UpperCAmelCase						:  Tuple     					=	[Image.fromarray(UpperCAmelCase_       ,		mode='''I;16'''					) for image_depth in images_depth]
						else:
										raise Exception('''Not supported'''					)

						return pil_images







		def 					a_  (    self  :   Dict       ,		UpperCAmelCase_  :   torch.FloatTensor       ,		UpperCAmelCase_  :   str = "pil"       ,		UpperCAmelCase_  :   Optional[List[bool]] = None       ,		)       ->		Any:


						'''simple docstring'''







						if not isinstance(UpperCAmelCase_       ,		torch.Tensor					):
										raise ValueError(
										    F'''Input for postprocessing is in incorrect format: {type(UpperCAmelCase_					)}. We only support pytorch tensor'''					)
						if output_type not in ["latent", "pt", "np", "pil"]:
										_UpperCAmelCase						:  Optional[int]     					=	(
										    F'''the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '''
										    '''`pil`, `np`, `pt`, `latent`'''
										)
										deprecate('''Unsupported output_type'''       ,		'''1.0.0'''       ,		UpperCAmelCase_       ,		standard_warn=UpperCAmelCase_					)
										_UpperCAmelCase						:  Union[str, Any]     					=	'''np'''

						if do_denormalize is None:
										_UpperCAmelCase						:  List[str]     					=	[self.config.do_normalize] * image.shape[0]

						_UpperCAmelCase						:  int     					=	torch.stack(
						    [self.denormalize(image[i]					) if do_denormalize[i] else image[i] for i in range(image.shape[0]					)]					)

						_UpperCAmelCase						:  str     					=	self.pt_to_numpy(UpperCAmelCase_					)

						if output_type == "np":
										if image.shape[-1] == 6:
														_UpperCAmelCase						:  int     					=	np.stack([self.rgblike_to_depthmap(im[:, :, 3:]					) for im in image]       ,		axis=0					)
										else:
														_UpperCAmelCase						:  Optional[Any]     					=	image[:, :, :, 3:]
										return image[:, :, :, :3], image_depth

						if output_type == "pil":
										return self.numpy_to_pil(UpperCAmelCase_					), self.numpy_to_depth(UpperCAmelCase_					)
						else:
										raise Exception(F'''This type {output_type} is not supported'''					)





import argparse
import json
from pathlib import Path

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

from transformers import ConvNextConfig, ConvNextForImageClassification, ConvNextImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
UpperCAmelCase__			:   Optional[Any]      			=    logging.get_logger(__name__)


def 	_A	(   _UpperCamelCase			):
				_UpperCAmelCase						:  Optional[Any]     					=	ConvNextConfig()

				if "tiny" in checkpoint_url:
								_UpperCAmelCase						:  Any     					=	[3, 3, 9, 3]
								_UpperCAmelCase						:  int     					=	[96, 192, 384, 768]
				if "small" in checkpoint_url:
								_UpperCAmelCase						:  str     					=	[3, 3, 27, 3]
								_UpperCAmelCase						:  List[Any]     					=	[96, 192, 384, 768]
				if "base" in checkpoint_url:
								_UpperCAmelCase						:  Dict     					=	[3, 3, 27, 3]
								_UpperCAmelCase						:  Tuple     					=	[128, 256, 512, 1_024]
				if "large" in checkpoint_url:
								_UpperCAmelCase						:  Optional[int]     					=	[3, 3, 27, 3]
								_UpperCAmelCase						:  Optional[int]     					=	[192, 384, 768, 1_536]
				if "xlarge" in checkpoint_url:
								_UpperCAmelCase						:  Tuple     					=	[3, 3, 27, 3]
								_UpperCAmelCase						:  int     					=	[256, 512, 1_024, 2_048]

				if "1k" in checkpoint_url:
								_UpperCAmelCase						:  int     					=	1_000
								_UpperCAmelCase						:  Union[str, Any]     					=	'''imagenet-1k-id2label.json'''
								_UpperCAmelCase						:  Any     					=	(1, 1_000)
				else:
								_UpperCAmelCase						:  Union[str, Any]     					=	21_841
								_UpperCAmelCase						:  int     					=	'''imagenet-22k-id2label.json'''
								_UpperCAmelCase						:  List[str]     					=	(1, 21_841)

				_UpperCAmelCase						:  List[str]     					=	'''huggingface/label-files'''
				_UpperCAmelCase						:  Any     					=	num_labels
				_UpperCAmelCase						:  str     					=	json.load(open(hf_hub_download(_UpperCamelCase      ,					_UpperCamelCase      ,					repo_type='''dataset'''			)      ,					'''r'''			)			)
				_UpperCAmelCase						:  List[Any]     					=	{int(_UpperCamelCase			): v for k, v in idalabel.items()}
				if "1k" not in checkpoint_url:
								# this dataset contains 21843 labels but the model only has 21841
								# we delete the classes as mentioned in https://github.com/google-research/big_transfer/issues/18
								del idalabel[9_205]
								del idalabel[15_027]
				_UpperCAmelCase						:  List[str]     					=	idalabel
				_UpperCAmelCase						:  Any     					=	{v: k for k, v in idalabel.items()}
				_UpperCAmelCase						:  Union[str, Any]     					=	hidden_sizes
				_UpperCAmelCase						:  int     					=	depths

				return config, expected_shape


def 	_A	(   _UpperCamelCase			):
				if "downsample_layers.0.0" in name:
								_UpperCAmelCase						:  Any     					=	name.replace('''downsample_layers.0.0'''      ,					'''embeddings.patch_embeddings'''			)
				if "downsample_layers.0.1" in name:
								_UpperCAmelCase						:  int     					=	name.replace('''downsample_layers.0.1'''      ,					'''embeddings.norm'''			)  # we rename to layernorm later on
				if "downsample_layers.1.0" in name:
								_UpperCAmelCase						:  Optional[Any]     					=	name.replace('''downsample_layers.1.0'''      ,					'''stages.1.downsampling_layer.0'''			)
				if "downsample_layers.1.1" in name:
								_UpperCAmelCase						:  Any     					=	name.replace('''downsample_layers.1.1'''      ,					'''stages.1.downsampling_layer.1'''			)
				if "downsample_layers.2.0" in name:
								_UpperCAmelCase						:  int     					=	name.replace('''downsample_layers.2.0'''      ,					'''stages.2.downsampling_layer.0'''			)
				if "downsample_layers.2.1" in name:
								_UpperCAmelCase						:  List[Any]     					=	name.replace('''downsample_layers.2.1'''      ,					'''stages.2.downsampling_layer.1'''			)
				if "downsample_layers.3.0" in name:
								_UpperCAmelCase						:  Union[str, Any]     					=	name.replace('''downsample_layers.3.0'''      ,					'''stages.3.downsampling_layer.0'''			)
				if "downsample_layers.3.1" in name:
								_UpperCAmelCase						:  Union[str, 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.
								_UpperCAmelCase						:  Any     					=	name[: len('''stages.0'''			)] + '''.layers''' + name[len('''stages.0'''			) :]
				if "stages" in name:
								_UpperCAmelCase						:  Dict     					=	name.replace('''stages'''      ,					'''encoder.stages'''			)
				if "norm" in name:
								_UpperCAmelCase						:  int     					=	name.replace('''norm'''      ,					'''layernorm'''			)
				if "gamma" in name:
								_UpperCAmelCase						:  str     					=	name.replace('''gamma'''      ,					'''layer_scale_parameter'''			)
				if "head" in name:
								_UpperCAmelCase						:  Optional[Any]     					=	name.replace('''head'''      ,					'''classifier'''			)

				return name


def 	_A	(   ):
				_UpperCAmelCase						:  Tuple     					=	'''http://images.cocodataset.org/val2017/000000039769.jpg'''
				_UpperCAmelCase						:  Union[str, Any]     					=	Image.open(requests.get(_UpperCamelCase      ,					stream=_UpperCamelCase			).raw			)
				return im


@torch.no_grad()
def 	_A	(   _UpperCamelCase      ,					_UpperCamelCase			):
				_UpperCAmelCase					, _UpperCAmelCase						:  Union[str, Any]     					=	get_convnext_config(_UpperCamelCase			)
				# load original state_dict from URL
				_UpperCAmelCase						:  List[Any]     					=	torch.hub.load_state_dict_from_url(_UpperCamelCase			)['''model''']
				# rename keys
				for key in state_dict.copy().keys():
								_UpperCAmelCase						:  str     					=	state_dict.pop(_UpperCamelCase			)
								_UpperCAmelCase						:  int     					=	val
				# add prefix to all keys expect classifier head
				for key in state_dict.copy().keys():
								_UpperCAmelCase						:  Any     					=	state_dict.pop(_UpperCamelCase			)
								if not key.startswith('''classifier'''			):
												_UpperCAmelCase						:  Dict     					=	'''convnext.''' + key
								_UpperCAmelCase						:  List[Any]     					=	val

				# load HuggingFace model
				_UpperCAmelCase						:  Optional[int]     					=	ConvNextForImageClassification(_UpperCamelCase			)
				model.load_state_dict(_UpperCamelCase			)
				model.eval()

				# Check outputs on an image, prepared by ConvNextImageProcessor
				_UpperCAmelCase						:  Optional[Any]     					=	224 if '''224''' in checkpoint_url else 384
				_UpperCAmelCase						:  int     					=	ConvNextImageProcessor(size=_UpperCamelCase			)
				_UpperCAmelCase						:  Union[str, Any]     					=	image_processor(images=prepare_img()      ,					return_tensors='''pt'''			).pixel_values

				_UpperCAmelCase						:  Any     					=	model(_UpperCamelCase			).logits

				# note: the logits below were obtained without center cropping
				if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth":
								_UpperCAmelCase						:  Optional[int]     					=	torch.tensor([-0.1_210, -0.6_605, 0.1_918]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_small_1k_224_ema.pth":
								_UpperCAmelCase						:  Optional[Any]     					=	torch.tensor([-0.4_473, -0.1_847, -0.6_365]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_224_ema.pth":
								_UpperCAmelCase						:  List[str]     					=	torch.tensor([0.4_525, 0.7_539, 0.0_308]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_384.pth":
								_UpperCAmelCase						:  Any     					=	torch.tensor([0.3_561, 0.6_350, -0.0_384]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_224_ema.pth":
								_UpperCAmelCase						:  str     					=	torch.tensor([0.4_174, -0.0_989, 0.1_489]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_384.pth":
								_UpperCAmelCase						:  Tuple     					=	torch.tensor([0.2_513, -0.1_349, -0.1_613]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_224.pth":
								_UpperCAmelCase						:  Dict     					=	torch.tensor([1.2_980, 0.3_631, -0.1_198]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_224.pth":
								_UpperCAmelCase						:  Optional[int]     					=	torch.tensor([1.2_963, 0.1_227, 0.1_723]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_224.pth":
								_UpperCAmelCase						:  str     					=	torch.tensor([1.7_956, 0.8_390, 0.2_820]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_224.pth":
								_UpperCAmelCase						:  List[str]     					=	torch.tensor([-0.2_822, -0.0_502, -0.0_878]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_384.pth":
								_UpperCAmelCase						:  List[Any]     					=	torch.tensor([-0.5_672, -0.0_730, -0.4_348]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_224.pth":
								_UpperCAmelCase						:  str     					=	torch.tensor([0.2_681, 0.2_365, 0.6_246]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_384.pth":
								_UpperCAmelCase						:  List[str]     					=	torch.tensor([-0.2_642, 0.3_931, 0.5_116]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_224_ema.pth":
								_UpperCAmelCase						:  Tuple     					=	torch.tensor([-0.6_677, -0.1_873, -0.8_379]			)
				elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_384_ema.pth":
								_UpperCAmelCase						:  Any     					=	torch.tensor([-0.7_749, -0.2_967, -0.6_444]			)
				else:
								raise ValueError(F'''Unknown URL: {checkpoint_url}'''			)

				assert torch.allclose(logits[0, :3]      ,					_UpperCamelCase      ,					atol=1e-3			)
				assert logits.shape == expected_shape

				Path(_UpperCamelCase			).mkdir(exist_ok=_UpperCamelCase			)
				print(F'''Saving model to {pytorch_dump_folder_path}'''			)
				model.save_pretrained(_UpperCamelCase			)
				print(F'''Saving image processor to {pytorch_dump_folder_path}'''			)
				image_processor.save_pretrained(_UpperCamelCase			)

				print('''Pushing model to the hub...'''			)
				_UpperCAmelCase						:  Union[str, Any]     					=	'''convnext'''
				if "tiny" in checkpoint_url:
								model_name += "-tiny"
				elif "small" in checkpoint_url:
								model_name += "-small"
				elif "base" in checkpoint_url:
								model_name += "-base"
				elif "xlarge" in checkpoint_url:
								model_name += "-xlarge"
				elif "large" in checkpoint_url:
								model_name += "-large"
				if "224" in checkpoint_url:
								model_name += "-224"
				elif "384" in checkpoint_url:
								model_name += "-384"
				if "22k" in checkpoint_url and "1k" not in checkpoint_url:
								model_name += "-22k"
				if "22k" in checkpoint_url and "1k" in checkpoint_url:
								model_name += "-22k-1k"

				model.push_to_hub(
				    repo_path_or_name=Path(_UpperCamelCase      ,					_UpperCamelCase			)      ,					organization='''nielsr'''      ,					commit_message='''Add model'''      ,					)


if __name__ == "__main__":
					UpperCAmelCase__			:   List[Any]      			=    argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '--checkpoint_url',
					    default='https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth',
					    type=str,
					    help='URL of the original ConvNeXT checkpoint you\'d like to convert.',
					)
					parser.add_argument(
					    '--pytorch_dump_folder_path',
					    default=None,
					    type=str,
					    required=True,
					    help='Path to the output PyTorch model directory.',
					)

					UpperCAmelCase__			:   int      			=    parser.parse_args()
					convert_convnext_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
