

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()
SCREAMING_SNAKE_CASE_						=					logging.get_logger(__name__)

def 							__SCREAMING_SNAKE_CASE							( lowerCAmelCase:     Optional[Any]       )      ->				List[str]:
				_UpperCAmelCase				:						Union[str, Any]       						=			ConvNextConfig()

				if "tiny" in checkpoint_url:
								_UpperCAmelCase				:						List[Any]       						=			[3, 3, 9, 3]
								_UpperCAmelCase				:						Optional[int]       						=			[96, 192, 384, 768]
				if "small" in checkpoint_url:
								_UpperCAmelCase				:						Optional[int]       						=			[3, 3, 27, 3]
								_UpperCAmelCase				:						Dict       						=			[96, 192, 384, 768]
				if "base" in checkpoint_url:
								_UpperCAmelCase				:						Tuple       						=			[3, 3, 27, 3]
								_UpperCAmelCase				:						Tuple       						=			[128, 256, 512, 1024]
				if "large" in checkpoint_url:
								_UpperCAmelCase				:						Optional[Any]       						=			[3, 3, 27, 3]
								_UpperCAmelCase				:						Optional[int]       						=			[192, 384, 768, 1536]
				if "xlarge" in checkpoint_url:
								_UpperCAmelCase				:						Union[str, Any]       						=			[3, 3, 27, 3]
								_UpperCAmelCase				:						str       						=			[256, 512, 1024, 2048]

				if "1k" in checkpoint_url:
								_UpperCAmelCase				:						Dict       						=			1000
								_UpperCAmelCase				:						Union[str, Any]       						=			"imagenet-1k-id2label.json"
								_UpperCAmelCase				:						List[str]       						=			(1, 1000)
				else:
								_UpperCAmelCase				:						Tuple       						=			2_1841
								_UpperCAmelCase				:						Tuple       						=			"imagenet-22k-id2label.json"
								_UpperCAmelCase				:						Optional[Any]       						=			(1, 2_1841)

				_UpperCAmelCase				:						Dict       						=			"huggingface/label-files"
				_UpperCAmelCase				:						Tuple       						=			num_labels
				_UpperCAmelCase				:						List[Any]       						=			json.load(open(hf_hub_download(lowerCAmelCase     ,					lowerCAmelCase     ,					repo_type="dataset"       )     ,					"r"       )       )
				_UpperCAmelCase				:						Optional[Any]       						=			{int(lowerCAmelCase       ): 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[9205]
								del idalabel[1_5027]
				_UpperCAmelCase				:						Tuple       						=			idalabel
				_UpperCAmelCase				:						int       						=			{v: k for k, v in idalabel.items()}
				_UpperCAmelCase				:						str       						=			hidden_sizes
				_UpperCAmelCase				:						int       						=			depths

				return config, expected_shape

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

				return name

def 							__SCREAMING_SNAKE_CASE							( )      ->				Union[str, Any]:
				_UpperCAmelCase				:						Union[str, Any]       						=			"http://images.cocodataset.org/val2017/000000039769.jpg"
				_UpperCAmelCase				:						int       						=			Image.open(requests.get(lowerCAmelCase     ,					stream=lowerCAmelCase       ).raw       )
				return im

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

				# load HuggingFace model
				_UpperCAmelCase				:						List[str]       						=			ConvNextForImageClassification(lowerCAmelCase       )
				model.load_state_dict(lowerCAmelCase       )
				model.eval()

				# Check outputs on an image, prepared by ConvNextImageProcessor
				_UpperCAmelCase				:						Tuple       						=			224 if "224" in checkpoint_url else 384
				_UpperCAmelCase				:						Dict       						=			ConvNextImageProcessor(size=lowerCAmelCase       )
				_UpperCAmelCase				:						Optional[Any]       						=			image_processor(images=prepare_img()     ,					return_tensors="pt"       ).pixel_values

				_UpperCAmelCase				:						List[str]       						=			model(lowerCAmelCase       ).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				:						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				:						Dict       						=			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				:						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				:						str       						=			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				:						Optional[int]       						=			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				:						Tuple       						=			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				:						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				:						int       						=			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				:						Optional[Any]       						=			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				:						Optional[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				:						Tuple       						=			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[Any]       						=			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				:						List[str]       						=			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				:						Dict       						=			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]     ,					lowerCAmelCase     ,					atol=1E-3       )
				assert logits.shape == expected_shape

				Path(lowerCAmelCase       ).mkdir(exist_ok=lowerCAmelCase       )
				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       )

				print("Pushing model to the hub..."       )
				_UpperCAmelCase				:						Optional[int]       						=			"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(lowerCAmelCase     ,					lowerCAmelCase       )     ,					organization="nielsr"     ,					commit_message="Add model"     ,					)


