
'''simple docstring'''







import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


__lowerCAmelCase         =    logging.get_logger(__name__)

__lowerCAmelCase         =    OrderedDict(
    [
        ("""align""", """EfficientNetImageProcessor"""),
        ("""beit""", """BeitImageProcessor"""),
        ("""bit""", """BitImageProcessor"""),
        ("""blip""", """BlipImageProcessor"""),
        ("""blip-2""", """BlipImageProcessor"""),
        ("""bridgetower""", """BridgeTowerImageProcessor"""),
        ("""chinese_clip""", """ChineseCLIPImageProcessor"""),
        ("""clip""", """CLIPImageProcessor"""),
        ("""clipseg""", """ViTImageProcessor"""),
        ("""conditional_detr""", """ConditionalDetrImageProcessor"""),
        ("""convnext""", """ConvNextImageProcessor"""),
        ("""convnextv2""", """ConvNextImageProcessor"""),
        ("""cvt""", """ConvNextImageProcessor"""),
        ("""data2vec-vision""", """BeitImageProcessor"""),
        ("""deformable_detr""", """DeformableDetrImageProcessor"""),
        ("""deit""", """DeiTImageProcessor"""),
        ("""deta""", """DetaImageProcessor"""),
        ("""detr""", """DetrImageProcessor"""),
        ("""dinat""", """ViTImageProcessor"""),
        ("""donut-swin""", """DonutImageProcessor"""),
        ("""dpt""", """DPTImageProcessor"""),
        ("""efficientformer""", """EfficientFormerImageProcessor"""),
        ("""efficientnet""", """EfficientNetImageProcessor"""),
        ("""flava""", """FlavaImageProcessor"""),
        ("""focalnet""", """BitImageProcessor"""),
        ("""git""", """CLIPImageProcessor"""),
        ("""glpn""", """GLPNImageProcessor"""),
        ("""groupvit""", """CLIPImageProcessor"""),
        ("""imagegpt""", """ImageGPTImageProcessor"""),
        ("""instructblip""", """BlipImageProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2ImageProcessor"""),
        ("""layoutlmv3""", """LayoutLMv3ImageProcessor"""),
        ("""levit""", """LevitImageProcessor"""),
        ("""mask2former""", """Mask2FormerImageProcessor"""),
        ("""maskformer""", """MaskFormerImageProcessor"""),
        ("""mgp-str""", """ViTImageProcessor"""),
        ("""mobilenet_v1""", """MobileNetV1ImageProcessor"""),
        ("""mobilenet_v2""", """MobileNetV2ImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevitv2""", """MobileViTImageProcessor"""),
        ("""nat""", """ViTImageProcessor"""),
        ("""oneformer""", """OneFormerImageProcessor"""),
        ("""owlvit""", """OwlViTImageProcessor"""),
        ("""perceiver""", """PerceiverImageProcessor"""),
        ("""pix2struct""", """Pix2StructImageProcessor"""),
        ("""poolformer""", """PoolFormerImageProcessor"""),
        ("""regnet""", """ConvNextImageProcessor"""),
        ("""resnet""", """ConvNextImageProcessor"""),
        ("""sam""", """SamImageProcessor"""),
        ("""segformer""", """SegformerImageProcessor"""),
        ("""swiftformer""", """ViTImageProcessor"""),
        ("""swin""", """ViTImageProcessor"""),
        ("""swin2sr""", """Swin2SRImageProcessor"""),
        ("""swinv2""", """ViTImageProcessor"""),
        ("""table-transformer""", """DetrImageProcessor"""),
        ("""timesformer""", """VideoMAEImageProcessor"""),
        ("""tvlt""", """TvltImageProcessor"""),
        ("""upernet""", """SegformerImageProcessor"""),
        ("""van""", """ConvNextImageProcessor"""),
        ("""videomae""", """VideoMAEImageProcessor"""),
        ("""vilt""", """ViltImageProcessor"""),
        ("""vit""", """ViTImageProcessor"""),
        ("""vit_hybrid""", """ViTHybridImageProcessor"""),
        ("""vit_mae""", """ViTImageProcessor"""),
        ("""vit_msn""", """ViTImageProcessor"""),
        ("""xclip""", """CLIPImageProcessor"""),
        ("""yolos""", """YolosImageProcessor"""),
    ]
)

