




import inspect
import unittest

from transformers import DataaVecVisionConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import (
		    MODEL_MAPPING,
		    DataaVecVisionForImageClassification,
		    DataaVecVisionForSemanticSegmentation,
		    DataaVecVisionModel,
		)
		from transformers.models.dataavec.modeling_dataavec_vision import DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import BeitImageProcessor

class 	__lowerCAmelCase			:
							def __init__(		self		:int	,   __magic_name__		:Optional[Any]	,   __magic_name__		:Optional[Any]=100	,   __magic_name__		:Union[str, Any]=13	,   __magic_name__		:Any=30	,   __magic_name__		:str=2	,   __magic_name__		:Tuple=3	,   __magic_name__		:Optional[Any]=True	,   __magic_name__		:Optional[Any]=True	,   __magic_name__		:Dict=32	,   __magic_name__		:Optional[int]=4	,   __magic_name__		:Any=4	,   __magic_name__		:Tuple=37	,   __magic_name__		:List[str]="gelu"	,   __magic_name__		:Any=0.1	,   __magic_name__		:List[str]=0.1	,   __magic_name__		:Union[str, Any]=10	,   __magic_name__		:Optional[int]=0.02	,   __magic_name__		:Union[str, Any]=3	,   __magic_name__		:Optional[int]=None	,   __magic_name__		:int=[0, 1, 2, 3]	,   ):







								'''simple docstring'''







								a		       =							parent
								a		       =							100
								a		       =							batch_size
								a		       =							image_size
								a		       =							patch_size
								a		       =							num_channels
								a		       =							is_training
								a		       =							use_labels
								a		       =							hidden_size
								a		       =							num_hidden_layers
								a		       =							num_attention_heads
								a		       =							intermediate_size
								a		       =							hidden_act
								a		       =							hidden_dropout_prob
								a		       =							attention_probs_dropout_prob
								a		       =							type_sequence_label_size
								a		       =							initializer_range
								a		       =							scope
								a		       =							out_indices
								a		       =							num_labels

								# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
								a		       =							(image_size // patch_size) ** 2
								a		       =							num_patches + 1
							def    lowerCamelCase__							(		self		:List[str]       ):







								'''simple docstring'''







								a		       =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

								a		       =							None
								a		       =							None
								if self.use_labels:
									a		       =							ids_tensor([self.batch_size]	,   self.type_sequence_label_size       )
									a		       =							ids_tensor([self.batch_size, self.image_size, self.image_size]	,   self.num_labels       )

								a		       =							self.get_config()

								return config, pixel_values, labels, pixel_labels
							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								return DataaVecVisionConfig(
								    vocab_size=self.vocab_size	,   image_size=self.image_size	,   patch_size=self.patch_size	,   num_channels=self.num_channels	,   hidden_size=self.hidden_size	,   num_hidden_layers=self.num_hidden_layers	,   num_attention_heads=self.num_attention_heads	,   intermediate_size=self.intermediate_size	,   hidden_act=self.hidden_act	,   hidden_dropout_prob=self.hidden_dropout_prob	,   attention_probs_dropout_prob=self.attention_probs_dropout_prob	,   is_decoder=__magic_name__	,   initializer_range=self.initializer_range	,   out_indices=self.out_indices	,   )
							def    lowerCamelCase__							(		self		:int	,   __magic_name__		:Dict	,   __magic_name__		:Optional[int]	,   __magic_name__		:Union[str, Any]	,   __magic_name__		:Dict       ):







								'''simple docstring'''







								a		       =							DataaVecVisionModel(config=__magic_name__       )
								model.to(__magic_name__       )
								model.eval()
								a		       =							model(__magic_name__       )
								# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
								a		       =							(self.image_size // self.patch_size) ** 2
								self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, num_patches + 1, self.hidden_size)       )
							def    lowerCamelCase__							(		self		:Optional[Any]	,   __magic_name__		:Optional[Any]	,   __magic_name__		:Any	,   __magic_name__		:Any	,   __magic_name__		:Optional[int]       ):







								'''simple docstring'''







								a		       =							self.type_sequence_label_size
								a		       =							DataaVecVisionForImageClassification(__magic_name__       )
								model.to(__magic_name__       )
								model.eval()
								a		       =							model(__magic_name__	,   labels=__magic_name__       )
								self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.type_sequence_label_size)       )
							def    lowerCamelCase__							(		self		:Optional[Any]	,   __magic_name__		:Tuple	,   __magic_name__		:List[str]	,   __magic_name__		:Any	,   __magic_name__		:Dict       ):







								'''simple docstring'''







								a		       =							self.num_labels
								a		       =							DataaVecVisionForSemanticSegmentation(__magic_name__       )
								model.to(__magic_name__       )
								model.eval()
								a		       =							model(__magic_name__       )
								self.parent.assertEqual(
								    result.logits.shape	,   (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)       )
								a		       =							model(__magic_name__	,   labels=__magic_name__       )
								self.parent.assertEqual(
								    result.logits.shape	,   (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)       )





							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								a		       =							self.prepare_config_and_inputs()
								a       ,				a       ,				a       ,				a		       =							config_and_inputs
								a		       =							{"""pixel_values""": pixel_values}
								return config, inputs_dict







