




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()
__a  :		Union[str, Any]		     =   logging.get_logger(__name__)
def  snake_case_					(		SCREAMING_SNAKE_CASE_    )      ->			Tuple:
							lowercase__  :	Optional[Any]        =							ConvNextConfig()

							if "tiny" in checkpoint_url:
														lowercase__  :	Union[str, Any]        =							[3, 3, 9, 3]
														lowercase__  :	Tuple        =							[96, 1_92, 3_84, 7_68]
							if "small" in checkpoint_url:
														lowercase__  :	Optional[Any]        =							[3, 3, 27, 3]
														lowercase__  :	Optional[Any]        =							[96, 1_92, 3_84, 7_68]
							if "base" in checkpoint_url:
														lowercase__  :	Tuple        =							[3, 3, 27, 3]
														lowercase__  :	Tuple        =							[1_28, 2_56, 5_12, 10_24]
							if "large" in checkpoint_url:
														lowercase__  :	int        =							[3, 3, 27, 3]
														lowercase__  :	List[Any]        =							[1_92, 3_84, 7_68, 15_36]
							if "xlarge" in checkpoint_url:
														lowercase__  :	Any        =							[3, 3, 27, 3]
														lowercase__  :	int        =							[2_56, 5_12, 10_24, 20_48]

							if "1k" in checkpoint_url:
														lowercase__  :	List[str]        =							10_00
														lowercase__  :	List[str]        =							"imagenet-1k-id2label.json"
														lowercase__  :	Optional[int]        =							(1, 10_00)
							else:
														lowercase__  :	Union[str, Any]        =							2_18_41
														lowercase__  :	List[Any]        =							"imagenet-22k-id2label.json"
														lowercase__  :	List[Any]        =							(1, 2_18_41)

							lowercase__  :	int        =							"huggingface/label-files"
							lowercase__  :	Union[str, Any]        =							num_labels
							lowercase__  :	Union[str, Any]        =							json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    ,repo_type="dataset"    )    ,"r"    )    )
							lowercase__  :	List[Any]        =							{int(SCREAMING_SNAKE_CASE_    ): 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[92_05]
														del idalabel[1_50_27]
							lowercase__  :	Union[str, Any]        =							idalabel
							lowercase__  :	List[str]        =							{v: k for k, v in idalabel.items()}
							lowercase__  :	List[Any]        =							hidden_sizes
							lowercase__  :	str        =							depths

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

							return name
def  snake_case_					(		)      ->			Dict:
							lowercase__  :	Optional[int]        =							"http://images.cocodataset.org/val2017/000000039769.jpg"
							lowercase__  :	Optional[Any]        =							Image.open(requests.get(SCREAMING_SNAKE_CASE_    ,stream=SCREAMING_SNAKE_CASE_    ).raw    )
							return im
@torch.no_grad()
def  snake_case_					(		SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    )      ->			List[str]:
							lowercase__ ,       lowercase__  :	Any        =							get_convnext_config(SCREAMING_SNAKE_CASE_    )
							# load original state_dict from URL
							lowercase__  :	Optional[int]        =							torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE_    )["model"]
							# rename keys
							for key in state_dict.copy().keys():
														lowercase__  :	Dict        =							state_dict.pop(SCREAMING_SNAKE_CASE_    )
														lowercase__  :	str        =							val
							# add prefix to all keys expect classifier head
							for key in state_dict.copy().keys():
														lowercase__  :	List[Any]        =							state_dict.pop(SCREAMING_SNAKE_CASE_    )
														if not key.startswith("classifier"    ):
																					lowercase__  :	Tuple        =							"convnext." + key
														lowercase__  :	List[Any]        =							val

							# load HuggingFace model
							lowercase__  :	List[Any]        =							ConvNextForImageClassification(SCREAMING_SNAKE_CASE_    )
							model.load_state_dict(SCREAMING_SNAKE_CASE_    )
							model.eval()

							# Check outputs on an image, prepared by ConvNextImageProcessor
							lowercase__  :	Any        =							2_24 if "224" in checkpoint_url else 3_84
							lowercase__  :	Union[str, Any]        =							ConvNextImageProcessor(size=SCREAMING_SNAKE_CASE_    )
							lowercase__  :	int        =							image_processor(images=prepare_img()    ,return_tensors="pt"    ).pixel_values

							lowercase__  :	Dict        =							model(SCREAMING_SNAKE_CASE_    ).logits

							# note: the logits below were obtained without center cropping
							if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth":
														lowercase__  :	Union[str, Any]        =							torch.tensor([-0.1210, -0.6605, 0.1918]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_small_1k_224_ema.pth":
														lowercase__  :	Dict        =							torch.tensor([-0.4473, -0.1847, -0.6365]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_224_ema.pth":
														lowercase__  :	Tuple        =							torch.tensor([0.4525, 0.7539, 0.0308]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_384.pth":
														lowercase__  :	Dict        =							torch.tensor([0.3561, 0.6350, -0.0384]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_224_ema.pth":
														lowercase__  :	int        =							torch.tensor([0.4174, -0.0989, 0.1489]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_384.pth":
														lowercase__  :	Tuple        =							torch.tensor([0.2513, -0.1349, -0.1613]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_224.pth":
														lowercase__  :	Dict        =							torch.tensor([1.2980, 0.3631, -0.1198]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_224.pth":
														lowercase__  :	Optional[int]        =							torch.tensor([1.2963, 0.1227, 0.1723]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_224.pth":
														lowercase__  :	str        =							torch.tensor([1.7956, 0.8390, 0.2820]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_224.pth":
														lowercase__  :	int        =							torch.tensor([-0.2822, -0.0502, -0.0878]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_384.pth":
														lowercase__  :	List[str]        =							torch.tensor([-0.5672, -0.0730, -0.4348]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_224.pth":
														lowercase__  :	Optional[int]        =							torch.tensor([0.2681, 0.2365, 0.6246]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_384.pth":
														lowercase__  :	str        =							torch.tensor([-0.2642, 0.3931, 0.5116]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_224_ema.pth":
														lowercase__  :	Union[str, Any]        =							torch.tensor([-0.6677, -0.1873, -0.8379]    )
							elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_384_ema.pth":
														lowercase__  :	str        =							torch.tensor([-0.7749, -0.2967, -0.6444]    )
							else:
														raise ValueError(F"""Unknown URL: {checkpoint_url}"""    )

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

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

							print("Pushing model to the hub..."    )
							lowercase__  :	List[str]        =							"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(SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    )    ,organization="nielsr"    ,commit_message="Add model"    ,)


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

						__a  :		str		     =   parser.parse_args()
						convert_convnext_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)





def  snake_case_					(		SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    )      ->			list[int]:
							if hue < 0 or hue > 3_60:
														raise Exception("hue should be between 0 and 360"    )

							if saturation < 0 or saturation > 1:
														raise Exception("saturation should be between 0 and 1"    )

							if value < 0 or value > 1:
														raise Exception("value should be between 0 and 1"    )

							lowercase__  :	List[Any]        =							value * saturation
							lowercase__  :	Optional[int]        =							hue / 60
							lowercase__  :	int        =							chroma * (1 - abs(hue_section % 2 - 1    ))
							lowercase__  :	Any        =							value - chroma

							if hue_section >= 0 and hue_section <= 1:
														lowercase__  :	int        =							round(2_55 * (chroma + match_value)    )
														lowercase__  :	Tuple        =							round(2_55 * (second_largest_component + match_value)    )
														lowercase__  :	Optional[int]        =							round(2_55 * (match_value)    )
							elif hue_section > 1 and hue_section <= 2:
														lowercase__  :	List[str]        =							round(2_55 * (second_largest_component + match_value)    )
														lowercase__  :	List[str]        =							round(2_55 * (chroma + match_value)    )
														lowercase__  :	List[str]        =							round(2_55 * (match_value)    )
							elif hue_section > 2 and hue_section <= 3:
														lowercase__  :	Any        =							round(2_55 * (match_value)    )
														lowercase__  :	List[str]        =							round(2_55 * (chroma + match_value)    )
														lowercase__  :	List[str]        =							round(2_55 * (second_largest_component + match_value)    )
							elif hue_section > 3 and hue_section <= 4:
														lowercase__  :	str        =							round(2_55 * (match_value)    )
														lowercase__  :	Any        =							round(2_55 * (second_largest_component + match_value)    )
														lowercase__  :	Dict        =							round(2_55 * (chroma + match_value)    )
							elif hue_section > 4 and hue_section <= 5:
														lowercase__  :	Tuple        =							round(2_55 * (second_largest_component + match_value)    )
														lowercase__  :	List[str]        =							round(2_55 * (match_value)    )
														lowercase__  :	Dict        =							round(2_55 * (chroma + match_value)    )
							else:
														lowercase__  :	List[Any]        =							round(2_55 * (chroma + match_value)    )
														lowercase__  :	Dict        =							round(2_55 * (match_value)    )
														lowercase__  :	Optional[int]        =							round(2_55 * (second_largest_component + match_value)    )

							return [red, green, blue]
def  snake_case_					(		SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    )      ->			list[float]:
							if red < 0 or red > 2_55:
														raise Exception("red should be between 0 and 255"    )

							if green < 0 or green > 2_55:
														raise Exception("green should be between 0 and 255"    )

							if blue < 0 or blue > 2_55:
														raise Exception("blue should be between 0 and 255"    )

							lowercase__  :	List[str]        =							red / 2_55
							lowercase__  :	str        =							green / 2_55
							lowercase__  :	Any        =							blue / 2_55
							lowercase__  :	Optional[int]        =							max(SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    )
							lowercase__  :	List[str]        =							value - min(SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    )
							lowercase__  :	Optional[Any]        =							0 if value == 0 else chroma / value

							if chroma == 0:
														lowercase__  :	Dict        =							0.0
							elif value == float_red:
														lowercase__  :	Union[str, Any]        =							60 * (0 + (float_green - float_blue) / chroma)
							elif value == float_green:
														lowercase__  :	Any        =							60 * (2 + (float_blue - float_red) / chroma)
							else:
														lowercase__  :	Any        =							60 * (4 + (float_red - float_green) / chroma)

							lowercase__  :	Tuple        =							(hue + 3_60) % 3_60

							return [hue, saturation, value]




def  snake_case_					(		SCREAMING_SNAKE_CASE_    ,SCREAMING_SNAKE_CASE_    )      ->			bool:
							lowercase__  :	Optional[Any]        =							abs(hsv_a[0] - hsv_a[0]    ) < 0.2
							lowercase__  :	Optional[int]        =							abs(hsv_a[1] - hsv_a[1]    ) < 0.002
							lowercase__  :	int        =							abs(hsv_a[2] - hsv_a[2]    ) < 0.002

							return check_hue and check_saturation and check_value