__lowerCAmelCase         =    _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)





def 					UpperCAmelCase_		(__a      :    str ):






   """simple docstring"""

   for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
      if class_name in extractors:
         _a				:	Any			=   model_type_to_module_name(snake_case__ )

         _a				:	str			=   importlib.import_module(f""".{module_name}""" ,	'transformers.models' )
         try:
            return getattr(snake_case__ ,	snake_case__ )
         except AttributeError:
            continue

   for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
      if getattr(snake_case__ ,	'__name__' ,	snake_case__ ) == class_name:
         return extractor

      # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
      # init and we return the proper dummy to get an appropriate error message.
   _a				:	Optional[int]			=   importlib.import_module('transformers' )
   if hasattr(snake_case__ ,	snake_case__ ):
      return getattr(snake_case__ ,	snake_case__ )

   return None





def 					UpperCAmelCase_		(__a      :    Union[str, os.PathLike] ,	__a      :    Optional[Union[str, os.PathLike]] = None ,	__a      :    bool = False ,	__a      :    bool = False ,	__a      :    Optional[Dict[str, str]] = None ,	__a      :    Optional[Union[bool, str]] = None ,	__a      :    Optional[str] = None ,	__a      :    bool = False ,	**__a      :    Dict ,	):






   """simple docstring"""

   _a				:	Union[str, Any]			=   get_file_from_repo(
       snake_case__ ,	snake_case__ ,	cache_dir=snake_case__ ,	force_download=snake_case__ ,	resume_download=snake_case__ ,	proxies=snake_case__ ,	use_auth_token=snake_case__ ,	revision=snake_case__ ,	local_files_only=snake_case__ ,	)
   if resolved_config_file is None:
      logger.info(
          'Could not locate the image processor configuration file, will try to use the model config instead.' )
      return {}

   with open(snake_case__ ,	encoding='utf-8' ) as reader:
      return json.load(snake_case__ )







class UpperCAmelCase__	:





  """simple docstring"""

  def __init__(		self      :     Optional[int]       ):


     '''simple docstring'''






     raise EnvironmentError(
         'AutoImageProcessor is designed to be instantiated '
         'using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.'       )


  @classmethod
  @replace_list_option_in_docstrings(a_       )
  def   __lowercase		(		cls      :     List[str]							,_a      :     Any							,**_a      :     Dict       ):


     '''simple docstring'''






     _a				:	Optional[int]			=   kwargs.pop('config'							,a_       )
     _a				:	Any			=   kwargs.pop('trust_remote_code'							,a_       )
     _a				:	Dict			=   True

     _a				:	Optional[int]			=   ImageProcessingMixin.get_image_processor_dict(a_							,**a_       )
     _a				:	Any			=   config_dict.get('image_processor_type'							,a_       )
     _a				:	Tuple			=   None
     if "AutoImageProcessor" in config_dict.get('auto_map'							,{}       ):
        _a				:	Any			=   config_dict["""auto_map"""]["""AutoImageProcessor"""]

     # If we still don't have the image processor class, check if we're loading from a previous feature extractor config
     # and if so, infer the image processor class from there.
     if image_processor_class is None and image_processor_auto_map is None:
        _a				:	Optional[Any]			=   config_dict.pop('feature_extractor_type'							,a_       )
        if feature_extractor_class is not None:
           logger.warning(
               'Could not find image processor class in the image processor config or the model config. Loading'
               ' based on pattern matching with the model\'s feature extractor configuration.'       )
           _a				:	Optional[int]			=   feature_extractor_class.replace('FeatureExtractor'							,'ImageProcessor'       )
        if "AutoFeatureExtractor" in config_dict.get('auto_map'							,{}       ):
           _a				:	Dict			=   config_dict["""auto_map"""]["""AutoFeatureExtractor"""]
           _a				:	List[str]			=   feature_extractor_auto_map.replace('FeatureExtractor'							,'ImageProcessor'       )
           logger.warning(
               'Could not find image processor auto map in the image processor config or the model config.'
               ' Loading based on pattern matching with the model\'s feature extractor configuration.'       )

            # If we don't find the image processor class in the image processor config, let's try the model config.
     if image_processor_class is None and image_processor_auto_map is None:
        if not isinstance(a_							,a_       ):
           _a				:	List[str]			=   AutoConfig.from_pretrained(a_							,**a_       )
        # It could be in `config.image_processor_type``
        _a				:	int			=   getattr(a_							,'image_processor_type'							,a_       )
        if hasattr(a_							,'auto_map'       ) and "AutoImageProcessor" in config.auto_map:
           _a				:	List[Any]			=   config.auto_map["""AutoImageProcessor"""]

     if image_processor_class is not None:
        _a				:	int			=   image_processor_class_from_name(a_       )

     _a				:	List[Any]			=   image_processor_auto_map is not None
     _a				:	Union[str, Any]			=   image_processor_class is not None or type(a_       ) in IMAGE_PROCESSOR_MAPPING
     _a				:	Union[str, Any]			=   resolve_trust_remote_code(
         a_							,a_							,a_							,a_       )

     if has_remote_code and trust_remote_code:
        _a				:	Optional[Any]			=   get_class_from_dynamic_module(
            a_							,a_							,**a_       )
        _a				:	Optional[Any]			=   kwargs.pop('code_revision'							,a_       )
        if os.path.isdir(a_       ):
           image_processor_class.register_for_auto_class()
        return image_processor_class.from_dict(a_							,**a_       )
     elif image_processor_class is not None:
        return image_processor_class.from_dict(a_							,**a_       )
     # Last try: we use the IMAGE_PROCESSOR_MAPPING.
     elif type(a_       ) in IMAGE_PROCESSOR_MAPPING:
        _a				:	Union[str, Any]			=   IMAGE_PROCESSOR_MAPPING[type(a_       )]
        return image_processor_class.from_dict(a_							,**a_       )

     raise ValueError(
         F"""Unrecognized image processor in {pretrained_model_name_or_path}. Should have a """
         F"""`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following """
         F"""`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys()       )}"""       )


  @staticmethod
  def   __lowercase		(		_a      :     Dict							,_a      :     Optional[Any]       ):


     '''simple docstring'''






     IMAGE_PROCESSOR_MAPPING.register(a_							,a_       )









