





import timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
		import torch

		from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
		import pyanvml.pyanvml as nvml


__UpperCamelCase      : Tuple					      =   logging.get_logger(__name__)

class 	__lowerCAmelCase			(			_UpperCAmelCase				):
							UpperCamelCase__        =						42
							UpperCamelCase__        =						42
							UpperCamelCase__        =						'''PyTorch'''
							@property
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								return torch.__version__
							def    lowerCamelCase__							(		self		:Tuple	,   __magic_name__		:int	,   __magic_name__		:List[Any]	,   __magic_name__		:Union[str, Any]       ):







								'''simple docstring'''







								a		       =							self._prepare_inference_func(__magic_name__	,   __magic_name__	,   __magic_name__       )
								return self._measure_speed(_inference       )
							def    lowerCamelCase__							(		self		:Any	,   __magic_name__		:Optional[int]	,   __magic_name__		:Optional[Any]	,   __magic_name__		:Optional[int]       ):







								'''simple docstring'''







								a		       =							self._prepare_inference_func(__magic_name__	,   __magic_name__	,   __magic_name__       )
								return self._measure_memory(_inference       )
							def    lowerCamelCase__							(		self		:int	,   __magic_name__		:List[str]	,   __magic_name__		:int	,   __magic_name__		:Any       ):







								'''simple docstring'''







								a		       =							self._prepare_train_func(__magic_name__	,   __magic_name__	,   __magic_name__       )
								return self._measure_speed(_train       )
							def    lowerCamelCase__							(		self		:Optional[int]	,   __magic_name__		:List[Any]	,   __magic_name__		:Union[str, Any]	,   __magic_name__		:Any       ):







								'''simple docstring'''







								a		       =							self._prepare_train_func(__magic_name__	,   __magic_name__	,   __magic_name__       )
								return self._measure_memory(_train       )
							def    lowerCamelCase__							(		self		:int	,   __magic_name__		:List[str]	,   __magic_name__		:List[str]	,   __magic_name__		:List[Any]       ):







								'''simple docstring'''







								a		       =							self.config_dict[model_name]

								if self.args.torchscript:
									a		       =							True

								a		       =							(
								    hasattr(__magic_name__	,   """architectures"""       )
								    and isinstance(config.architectures	,   __magic_name__       )
								    and len(config.architectures       ) > 0
								)
								if not self.args.only_pretrain_model and has_model_class_in_config:
									try:
										a		       =							config.architectures[0]
										a		       =							__import__("""transformers"""	,   fromlist=[model_class]       )
										a		       =							getattr(__magic_name__	,   __magic_name__       )
										a		       =							model_cls(__magic_name__       )
									except ImportError:
										raise ImportError(
										    F'{model_class} does not exist. If you just want to test the pretrained model, you might want to'
										    """ set `--only_pretrain_model` or `args.only_pretrain_model=True`."""       )
								else:
									a		       =							MODEL_MAPPING[config.__class__](__magic_name__       )

								model.eval()
								model.to(self.args.device       )

								# encoder-decoder has vocab size saved differently
								a		       =							config.vocab_size if hasattr(__magic_name__	,   """vocab_size"""       ) else config.encoder.vocab_size
								a		       =							torch.randint(__magic_name__	,   (batch_size, sequence_length)	,   dtype=torch.long	,   device=self.args.device       )

								if self.args.fpaa:
									logger.info("""Running training in Mixed Precision..."""       )
									if not self.args.is_gpu:
										raise ValueError("""Mixed precision is possible only for GPU."""       )
									# amp seems to have memory leaks so that memory usage
									# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
									model.half()

								if self.args.torchscript:
									with torch.no_grad():
										a		       =							torch.jit.trace(__magic_name__	,   __magic_name__       )
								else:
									a		       =							model

								def encoder_decoder_forward():
									with torch.no_grad():
										a		       =							inference_model(__magic_name__	,   decoder_input_ids=__magic_name__       )
									return outputs

								def encoder_forward():
									with torch.no_grad():
										a		       =							inference_model(__magic_name__       )
									return outputs

								a		       =							encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
								return _forward
							def    lowerCamelCase__							(		self		:Optional[Any]	,   __magic_name__		:List[str]	,   __magic_name__		:List[str]	,   __magic_name__		:str       ):







								'''simple docstring'''







								a		       =							self.config_dict[model_name]

								a		       =							(
								    hasattr(__magic_name__	,   """architectures"""       )
								    and isinstance(config.architectures	,   __magic_name__       )
								    and len(config.architectures       ) > 0
								)
								if not self.args.only_pretrain_model and has_model_class_in_config:
									try:
										a		       =							config.architectures[0]
										a		       =							__import__("""transformers"""	,   fromlist=[model_class]       )
										a		       =							getattr(__magic_name__	,   __magic_name__       )
										a		       =							model_cls(__magic_name__       )
									except ImportError:
										raise ImportError(
										    F'{model_class} does not exist. If you just want to test the pretrained model, you might want to'
										    """ set `--only_pretrain_model` or `args.only_pretrain_model=True`."""       )
								else:
									a		       =							MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__magic_name__       )

								if self.args.torchscript:
									raise NotImplementedError("""Training for torchscript is currently not implemented"""       )
								else:
									a		       =							model

								model.train()
								model.to(self.args.device       )

								# encoder-decoder has vocab size saved differently
								a		       =							config.vocab_size if hasattr(__magic_name__	,   """vocab_size"""       ) else config.encoder.vocab_size
								a		       =							torch.randint(__magic_name__	,   (batch_size, sequence_length)	,   dtype=torch.long	,   device=self.args.device       )

								if self.args.fpaa:
									logger.info("""Running training in Mixed Precision..."""       )
									if not self.args.is_gpu:
										raise ValueError("""Mixed precision is possible only for GPU."""       )

									# amp seems to have memory leaks so that memory usage
									# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
									model.half()

								def compute_loss_and_backprob_encoder():
									a		       =							train_model(__magic_name__	,   labels=__magic_name__       )[0]
									loss.backward()
									return loss

								def compute_loss_and_backprob_encoder_decoder():
									a		       =							train_model(__magic_name__	,   decoder_input_ids=__magic_name__	,   labels=__magic_name__       )[0]
									loss.backward()
									return loss

								a		       =							(
								    compute_loss_and_backprob_encoder_decoder
								    if config.is_encoder_decoder
								    else compute_loss_and_backprob_encoder
								)
								return _train
							def    lowerCamelCase__							(		self		:List[Any]	,   __magic_name__		:str       ):







								'''simple docstring'''







								try:
									if self.args.is_tpu or self.args.torchscript:
										# run additional 10 times to stabilize compilation for tpu and torchscript
										logger.info("""Do inference on TPU or torchscript. Running model 5 times to stabilize compilation"""       )
										timeit.repeat(
										    __magic_name__	,   repeat=1	,   number=5	,   )

									# as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
									a		       =							timeit.repeat(
									    __magic_name__	,   repeat=self.args.repeat	,   number=10	,   )

									if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
										import torch_xla.debug.metrics as met

										self.print_fn(met.metrics_report()       )

									return min(__magic_name__       ) / 10.0
								except RuntimeError as e:
									self.print_fn(F'Doesn\'t fit on GPU. {e}'       )
									return "N/A"





							def    lowerCamelCase__							(		self		:Union[str, Any]	,   __magic_name__		:List[str]       ):







								'''simple docstring'''







								try:
									if self.args.trace_memory_line_by_line:
										a		       =							start_memory_tracing("""transformers"""       )

									if self.args.is_tpu:
										# tpu
										raise NotImplementedError(
										    """Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with"""
										    """ `--no-memory` or `args.memory=False`"""       )
									elif self.args.is_gpu:
										if not is_pyanvml_available():
											logger.warning(
											    """py3nvml not installed, we won't log GPU memory usage. """
											    """Install py3nvml (pip install py3nvml) to log information about GPU."""       )
											a		       =							"""N/A"""
										else:
											logger.info(
											    """Measuring total GPU usage on GPU device. Make sure to not have additional processes running"""
											    """ on the same GPU."""       )
											# init nvml
											nvml.nvmlInit()
											func()
											a		       =							nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx       )
											a		       =							nvml.nvmlDeviceGetMemoryInfo(__magic_name__       )
											a		       =							meminfo.used
											a		       =							Memory(__magic_name__       )
											# shutdown nvml
											nvml.nvmlShutdown()
									else:
										# cpu
										a		       =							measure_peak_memory_cpu(__magic_name__       )
										a		       =							Memory(__magic_name__       ) if isinstance(__magic_name__	,   __magic_name__       ) else memory_bytes

									if self.args.trace_memory_line_by_line:
										a		       =							stop_memory_tracing(__magic_name__       )
									else:
										a		       =							None

									return memory, summary
								except RuntimeError as e:
									self.print_fn(F'Doesn\'t fit on GPU. {e}'       )
									return "N/A", None







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)