@require_torch
class 	__lowerCAmelCase			(			__magic_name__   , __magic_name__   , unittest.TestCase				):
							UpperCamelCase__        =						(
							    (DataaVecVisionModel, DataaVecVisionForImageClassification, DataaVecVisionForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)
							UpperCamelCase__        =						(
							    {
							        '''feature-extraction''': DataaVecVisionModel,
							        '''image-classification''': DataaVecVisionForImageClassification,
							        '''image-segmentation''': DataaVecVisionForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							UpperCamelCase__        =						False
							UpperCamelCase__        =						False
							UpperCamelCase__        =						False
							def    lowerCamelCase__							(		self		:Tuple       ):







								'''simple docstring'''







								a		       =							DataaVecVisionModelTester(self       )
								a		       =							ConfigTester(
								    self	,   config_class=__magic_name__	,   has_text_modality=__magic_name__	,   hidden_size=37       )
							def    lowerCamelCase__							(		self		:Union[str, Any]       ):







								'''simple docstring'''







								self.config_tester.run_common_tests()
							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								pass
							@require_torch_multi_gpu
							@unittest.skip(
							    reason="""Data2VecVision has some layers using `add_module` which doesn't work well with `nn.DataParallel`"""       )
							def    lowerCamelCase__							(		self		:int       ):







								'''simple docstring'''







								pass
							def    lowerCamelCase__							(		self		:List[Any]       ):







								'''simple docstring'''







								a       ,				a		       =							self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
									a		       =							model_class(__magic_name__       )
									self.assertIsInstance(model.get_input_embeddings()	,   (nn.Module)       )
									a		       =							model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(__magic_name__	,   nn.Linear       )       )
							def    lowerCamelCase__							(		self		:Union[str, Any]       ):







								'''simple docstring'''







								a       ,				a		       =							self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
									a		       =							model_class(__magic_name__       )
									a		       =							inspect.signature(model.forward       )
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									a		       =							[*signature.parameters.keys()]

									a		       =							["""pixel_values"""]
									self.assertListEqual(arg_names[:1]	,   __magic_name__       )
							def    lowerCamelCase__							(		self		:Tuple       ):







								'''simple docstring'''







								a		       =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__magic_name__       )
							def    lowerCamelCase__							(		self		:List[Any]       ):







								'''simple docstring'''







								a		       =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_segmentation(*__magic_name__       )
							def    lowerCamelCase__							(		self		:Dict       ):







								'''simple docstring'''







								if not self.model_tester.is_training:
									return

								a       ,				a		       =							self.model_tester.prepare_config_and_inputs_for_common()
								a		       =							True

								for model_class in self.all_model_classes:
									if model_class in [*get_values(__magic_name__       )]:
										continue

									a		       =							model_class(__magic_name__       )
									model.to(__magic_name__       )
									model.train()
									a		       =							self._prepare_for_class(__magic_name__	,   __magic_name__	,   return_labels=__magic_name__       )
									a		       =							model(**__magic_name__       ).loss
									loss.backward()
							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								a       ,				a		       =							self.model_tester.prepare_config_and_inputs_for_common()
								if not self.model_tester.is_training:
									return

								a		       =							False
								a		       =							True

								for model_class in self.all_model_classes:
									if model_class in [*get_values(__magic_name__       )] or not model_class.supports_gradient_checkpointing:
										continue
									# TODO: remove the following 3 lines once we have a MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING
									# this can then be incorporated into _prepare_for_class in test_modeling_common.py
									elif model_class.__name__ == "Data2VecVisionForSemanticSegmentation":
										a       ,				a       ,				a       ,				a		       =							inputs_dict["""pixel_values"""].shape
										a		       =							torch.zeros(
										    [self.model_tester.batch_size, height, width]	,   device=__magic_name__       ).long()
									a		       =							model_class(__magic_name__       )
									model.gradient_checkpointing_enable()
									model.to(__magic_name__       )
									model.train()
									a		       =							self._prepare_for_class(__magic_name__	,   __magic_name__	,   return_labels=__magic_name__       )
									a		       =							model(**__magic_name__       ).loss
									loss.backward()
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								a       ,				a		       =							self.model_tester.prepare_config_and_inputs_for_common()

								a		       =							_config_zero_init(__magic_name__       )
								for model_class in self.all_model_classes:
									a		       =							model_class(config=__magic_name__       )
									for name, param in model.named_parameters():
										# we skip lambda parameters as these require special initial values
										# determined by config.layer_scale_init_value
										if "lambda" in name:
											continue
										if param.requires_grad:
											self.assertIn(
											    ((param.data.mean() * 1E9).round() / 1E9).item()	,   [0.0, 1.0]	,   msg=F'Parameter {name} of model {model_class} seems not properly initialized'	,   )
							def    lowerCamelCase__							(		self		:str	,   __magic_name__		:Optional[int]	,   __magic_name__		:Any	,   __magic_name__		:int	,   __magic_name__		:Tuple=2E-4	,   __magic_name__		:Union[str, Any]="outputs"	,   __magic_name__		:List[Any]=None       ):







								'''simple docstring'''







								super().check_pt_tf_outputs(__magic_name__	,   __magic_name__	,   __magic_name__	,   __magic_name__	,   __magic_name__	,   __magic_name__       )
							def    lowerCamelCase__							(		self		:List[Any]       ):







								'''simple docstring'''







								a		       =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*__magic_name__       )





							@slow
							def    lowerCamelCase__							(		self		:str       ):







								'''simple docstring'''







								for model_name in DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									a		       =							DataaVecVisionModel.from_pretrained(__magic_name__       )
									self.assertIsNotNone(__magic_name__       )







