

import argparse
import json
import os

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

from transformers import ConvNextImageProcessor, ConvNextVaConfig, ConvNextVaForImageClassification
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
_SCREAMING_SNAKE_CASE          = logging.get_logger(__name__)





def    _snake_case		(snake_case_				:    List[str]     )       ->		int:
  __UpperCAmelCase  :     str		=    ConvNextVaConfig()

  if "atto" in checkpoint_url:
    __UpperCAmelCase  :     Tuple		=    [2, 2, 6, 2]
    __UpperCAmelCase  :     Optional[Any]		=    [40, 80, 160, 320]
  if "femto" in checkpoint_url:
    __UpperCAmelCase  :     Optional[int]		=    [2, 2, 6, 2]
    __UpperCAmelCase  :     List[Any]		=    [48, 96, 192, 384]
  if "pico" in checkpoint_url:
    __UpperCAmelCase  :     Tuple		=    [2, 2, 6, 2]
    __UpperCAmelCase  :     List[str]		=    [64, 128, 256, 512]
  if "nano" in checkpoint_url:
    __UpperCAmelCase  :     str		=    [2, 2, 8, 2]
    __UpperCAmelCase  :     Optional[int]		=    [80, 160, 320, 640]
  if "tiny" in checkpoint_url:
    __UpperCAmelCase  :     Union[str, Any]		=    [3, 3, 9, 3]
    __UpperCAmelCase  :     str		=    [96, 192, 384, 768]
  if "base" in checkpoint_url:
    __UpperCAmelCase  :     int		=    [3, 3, 27, 3]
    __UpperCAmelCase  :     Tuple		=    [128, 256, 512, 1024]
  if "large" in checkpoint_url:
    __UpperCAmelCase  :     str		=    [3, 3, 27, 3]
    __UpperCAmelCase  :     Dict		=    [192, 384, 768, 1536]
  if "huge" in checkpoint_url:
    __UpperCAmelCase  :     Tuple		=    [3, 3, 27, 3]
    __UpperCAmelCase  :     Optional[Any]		=    [352, 704, 1408, 2816]

  __UpperCAmelCase  :     str		=    1000
  __UpperCAmelCase  :     Any		=    'imagenet-1k-id2label.json'
  __UpperCAmelCase  :     str		=    (1, 1000)

  __UpperCAmelCase  :     List[str]		=    'huggingface/label-files'
  __UpperCAmelCase  :     List[str]		=    num_labels
  __UpperCAmelCase  :     str		=    json.load(open(hf_hub_download(snake_case_						,					snake_case_						,					repo_type='dataset'     )						,					'r'     )     )
  __UpperCAmelCase  :     Optional[int]		=    {int(snake_case_     ): v for k, v in idalabel.items()}

  __UpperCAmelCase  :     Optional[int]		=    idalabel
  __UpperCAmelCase  :     List[Any]		=    {v: k for k, v in idalabel.items()}
  __UpperCAmelCase  :     Tuple		=    hidden_sizes
  __UpperCAmelCase  :     List[str]		=    depths

  return config, expected_shape