if __name__ == "__main__":
					SCREAMING_SNAKE_CASE_						=					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.',
					)

					SCREAMING_SNAKE_CASE_						=					parser.parse_args()
					convert_convnext_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)





from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    get_resize_output_image_size,
    normalize,
    pad,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging
from ...utils.import_utils import is_vision_available


SCREAMING_SNAKE_CASE_						=					logging.get_logger(__name__)


if is_vision_available():
					import PIL

class  a     (		UpperCAmelCase ):
						_lowercase			  =	["pixel_values"]


						def __init__(				self  ,    A_ = True  ,    A_ = None  ,    A_ = PILImageResampling.BILINEAR  ,    A_ = True  ,    A_ = False  ,    A_ = True  ,    A_ = True  ,    A_ = 1 / 255  ,    A_ = True  ,    A_ = None  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										super().__init__(**A_		)

										_UpperCAmelCase				:						str       						=			size if size is not None else {"height": 2560, "width": 1920}
										if isinstance(A_  ,    (tuple, list)		):
														# The previous feature extractor size parameter was in (width, height) format
														_UpperCAmelCase				:						List[Any]       						=			size[::-1]
										_UpperCAmelCase				:						Dict       						=			get_size_dict(A_		)

										_UpperCAmelCase				:						int       						=			do_resize
										_UpperCAmelCase				:						Dict       						=			size
										_UpperCAmelCase				:						List[Any]       						=			resample
										_UpperCAmelCase				:						Union[str, Any]       						=			do_thumbnail
										_UpperCAmelCase				:						Optional[int]       						=			do_align_long_axis
										_UpperCAmelCase				:						Optional[Any]       						=			do_pad
										_UpperCAmelCase				:						int       						=			do_rescale
										_UpperCAmelCase				:						List[Any]       						=			rescale_factor
										_UpperCAmelCase				:						Union[str, Any]       						=			do_normalize
										_UpperCAmelCase				:						Any       						=			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
										_UpperCAmelCase				:						Dict       						=			image_std if image_std is not None else IMAGENET_STANDARD_STD


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = None		):







										'''simple docstring'''


										_UpperCAmelCase						,							_UpperCAmelCase				:						List[str]       						=			get_image_size(A_		)
										_UpperCAmelCase						,							_UpperCAmelCase				:						Any       						=			size["height"], size["width"]

										if (output_width < output_height and input_width > input_height) or (
										    output_width > output_height and input_width < input_height
										):
														_UpperCAmelCase				:						Optional[int]       						=			np.rotaa(A_  ,    3		)

										if data_format is not None:
														_UpperCAmelCase				:						List[str]       						=			to_channel_dimension_format(A_  ,    A_		)

										return image


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = False  ,    A_ = None  ,    ):







										'''simple docstring'''


										_UpperCAmelCase						,							_UpperCAmelCase				:						Optional[Any]       						=			size["height"], size["width"]
										_UpperCAmelCase						,							_UpperCAmelCase				:						List[Any]       						=			get_image_size(A_		)

										_UpperCAmelCase				:						Optional[Any]       						=			output_width - input_width
										_UpperCAmelCase				:						Any       						=			output_height - input_height

										if random_padding:
														_UpperCAmelCase				:						List[str]       						=			np.random.randint(low=0  ,    high=delta_height + 1		)
														_UpperCAmelCase				:						Optional[int]       						=			np.random.randint(low=0  ,    high=delta_width + 1		)
										else:
														_UpperCAmelCase				:						Union[str, Any]       						=			delta_height // 2
														_UpperCAmelCase				:						str       						=			delta_width // 2

										_UpperCAmelCase				:						Optional[Any]       						=			delta_height - pad_top
										_UpperCAmelCase				:						List[Any]       						=			delta_width - pad_left

										_UpperCAmelCase				:						Optional[Any]       						=			((pad_top, pad_bottom), (pad_left, pad_right))
										return pad(A_  ,    A_  ,    data_format=A_		)


						def 				_UpperCAmelCase (				self  ,    *A_  ,    **A_		):







										'''simple docstring'''


										logger.info("pad is deprecated and will be removed in version 4.27. Please use pad_image instead."		)
										return self.pad_image(*A_  ,    **A_		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = PILImageResampling.BICUBIC  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										_UpperCAmelCase						,							_UpperCAmelCase				:						Union[str, Any]       						=			get_image_size(A_		)
										_UpperCAmelCase						,							_UpperCAmelCase				:						Union[str, Any]       						=			size["height"], size["width"]

										# We always resize to the smallest of either the input or output size.
										_UpperCAmelCase				:						Dict       						=			min(A_  ,    A_		)
										_UpperCAmelCase				:						Tuple       						=			min(A_  ,    A_		)

										if height == input_height and width == input_width:
														return image

										if input_height > input_width:
														_UpperCAmelCase				:						Any       						=			int(input_width * height / input_height		)
										elif input_width > input_height:
														_UpperCAmelCase				:						Any       						=			int(input_height * width / input_width		)

										return resize(
										    A_  ,    size=(height, width)  ,    resample=A_  ,    reducing_gap=2.0  ,    data_format=A_  ,    **A_		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = PILImageResampling.BICUBIC  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						Any       						=			get_size_dict(A_		)
										_UpperCAmelCase				:						List[str]       						=			min(size["height"]  ,    size["width"]		)
										_UpperCAmelCase				:						Optional[Any]       						=			get_resize_output_image_size(A_  ,    size=A_  ,    default_to_square=A_		)
										_UpperCAmelCase				:						str       						=			resize(A_  ,    size=A_  ,    resample=A_  ,    data_format=A_  ,    **A_		)
										return resized_image


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										return rescale(A_  ,    scale=A_  ,    data_format=A_  ,    **A_		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										return normalize(A_  ,    mean=A_  ,    std=A_  ,    data_format=A_  ,    **A_		)





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = False  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = ChannelDimension.FIRST  ,    **A_  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						str       						=			do_resize if do_resize is not None else self.do_resize
										_UpperCAmelCase				:						str       						=			size if size is not None else self.size
										if isinstance(A_  ,    (tuple, list)		):
														# Previous feature extractor had size in (width, height) format
														_UpperCAmelCase				:						List[Any]       						=			size[::-1]
										_UpperCAmelCase				:						Union[str, Any]       						=			get_size_dict(A_		)
										_UpperCAmelCase				:						Dict       						=			resample if resample is not None else self.resample
										_UpperCAmelCase				:						str       						=			do_thumbnail if do_thumbnail is not None else self.do_thumbnail
										_UpperCAmelCase				:						Optional[Any]       						=			do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
										_UpperCAmelCase				:						List[str]       						=			do_pad if do_pad is not None else self.do_pad
										_UpperCAmelCase				:						Optional[Any]       						=			do_rescale if do_rescale is not None else self.do_rescale
										_UpperCAmelCase				:						int       						=			rescale_factor if rescale_factor is not None else self.rescale_factor
										_UpperCAmelCase				:						List[str]       						=			do_normalize if do_normalize is not None else self.do_normalize
										_UpperCAmelCase				:						Any       						=			image_mean if image_mean is not None else self.image_mean
										_UpperCAmelCase				:						List[Any]       						=			image_std if image_std is not None else self.image_std

										_UpperCAmelCase				:						str       						=			make_list_of_images(A_		)

										if not valid_images(A_		):
														raise ValueError(
														    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
														    "torch.Tensor, tf.Tensor or jax.ndarray."		)

										if do_resize and size is None:
														raise ValueError("Size must be specified if do_resize is True."		)

										if do_rescale and rescale_factor is None:
														raise ValueError("Rescale factor must be specified if do_rescale is True."		)

										if do_pad and size is None:
														raise ValueError("Size must be specified if do_pad is True."		)

										if do_normalize and (image_mean is None or image_std is None):
														raise ValueError("Image mean and std must be specified if do_normalize is True."		)

										# All transformations expect numpy arrays.
										_UpperCAmelCase				:						Union[str, Any]       						=			[to_numpy_array(A_		) for image in images]

										if do_align_long_axis:
														_UpperCAmelCase				:						Tuple       						=			[self.align_long_axis(A_  ,    size=A_		) for image in images]

										if do_resize:
														_UpperCAmelCase				:						Optional[int]       						=			[self.resize(image=A_  ,    size=A_  ,    resample=A_		) for image in images]

										if do_thumbnail:
														_UpperCAmelCase				:						Optional[Any]       						=			[self.thumbnail(image=A_  ,    size=A_		) for image in images]

										if do_pad:
														_UpperCAmelCase				:						List[Any]       						=			[self.pad_image(image=A_  ,    size=A_  ,    random_padding=A_		) for image in images]

										if do_rescale:
														_UpperCAmelCase				:						Tuple       						=			[self.rescale(image=A_  ,    scale=A_		) for image in images]

										if do_normalize:
														_UpperCAmelCase				:						int       						=			[self.normalize(image=A_  ,    mean=A_  ,    std=A_		) for image in images]

										_UpperCAmelCase				:						str       						=			[to_channel_dimension_format(A_  ,    A_		) for image in images]

										_UpperCAmelCase				:						Dict       						=			{"pixel_values": images}
										return BatchFeature(data=A_  ,    tensor_type=A_		)