def 	__A	(			)   -> Tuple:
	a		       =							Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
	return image



@require_torch
@require_vision
class 	__lowerCAmelCase			(			unittest.TestCase				):
							@cached_property
							def    lowerCamelCase__							(		self		:List[str]       ):







								'''simple docstring'''







								return (
								    BeitImageProcessor.from_pretrained("""facebook/data2vec-vision-base-ft1k"""       ) if is_vision_available() else None
								)





							@slow
							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								a		       =							DataaVecVisionForImageClassification.from_pretrained("""facebook/data2vec-vision-base-ft1k"""       ).to(
								    __magic_name__       )

								a		       =							self.default_image_processor
								a		       =							prepare_img()
								a		       =							image_processor(images=__magic_name__	,   return_tensors="""pt"""       ).to(__magic_name__       )

								# forward pass
								with torch.no_grad():
									a		       =							model(**__magic_name__       )
								a		       =							outputs.logits

								# verify the logits
								a		       =							torch.Size((1, 1000)       )
								self.assertEqual(logits.shape	,   __magic_name__       )

								a		       =							torch.tensor([0.3277, -0.1395, 0.0911]       ).to(__magic_name__       )

								self.assertTrue(torch.allclose(logits[0, :3]	,   __magic_name__	,   atol=1E-4       )       )

								a		       =							[model.config.labelaid[i] for i in ["""remote control, remote""", """tabby, tabby cat"""]]
								self.assertEqual(logits[0].topk(2       ).indices.cpu().tolist()	,   __magic_name__       )







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      : List[Any]					      =   logging.get_logger(__name__)