def    _snake_case		(snake_case_				:    Any     )       ->		Union[str, Any]:
  if "downsample_layers.0.0" in name:
    __UpperCAmelCase  :     List[str]		=    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  :     Optional[Any]		=    name.replace('downsample_layers.1.0'						,					'stages.1.downsampling_layer.0'     )
  if "downsample_layers.1.1" in name:
    __UpperCAmelCase  :     int		=    name.replace('downsample_layers.1.1'						,					'stages.1.downsampling_layer.1'     )
  if "downsample_layers.2.0" in name:
    __UpperCAmelCase  :     str		=    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  :     List[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  :     Optional[int]		=    name[: len('stages.0'     )] + '.layers' + name[len('stages.0'     ) :]
  if "gamma" in name:
    __UpperCAmelCase  :     Tuple		=    name.replace('gamma'						,					'weight'     )
  if "beta" in name:
    __UpperCAmelCase  :     List[Any]		=    name.replace('beta'						,					'bias'     )
  if "stages" in name:
    __UpperCAmelCase  :     str		=    name.replace('stages'						,					'encoder.stages'     )
  if "norm" in name:
    __UpperCAmelCase  :     List[Any]		=    name.replace('norm'						,					'layernorm'     )
  if "head" in name:
    __UpperCAmelCase  :     List[str]		=    name.replace('head'						,					'classifier'     )

  return name





def    _snake_case		()       ->		str:
  __UpperCAmelCase  :     Dict		=    'http://images.cocodataset.org/val2017/000000039769.jpg'
  __UpperCAmelCase  :     str		=    Image.open(requests.get(snake_case_						,					stream=snake_case_     ).raw     )
  return im





def    _snake_case		(snake_case_				:    Dict     )       ->		int:
  if "224" in checkpoint_url:
    __UpperCAmelCase  :     Union[str, Any]		=    224
    __UpperCAmelCase  :     int		=    224 / 256
  elif "384" in checkpoint_url:
    __UpperCAmelCase  :     int		=    384
    __UpperCAmelCase  :     List[str]		=    None
  else:
    __UpperCAmelCase  :     int		=    512
    __UpperCAmelCase  :     Optional[int]		=    None

  return ConvNextImageProcessor(
      size=snake_case_						,					crop_pct=snake_case_						,					image_mean=[0.485, 0.456, 0.406]						,					image_std=[0.229, 0.224, 0.225]						,					resample=PILImageResampling.BICUBIC						,					)





@torch.no_grad()
def    _snake_case		(snake_case_				:    Optional[int]						,					snake_case_				:    int						,					snake_case_				:    List[Any]						,					snake_case_				:    Optional[Any]     )       ->		Union[str, Any]:
  print('Downloading original model from checkpoint...'     )
  # define ConvNeXTV2 configuration based on URL
  __UpperCAmelCase, __UpperCAmelCase  :     List[Any]		=    get_convnextva_config(snake_case_     )
  # load original state_dict from URL
  __UpperCAmelCase  :     Optional[int]		=    torch.hub.load_state_dict_from_url(snake_case_     )['model']

  print('Converting model parameters...'     )
  # rename keys
  for key in state_dict.copy().keys():
    __UpperCAmelCase  :     List[Any]		=    state_dict.pop(snake_case_     )
    __UpperCAmelCase  :     Union[str, Any]		=    val
  # add prefix to all keys expect classifier head
  for key in state_dict.copy().keys():
    __UpperCAmelCase  :     List[Any]		=    state_dict.pop(snake_case_     )
    if not key.startswith('classifier'     ):
      __UpperCAmelCase  :     Dict		=    'convnextv2.' + key
    __UpperCAmelCase  :     Tuple		=    val

  # load HuggingFace model
  __UpperCAmelCase  :     str		=    ConvNextVaForImageClassification(snake_case_     )
  model.load_state_dict(snake_case_     )
  model.eval()

  # Check outputs on an image, prepared by ConvNextImageProcessor
  __UpperCAmelCase  :     List[str]		=    convert_preprocessor(snake_case_     )
  __UpperCAmelCase  :     Tuple		=    preprocessor(images=prepare_img()						,					return_tensors='pt'     )
  __UpperCAmelCase  :     Optional[int]		=    model(**snake_case_     ).logits

  # note: the logits below were obtained without center cropping
  if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt":
    __UpperCAmelCase  :     Optional[int]		=    torch.tensor([-0.3930, 0.1747, -0.5246, 0.4177, 0.4295]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_femto_1k_224_ema.pt":
    __UpperCAmelCase  :     List[str]		=    torch.tensor([-0.1727, -0.5341, -0.7818, -0.4745, -0.6566]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_pico_1k_224_ema.pt":
    __UpperCAmelCase  :     List[Any]		=    torch.tensor([-0.0333, 0.1563, -0.9137, 0.1054, 0.0381]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_nano_1k_224_ema.pt":
    __UpperCAmelCase  :     Dict		=    torch.tensor([-0.1744, -0.1555, -0.0713, 0.0950, -0.1431]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_tiny_1k_224_ema.pt":
    __UpperCAmelCase  :     Optional[Any]		=    torch.tensor([0.9996, 0.1966, -0.4386, -0.3472, 0.6661]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_base_1k_224_ema.pt":
    __UpperCAmelCase  :     Optional[int]		=    torch.tensor([-0.2553, -0.6708, -0.1359, 0.2518, -0.2488]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_large_1k_224_ema.pt":
    __UpperCAmelCase  :     Optional[int]		=    torch.tensor([-0.0673, -0.5627, -0.3753, -0.2722, 0.0178]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_huge_1k_224_ema.pt":
    __UpperCAmelCase  :     Any		=    torch.tensor([-0.6377, -0.7458, -0.2150, 0.1184, -0.0597]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_224_ema.pt":
    __UpperCAmelCase  :     Dict		=    torch.tensor([1.0799, 0.2322, -0.8860, 1.0219, 0.6231]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_384_ema.pt":
    __UpperCAmelCase  :     str		=    torch.tensor([0.3766, 0.4917, -1.1426, 0.9942, 0.6024]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_224_ema.pt":
    __UpperCAmelCase  :     str		=    torch.tensor([0.4220, -0.6919, -0.4317, -0.2881, -0.6609]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_384_ema.pt":
    __UpperCAmelCase  :     Any		=    torch.tensor([0.1082, -0.8286, -0.5095, 0.4681, -0.8085]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_224_ema.pt":
    __UpperCAmelCase  :     Optional[int]		=    torch.tensor([-0.2419, -0.6221, 0.2176, -0.0980, -0.7527]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_384_ema.pt":
    __UpperCAmelCase  :     Union[str, Any]		=    torch.tensor([0.0391, -0.4371, 0.3786, 0.1251, -0.2784]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_224_ema.pt":
    __UpperCAmelCase  :     Union[str, Any]		=    torch.tensor([-0.0504, 0.5636, -0.1729, -0.6507, -0.3949]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_384_ema.pt":
    __UpperCAmelCase  :     Tuple		=    torch.tensor([0.3560, 0.9486, 0.3149, -0.2667, -0.5138]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_384_ema.pt":
    __UpperCAmelCase  :     List[Any]		=    torch.tensor([-0.2469, -0.4550, -0.5853, -0.0810, 0.0309]     )
  elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_512_ema.pt":
    __UpperCAmelCase  :     Dict		=    torch.tensor([-0.3090, 0.0802, -0.0682, -0.1979, -0.2826]     )
  else:
    raise ValueError(F"Unknown URL: {checkpoint_url}"     )

  assert torch.allclose(logits[0, :5]						,					snake_case_						,					atol=1e-3     )
  assert logits.shape == expected_shape
  print('Model outputs match the original results!'     )

  if save_model:
    print('Saving model to local...'     )
    # Create folder to save model
    if not os.path.isdir(snake_case_     ):
      os.mkdir(snake_case_     )

    model.save_pretrained(snake_case_     )
    preprocessor.save_pretrained(snake_case_     )

  __UpperCAmelCase  :     Optional[Any]		=    'convnextv2'
  if "atto" in checkpoint_url:
    model_name += "-atto"
  if "femto" in checkpoint_url:
    model_name += "-femto"
  if "pico" in checkpoint_url:
    model_name += "-pico"
  if "nano" in checkpoint_url:
    model_name += "-nano"
  elif "tiny" in checkpoint_url:
    model_name += "-tiny"
  elif "base" in checkpoint_url:
    model_name += "-base"
  elif "large" in checkpoint_url:
    model_name += "-large"
  elif "huge" in checkpoint_url:
    model_name += "-huge"
  if "22k" in checkpoint_url and "1k" not in checkpoint_url:
    model_name += "-22k"
  elif "22k" in checkpoint_url and "1k" in checkpoint_url:
    model_name += "-22k-1k"
  elif "1k" in checkpoint_url:
    model_name += "-1k"
  if "224" in checkpoint_url:
    model_name += "-224"
  elif "384" in checkpoint_url:
    model_name += "-384"
  elif "512" in checkpoint_url:
    model_name += "-512"

  if push_to_hub:
    print(F"Pushing {model_name} to the hub..."     )
    model.push_to_hub(snake_case_     )
    preprocessor.push_to_hub(snake_case_     )


if __name__ == "__main__":
      _SCREAMING_SNAKE_CASE          = argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '''--checkpoint_url''',
          default='''https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt''',
          type=str,
          help='''URL of the original ConvNeXTV2 checkpoint you\'d like to convert.''',
      )
      parser.add_argument(
          '''--pytorch_dump_folder_path''',
          default='''model''',
          type=str,
          help='''Path to the output PyTorch model directory.''',
      )
      parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
      parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image preprocessor to the hub''')

      _SCREAMING_SNAKE_CASE          = parser.parse_args()
      convert_convnextva_checkpoint(
          args.checkpoint_url, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub
      )








import argparse
import copy
import json
import multiprocessing
import os
import time

from create_dummy_models import COMPOSITE_MODELS, create_tiny_models
from huggingface_hub import ModelFilter, hf_api

import transformers
from transformers import AutoFeatureExtractor, AutoImageProcessor, AutoTokenizer
from transformers.image_processing_utils import BaseImageProcessor





def    _snake_case		()       ->		Optional[int]:
  __UpperCAmelCase  :     Any		=    set()
  # Each auto modeling files contains multiple mappings. Let's get them in a dynamic way.
  for module_name in ["modeling_auto", "modeling_tf_auto", "modeling_flax_auto"]:
    __UpperCAmelCase  :     str		=    getattr(transformers.models.auto						,					snake_case_						,					snake_case_     )
    if module is None:
      continue
    # all mappings in a single auto modeling file
    __UpperCAmelCase  :     Dict		=    [
        x
        for x in dir(snake_case_     )
        if x.endswith('_MAPPING_NAMES'     )
        and (x.startswith('MODEL_'     ) or x.startswith('TF_MODEL_'     ) or x.startswith('FLAX_MODEL_'     ))
    ]
    for name in mapping_names:
      __UpperCAmelCase  :     Optional[int]		=    getattr(snake_case_						,					snake_case_     )
      if mapping is not None:
        for v in mapping.values():
          if isinstance(snake_case_						,					(list, tuple)     ):
            model_names.update(snake_case_     )
          elif isinstance(snake_case_						,					snake_case_     ):
            model_names.add(snake_case_     )

  return sorted(snake_case_     )





def    _snake_case		()       ->		Any:
  # All model names defined in auto mappings
  __UpperCAmelCase  :     int		=    set(get_all_model_names()     )

  with open('tests/utils/tiny_model_summary.json'     ) as fp:
    __UpperCAmelCase  :     Tuple		=    json.load(snake_case_     )
  __UpperCAmelCase  :     int		=    set()
  for model_base_name in tiny_model_info:
    tiny_models_names.update(tiny_model_info[model_base_name]['model_classes']     )

  # Remove a tiny model name if one of its framework implementation hasn't yet a tiny version on the Hub.
  __UpperCAmelCase  :     Tuple		=    model_names.difference(snake_case_     )
  for model_name in copy.copy(snake_case_     ):
    if not model_name.startswith('TF'     ) and F"TF{model_name}" in not_on_hub:
      tiny_models_names.remove(snake_case_     )
    elif model_name.startswith('TF'     ) and model_name[2:] in not_on_hub:
      tiny_models_names.remove(snake_case_     )

  return sorted(snake_case_     )





def    _snake_case		(snake_case_				:    List[str]     )       ->		Tuple:
  __UpperCAmelCase  :     Dict		=    COMPOSITE_MODELS.values()

  # All tiny model base names on Hub
  __UpperCAmelCase  :     Optional[int]		=    get_all_model_names()
  __UpperCAmelCase  :     List[Any]		=    hf_api.list_models(
      filter=ModelFilter(
          author='hf-internal-testing'						,					)     )
  __UpperCAmelCase  :     Dict		=    set()
  for x in models:
    __UpperCAmelCase  :     Union[str, Any]		=    x.modelId
    __UpperCAmelCase, __UpperCAmelCase  :     List[str]		=    model.split('/'     )
    if not model.startswith('tiny-random-'     ):
      continue
    __UpperCAmelCase  :     Optional[Any]		=    model.replace('tiny-random-'						,					''     )
    if not model[0].isupper():
      continue
    if model not in model_names and model not in special_models:
      continue
    _models.add(snake_case_     )

  __UpperCAmelCase  :     Optional[Any]		=    sorted(_models     )
  # All tiny model names on Hub
  __UpperCAmelCase  :     List[Any]		=    {}
  for model in models:
    __UpperCAmelCase  :     Any		=    F"hf-internal-testing/tiny-random-{model}"
    __UpperCAmelCase  :     Optional[Any]		=    model.split('-'     )[0]
    try:
      __UpperCAmelCase  :     Tuple		=    hf_api.repo_info(snake_case_     )
      __UpperCAmelCase  :     Optional[int]		=    {
          'tokenizer_classes': set(),
          'processor_classes': set(),
          'model_classes': set(),
          'sha': repo_info.sha,
      }
    except Exception:
      continue
    try:
      time.sleep(1     )
      __UpperCAmelCase  :     List[Any]		=    AutoTokenizer.from_pretrained(snake_case_     )
      content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__     )
    except Exception:
      pass
    try:
      time.sleep(1     )
      __UpperCAmelCase  :     Optional[int]		=    AutoTokenizer.from_pretrained(snake_case_						,					use_fast=snake_case_     )
      content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__     )
    except Exception:
      pass
    try:
      time.sleep(1     )
      __UpperCAmelCase  :     Optional[int]		=    AutoImageProcessor.from_pretrained(snake_case_     )
      content["processor_classes"].add(img_p.__class__.__name__     )
    except Exception:
      pass
    try:
      time.sleep(1     )
      __UpperCAmelCase  :     Optional[int]		=    AutoFeatureExtractor.from_pretrained(snake_case_     )
      if not isinstance(snake_case_						,					snake_case_     ):
        content["processor_classes"].add(feat_p.__class__.__name__     )
    except Exception:
      pass
    try:
      time.sleep(1     )
      __UpperCAmelCase  :     Tuple		=    getattr(snake_case_						,					snake_case_     )
      __UpperCAmelCase  :     str		=    model_class.from_pretrained(snake_case_     )
      content["model_classes"].add(m.__class__.__name__     )
    except Exception:
      pass
    try:
      time.sleep(1     )
      __UpperCAmelCase  :     Any		=    getattr(snake_case_						,					F"TF{model}"     )
      __UpperCAmelCase  :     List[str]		=    model_class.from_pretrained(snake_case_     )
      content["model_classes"].add(m.__class__.__name__     )
    except Exception:
      pass

    __UpperCAmelCase  :     Optional[int]		=    sorted(content['tokenizer_classes']     )
    __UpperCAmelCase  :     List[str]		=    sorted(content['processor_classes']     )
    __UpperCAmelCase  :     Tuple		=    sorted(content['model_classes']     )

    __UpperCAmelCase  :     str		=    content
    with open(os.path.join(snake_case_						,					'hub_tiny_model_summary.json'     )						,					'w'     ) as fp:
      json.dump(snake_case_						,					snake_case_						,					ensure_ascii=snake_case_						,					indent=4     )


if __name__ == "__main__":
      _SCREAMING_SNAKE_CASE          = argparse.ArgumentParser()
      parser.add_argument('''--num_workers''', default=1, type=int, help='''The number of workers to run.''')
      _SCREAMING_SNAKE_CASE          = parser.parse_args()

      # This has to be `spawn` to avoid hanging forever!
      multiprocessing.set_start_method('''spawn''')

      _SCREAMING_SNAKE_CASE          = '''tiny_models'''
      _SCREAMING_SNAKE_CASE          = True
      _SCREAMING_SNAKE_CASE          = None
      _SCREAMING_SNAKE_CASE          = get_tiny_model_names_from_repo()
      _SCREAMING_SNAKE_CASE          = True
      _SCREAMING_SNAKE_CASE          = True
      _SCREAMING_SNAKE_CASE          = '''hf-internal-testing'''

      create_tiny_models(
          output_path,
          all,
          model_types,
          models_to_skip,
          no_check,
          upload,
          organization,
          token=os.environ.get('''TOKEN''', None),
          num_workers=args.num_workers,
      )





