




'''simple docstring'''







import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor



def        lowerCamelCase__				(      __lowercase				):
     if "cls_token" in name:
          snake_case			:      int        =			name.replace("""cls_token"""     ,   """vit.embeddings.cls_token"""				)
     if "mask_token" in name:
          snake_case			:      List[str]        =			name.replace("""mask_token"""     ,   """decoder.mask_token"""				)
     if "decoder_pos_embed" in name:
          snake_case			:      Dict        =			name.replace("""decoder_pos_embed"""     ,   """decoder.decoder_pos_embed"""				)
     if "pos_embed" in name and "decoder" not in name:
          snake_case			:      str        =			name.replace("""pos_embed"""     ,   """vit.embeddings.position_embeddings"""				)
     if "patch_embed.proj" in name:
          snake_case			:      Optional[int]        =			name.replace("""patch_embed.proj"""     ,   """vit.embeddings.patch_embeddings.projection"""				)
     if "patch_embed.norm" in name:
          snake_case			:      Union[str, Any]        =			name.replace("""patch_embed.norm"""     ,   """vit.embeddings.norm"""				)
     if "decoder_blocks" in name:
          snake_case			:      Dict        =			name.replace("""decoder_blocks"""     ,   """decoder.decoder_layers"""				)
     if "blocks" in name:
          snake_case			:      int        =			name.replace("""blocks"""     ,   """vit.encoder.layer"""				)
     if "attn.proj" in name:
          snake_case			:      List[Any]        =			name.replace("""attn.proj"""     ,   """attention.output.dense"""				)
     if "attn" in name:
          snake_case			:      Optional[int]        =			name.replace("""attn"""     ,   """attention.self"""				)
     if "norm1" in name:
          snake_case			:      Optional[int]        =			name.replace("""norm1"""     ,   """layernorm_before"""				)
     if "norm2" in name:
          snake_case			:      List[str]        =			name.replace("""norm2"""     ,   """layernorm_after"""				)
     if "mlp.fc1" in name:
          snake_case			:      Tuple        =			name.replace("""mlp.fc1"""     ,   """intermediate.dense"""				)
     if "mlp.fc2" in name:
          snake_case			:      Dict        =			name.replace("""mlp.fc2"""     ,   """output.dense"""				)
     if "decoder_embed" in name:
          snake_case			:      int        =			name.replace("""decoder_embed"""     ,   """decoder.decoder_embed"""				)
     if "decoder_norm" in name:
          snake_case			:      str        =			name.replace("""decoder_norm"""     ,   """decoder.decoder_norm"""				)
     if "decoder_pred" in name:
          snake_case			:      str        =			name.replace("""decoder_pred"""     ,   """decoder.decoder_pred"""				)
     if "norm.weight" in name and "decoder" not in name:
          snake_case			:      Any        =			name.replace("""norm.weight"""     ,   """vit.layernorm.weight"""				)
     if "norm.bias" in name and "decoder" not in name:
          snake_case			:      int        =			name.replace("""norm.bias"""     ,   """vit.layernorm.bias"""				)

     return name



def        lowerCamelCase__				(      __lowercase     ,   __lowercase				):
     for key in orig_state_dict.copy().keys():
          snake_case			:      str        =			orig_state_dict.pop(_lowerCamelCase				)

          if "qkv" in key:
               snake_case			:      Union[str, Any]        =			key.split("""."""				)
               snake_case			:      int        =			int(key_split[1]				)
               if "decoder_blocks" in key:
                    snake_case			:      List[Any]        =			config.decoder_hidden_size
                    snake_case			:      Optional[Any]        =			"""decoder.decoder_layers."""
                    if "weight" in key:
                         snake_case			:      List[Any]        =			val[:dim, :]
                         snake_case			:      Union[str, Any]        =			val[dim : dim * 2, :]
                         snake_case			:      Optional[Any]        =			val[-dim:, :]
                    elif "bias" in key:
                         snake_case			:      Any        =			val[:dim]
                         snake_case			:      Optional[int]        =			val[dim : dim * 2]
                         snake_case			:      Any        =			val[-dim:]
               else:
                    snake_case			:      List[str]        =			config.hidden_size
                    snake_case			:      int        =			"""vit.encoder.layer."""
                    if "weight" in key:
                         snake_case			:      Optional[int]        =			val[:dim, :]
                         snake_case			:      List[Any]        =			val[dim : dim * 2, :]
                         snake_case			:      str        =			val[-dim:, :]
                    elif "bias" in key:
                         snake_case			:      Union[str, Any]        =			val[:dim]
                         snake_case			:      List[str]        =			val[dim : dim * 2]
                         snake_case			:      Tuple        =			val[-dim:]

          else:
               snake_case			:      List[str]        =			val

     return orig_state_dict