"""simple docstring"""


import argparse
import json

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

from transformers import ViTImageProcessor, ViTMSNConfig, ViTMSNModel
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD


torch.set_grad_enabled(False)


def 					UpperCAmelCase__       (snake_case__							:					str		,   snake_case__							:					List[str]=False    ):
  """simple docstring"""

  _snake_case							:		Optional[Any]								=  []
  for i in range(config.num_hidden_layers    ):
    # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
    rename_keys.append((F"module.blocks.{i}.norm1.weight", F"vit.encoder.layer.{i}.layernorm_before.weight")    )
    rename_keys.append((F"module.blocks.{i}.norm1.bias", F"vit.encoder.layer.{i}.layernorm_before.bias")    )
    rename_keys.append(
        (F"module.blocks.{i}.attn.proj.weight", F"vit.encoder.layer.{i}.attention.output.dense.weight")    )
    rename_keys.append((F"module.blocks.{i}.attn.proj.bias", F"vit.encoder.layer.{i}.attention.output.dense.bias")    )
    rename_keys.append((F"module.blocks.{i}.norm2.weight", F"vit.encoder.layer.{i}.layernorm_after.weight")    )
    rename_keys.append((F"module.blocks.{i}.norm2.bias", F"vit.encoder.layer.{i}.layernorm_after.bias")    )
    rename_keys.append((F"module.blocks.{i}.mlp.fc1.weight", F"vit.encoder.layer.{i}.intermediate.dense.weight")    )
    rename_keys.append((F"module.blocks.{i}.mlp.fc1.bias", F"vit.encoder.layer.{i}.intermediate.dense.bias")    )
    rename_keys.append((F"module.blocks.{i}.mlp.fc2.weight", F"vit.encoder.layer.{i}.output.dense.weight")    )
    rename_keys.append((F"module.blocks.{i}.mlp.fc2.bias", F"vit.encoder.layer.{i}.output.dense.bias")    )

  # projection layer + position embeddings
  rename_keys.extend(
      [
          ("""module.cls_token""", """vit.embeddings.cls_token"""),
          ("""module.patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight"""),
          ("""module.patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias"""),
          ("""module.pos_embed""", """vit.embeddings.position_embeddings"""),
      ]    )

  if base_model:
    # layernorm + pooler
    rename_keys.extend(
        [
            ("""module.norm.weight""", """layernorm.weight"""),
            ("""module.norm.bias""", """layernorm.bias"""),
        ]    )

    # if just the base model, we should remove "vit" from all keys that start with "vit"
    _snake_case							:		Any								=  [(pair[0], pair[1][4:]) if pair[1].startswith("""vit"""    ) else pair for pair in rename_keys]
  else:
    # layernorm + classification head
    rename_keys.extend(
        [
            ("""norm.weight""", """vit.layernorm.weight"""),
            ("""norm.bias""", """vit.layernorm.bias"""),
            ("""head.weight""", """classifier.weight"""),
            ("""head.bias""", """classifier.bias"""),
        ]    )

  return rename_keys