def 	__A	(			__lowerCamelCase					)   -> Optional[int]:
	a		       =							ConvNextConfig()

	if "tiny" in checkpoint_url:
		a		       =							[3, 3, 9, 3]
		a		       =							[96, 192, 384, 768]
	if "small" in checkpoint_url:
		a		       =							[3, 3, 27, 3]
		a		       =							[96, 192, 384, 768]
	if "base" in checkpoint_url:
		a		       =							[3, 3, 27, 3]
		a		       =							[128, 256, 512, 1024]
	if "large" in checkpoint_url:
		a		       =							[3, 3, 27, 3]
		a		       =							[192, 384, 768, 1536]
	if "xlarge" in checkpoint_url:
		a		       =							[3, 3, 27, 3]
		a		       =							[256, 512, 1024, 2048]

	if "1k" in checkpoint_url:
		a		       =							1000
		a		       =							"""imagenet-1k-id2label.json"""
		a		       =							(1, 1000)
	else:
		a		       =							2_1841
		a		       =							"""imagenet-22k-id2label.json"""
		a		       =							(1, 2_1841)

	a		       =							"""huggingface/label-files"""
	a		       =							num_labels
	a		       =							json.load(open(hf_hub_download(__lowerCamelCase							,    __lowerCamelCase							,    repo_type="""dataset"""					)							,    """r"""					)					)
	a		       =							{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]
	a		       =							idalabel
	a		       =							{v: k for k, v in idalabel.items()}
	a		       =							hidden_sizes
	a		       =							depths

	return config, expected_shape





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

	return name





def 	__A	(			)   -> Optional[Any]:
	a		       =							"""http://images.cocodataset.org/val2017/000000039769.jpg"""
	a		       =							Image.open(requests.get(__lowerCamelCase							,    stream=__lowerCamelCase					).raw					)
	return im





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

	# load HuggingFace model
	a		       =							ConvNextForImageClassification(__lowerCamelCase					)
	model.load_state_dict(__lowerCamelCase					)
	model.eval()

	# Check outputs on an image, prepared by ConvNextImageProcessor
	a		       =							224 if """224""" in checkpoint_url else 384
	a		       =							ConvNextImageProcessor(size=__lowerCamelCase					)
	a		       =							image_processor(images=prepare_img()							,    return_tensors="""pt"""					).pixel_values

	a		       =							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":
		a		       =							torch.tensor([-0.1210, -0.6605, 0.1918]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_small_1k_224_ema.pth":
		a		       =							torch.tensor([-0.4473, -0.1847, -0.6365]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_224_ema.pth":
		a		       =							torch.tensor([0.4525, 0.7539, 0.0308]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_384.pth":
		a		       =							torch.tensor([0.3561, 0.6350, -0.0384]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_224_ema.pth":
		a		       =							torch.tensor([0.4174, -0.0989, 0.1489]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_384.pth":
		a		       =							torch.tensor([0.2513, -0.1349, -0.1613]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_224.pth":
		a		       =							torch.tensor([1.2980, 0.3631, -0.1198]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_224.pth":
		a		       =							torch.tensor([1.2963, 0.1227, 0.1723]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_224.pth":
		a		       =							torch.tensor([1.7956, 0.8390, 0.2820]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_224.pth":
		a		       =							torch.tensor([-0.2822, -0.0502, -0.0878]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_384.pth":
		a		       =							torch.tensor([-0.5672, -0.0730, -0.4348]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_224.pth":
		a		       =							torch.tensor([0.2681, 0.2365, 0.6246]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_384.pth":
		a		       =							torch.tensor([-0.2642, 0.3931, 0.5116]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_224_ema.pth":
		a		       =							torch.tensor([-0.6677, -0.1873, -0.8379]					)
	elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_384_ema.pth":
		a		       =							torch.tensor([-0.7749, -0.2967, -0.6444]					)
	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..."""					)
	a		       =							"""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__":
		__UpperCamelCase      : 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.",
		)

		__UpperCamelCase      : List[Any]					      =   parser.parse_args()
		convert_convnext_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)