def        lowerCamelCase__				(      __lowercase     ,   __lowercase				):
     snake_case			:      Dict        =			ViTMAEConfig()
     if "large" in checkpoint_url:
          snake_case			:      Dict        =			1_024
          snake_case			:      Tuple        =			4_096
          snake_case			:      List[str]        =			24
          snake_case			:      List[Any]        =			16
     elif "huge" in checkpoint_url:
          snake_case			:      Any        =			14
          snake_case			:      Dict        =			1_280
          snake_case			:      Optional[int]        =			5_120
          snake_case			:      List[Any]        =			32
          snake_case			:      Union[str, Any]        =			16

     snake_case			:      Dict        =			ViTMAEForPreTraining(_lowerCamelCase				)

     snake_case			:      Optional[int]        =			torch.hub.load_state_dict_from_url(_lowerCamelCase     ,   map_location="""cpu"""				)["""model"""]

     snake_case			:      List[str]        =			ViTMAEImageProcessor(size=config.image_size				)

     snake_case			:      Optional[int]        =			convert_state_dict(_lowerCamelCase     ,   _lowerCamelCase				)

     model.load_state_dict(_lowerCamelCase				)
     model.eval()

     snake_case			:      Any        =			"""https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg"""

     snake_case			:      Tuple        =			Image.open(requests.get(_lowerCamelCase     ,   stream=_lowerCamelCase				).raw				)
     snake_case			:      Dict        =			ViTMAEImageProcessor(size=config.image_size				)
     snake_case			:      Optional[int]        =			image_processor(images=_lowerCamelCase     ,   return_tensors="""pt"""				)

     # forward pass
     torch.manual_seed(2				)
     snake_case			:      Optional[int]        =			model(**_lowerCamelCase				)
     snake_case			:      Union[str, Any]        =			outputs.logits

     if "large" in checkpoint_url:
          snake_case			:      List[str]        =			torch.tensor(
              [[-0.7309, -0.7128, -1.0169], [-1.0161, -0.9058, -1.1878], [-1.0478, -0.9411, -1.1911]]				)
     elif "huge" in checkpoint_url:
          snake_case			:      Any        =			torch.tensor(
              [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]]				)
     else:
          snake_case			:      str        =			torch.tensor(
              [[-0.9192, -0.8481, -1.1259], [-1.1349, -1.0034, -1.2599], [-1.1757, -1.0429, -1.2726]]				)

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

     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				)


if __name__ == "__main__":
      lowercase      :   List[Any]      =       argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          """--checkpoint_url""",
          default="""https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth""",
          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."""
      )

      lowercase      :   int      =       parser.parse_args()
      convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)










'''simple docstring'''

# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowerCAmelCase				:      Optional[int]						      ={
    "configuration_vivit": ["VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "VivitConfig"],
}
try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __lowerCAmelCase				:      int						      =["VivitImageProcessor"]


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __lowerCAmelCase				:      int						      =[
      "VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST",
      "VivitModel",
      "VivitPreTrainedModel",
      "VivitForVideoClassification",
  ]


if TYPE_CHECKING:
  from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_vivit import VivitImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_vivit import (
        VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
        VivitForVideoClassification,
        VivitModel,
        VivitPreTrainedModel,
    )


else:
  import sys

  __lowerCAmelCase				:      List[Any]						      =_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