def 					UpperCAmelCase__       (snake_case__							:					Dict		,   snake_case__							:					Dict		,   snake_case__							:					List[str]=False    ):
  """simple docstring"""

  for i in range(config.num_hidden_layers    ):
    if base_model:
      _snake_case							:		List[Any]								=  """"""
    else:
      _snake_case							:		List[Any]								=  """vit."""
    # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
    _snake_case							:		Optional[Any]								=  state_dict.pop(F"module.blocks.{i}.attn.qkv.weight"    )
    _snake_case							:		Optional[Any]								=  state_dict.pop(F"module.blocks.{i}.attn.qkv.bias"    )
    # next, add query, keys and values (in that order) to the state dict
    _snake_case							:		Optional[Any]								=  in_proj_weight[
        : config.hidden_size, :
    ]
    _snake_case							:		Union[str, Any]								=  in_proj_bias[: config.hidden_size]
    _snake_case							:		Union[str, Any]								=  in_proj_weight[
        config.hidden_size : config.hidden_size * 2, :
    ]
    _snake_case							:		Optional[Any]								=  in_proj_bias[
        config.hidden_size : config.hidden_size * 2
    ]
    _snake_case							:		Union[str, Any]								=  in_proj_weight[
        -config.hidden_size :, :
    ]
    _snake_case							:		List[str]								=  in_proj_bias[-config.hidden_size :]


def 					UpperCAmelCase__       (snake_case__							:					str    ):
  """simple docstring"""

  _snake_case							:		Tuple								=  ["""head.weight""", """head.bias"""]
  for k in ignore_keys:
    state_dict.pop(snake_case__		,   snake_case__    )


def 					UpperCAmelCase__       (snake_case__							:					int    ):
  """simple docstring"""

  _snake_case							:		List[str]								=  [
      """module.fc.fc1.weight""",
      """module.fc.fc1.bias""",
      """module.fc.bn1.weight""",
      """module.fc.bn1.bias""",
      """module.fc.bn1.running_mean""",
      """module.fc.bn1.running_var""",
      """module.fc.bn1.num_batches_tracked""",
      """module.fc.fc2.weight""",
      """module.fc.fc2.bias""",
      """module.fc.bn2.weight""",
      """module.fc.bn2.bias""",
      """module.fc.bn2.running_mean""",
      """module.fc.bn2.running_var""",
      """module.fc.bn2.num_batches_tracked""",
      """module.fc.fc3.weight""",
      """module.fc.fc3.bias""",
  ]
  for k in ignore_keys:
    state_dict.pop(snake_case__		,   snake_case__    )


def 					UpperCAmelCase__       (snake_case__							:					List[Any]		,   snake_case__							:					Tuple		,   snake_case__							:					int    ):
  """simple docstring"""

  _snake_case							:		Optional[Any]								=  dct.pop(snake_case__    )
  _snake_case							:		Union[str, Any]								=  val


def 					UpperCAmelCase__       (snake_case__							:					List[Any]		,   snake_case__							:					str    ):
  """simple docstring"""

  _snake_case							:		str								=  ViTMSNConfig()
  _snake_case							:		Any								=  10_00

  _snake_case							:		Tuple								=  """datasets/huggingface/label-files"""
  _snake_case							:		Dict								=  """imagenet-1k-id2label.json"""
  _snake_case							:		int								=  json.load(open(hf_hub_download(snake_case__		,   snake_case__    )		,   """r"""    )    )
  _snake_case							:		Any								=  {int(snake_case__    ): v for k, v in idalabel.items()}
  _snake_case							:		List[Any]								=  idalabel
  _snake_case							:		str								=  {v: k for k, v in idalabel.items()}

  if "s16" in checkpoint_url:
    _snake_case							:		Tuple								=  3_84
    _snake_case							:		Dict								=  15_36
    _snake_case							:		Tuple								=  6
  elif "l16" in checkpoint_url:
    _snake_case							:		Any								=  10_24
    _snake_case							:		int								=  40_96
    _snake_case							:		str								=  24
    _snake_case							:		Optional[int]								=  16
    _snake_case							:		List[Any]								=  0.1
  elif "b4" in checkpoint_url:
    _snake_case							:		Tuple								=  4
  elif "l7" in checkpoint_url:
    _snake_case							:		int								=  7
    _snake_case							:		Dict								=  10_24
    _snake_case							:		Optional[Any]								=  40_96
    _snake_case							:		Any								=  24
    _snake_case							:		Union[str, Any]								=  16
    _snake_case							:		Optional[int]								=  0.1

  _snake_case							:		int								=  ViTMSNModel(snake_case__    )

  _snake_case							:		Optional[int]								=  torch.hub.load_state_dict_from_url(snake_case__		,   map_location="""cpu"""    )["""target_encoder"""]

  _snake_case							:		List[str]								=  ViTImageProcessor(size=config.image_size    )

  remove_projection_head(snake_case__    )
  _snake_case							:		List[str]								=  create_rename_keys(snake_case__		,   base_model=snake_case__    )

  for src, dest in rename_keys:
    rename_key(snake_case__		,   snake_case__		,   snake_case__    )
  read_in_q_k_v(snake_case__		,   snake_case__		,   base_model=snake_case__    )

  model.load_state_dict(snake_case__    )
  model.eval()

  _snake_case							:		Union[str, Any]								=  """http://images.cocodataset.org/val2017/000000039769.jpg"""

  _snake_case							:		Tuple								=  Image.open(requests.get(snake_case__		,   stream=snake_case__    ).raw    )
  _snake_case							:		str								=  ViTImageProcessor(
      size=config.image_size		,   image_mean=snake_case__		,   image_std=snake_case__    )
  _snake_case							:		Any								=  image_processor(images=snake_case__		,   return_tensors="""pt"""    )

  # forward pass
  torch.manual_seed(2    )
  _snake_case							:		int								=  model(**snake_case__    )
  _snake_case							:		List[Any]								=  outputs.last_hidden_state

  # The following Colab Notebook was used to generate these outputs:
  # https://colab.research.google.com/gist/sayakpaul/3672419a04f5997827503fd84079bdd1/scratchpad.ipynb
  if "s16" in checkpoint_url:
    _snake_case							:		Optional[Any]								=  torch.tensor([[-1.09_15, -1.48_76, -1.18_09]]    )
  elif "b16" in checkpoint_url:
    _snake_case							:		str								=  torch.tensor([[14.28_89, -18.90_45, 11.72_81]]    )
  elif "l16" in checkpoint_url:
    _snake_case							:		Optional[int]								=  torch.tensor([[41.50_28, -22.86_81, 45.64_75]]    )
  elif "b4" in checkpoint_url:
    _snake_case							:		List[Any]								=  torch.tensor([[-4.38_68, 5.29_32, -0.41_37]]    )
  else:
    _snake_case							:		Optional[int]								=  torch.tensor([[-0.17_92, -0.64_65, 2.42_63]]    )

  # verify logits
  assert torch.allclose(last_hidden_state[:, 0, :3]		,   snake_case__		,   atol=1e-4    )

  print(F"Saving model to {pytorch_dump_folder_path}"    )
  model.save_pretrained(snake_case__    )

  print(F"Saving image processor to {pytorch_dump_folder_path}"    )
  image_processor.save_pretrained(snake_case__    )


if __name__ == "__main__":
     A_						=				argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '''--checkpoint_url''',
         default='''https://dl.fbaipublicfiles.com/msn/vits16_800ep.pth.tar''',
         type=str,
         help='''URL of the checkpoint you\'d like to convert.''',
     )
     parser.add_argument(
         '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
     )

     A_						=				parser.parse_args()
     convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)


