






"""simple docstring"""





import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	Any:
    """simple docstring"""

    if "cls_token" in name:
        UpperCamelCase__         =    name.replace('cls_token' ,	'vit.embeddings.cls_token'					)
    if "mask_token" in name:
        UpperCamelCase__         =    name.replace('mask_token' ,	'decoder.mask_token'					)
    if "decoder_pos_embed" in name:
        UpperCamelCase__         =    name.replace('decoder_pos_embed' ,	'decoder.decoder_pos_embed'					)
    if "pos_embed" in name and "decoder" not in name:
        UpperCamelCase__         =    name.replace('pos_embed' ,	'vit.embeddings.position_embeddings'					)
    if "patch_embed.proj" in name:
        UpperCamelCase__         =    name.replace('patch_embed.proj' ,	'vit.embeddings.patch_embeddings.projection'					)
    if "patch_embed.norm" in name:
        UpperCamelCase__         =    name.replace('patch_embed.norm' ,	'vit.embeddings.norm'					)
    if "decoder_blocks" in name:
        UpperCamelCase__         =    name.replace('decoder_blocks' ,	'decoder.decoder_layers'					)
    if "blocks" in name:
        UpperCamelCase__         =    name.replace('blocks' ,	'vit.encoder.layer'					)
    if "attn.proj" in name:
        UpperCamelCase__         =    name.replace('attn.proj' ,	'attention.output.dense'					)
    if "attn" in name:
        UpperCamelCase__         =    name.replace('attn' ,	'attention.self'					)
    if "norm1" in name:
        UpperCamelCase__         =    name.replace('norm1' ,	'layernorm_before'					)
    if "norm2" in name:
        UpperCamelCase__         =    name.replace('norm2' ,	'layernorm_after'					)
    if "mlp.fc1" in name:
        UpperCamelCase__         =    name.replace('mlp.fc1' ,	'intermediate.dense'					)
    if "mlp.fc2" in name:
        UpperCamelCase__         =    name.replace('mlp.fc2' ,	'output.dense'					)
    if "decoder_embed" in name:
        UpperCamelCase__         =    name.replace('decoder_embed' ,	'decoder.decoder_embed'					)
    if "decoder_norm" in name:
        UpperCamelCase__         =    name.replace('decoder_norm' ,	'decoder.decoder_norm'					)
    if "decoder_pred" in name:
        UpperCamelCase__         =    name.replace('decoder_pred' ,	'decoder.decoder_pred'					)
    if "norm.weight" in name and "decoder" not in name:
        UpperCamelCase__         =    name.replace('norm.weight' ,	'vit.layernorm.weight'					)
    if "norm.bias" in name and "decoder" not in name:
        UpperCamelCase__         =    name.replace('norm.bias' ,	'vit.layernorm.bias'					)

    return name







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)					->	Any:
    """simple docstring"""

    for key in orig_state_dict.copy().keys():
        UpperCamelCase__         =    orig_state_dict.pop(SCREAMING_SNAKE_CASE					)

        if "qkv" in key:
            UpperCamelCase__         =    key.split('.'					)
            UpperCamelCase__         =    int(key_split[1]					)
            if "decoder_blocks" in key:
                UpperCamelCase__         =    config.decoder_hidden_size
                UpperCamelCase__         =    'decoder.decoder_layers.'
                if "weight" in key:
                    UpperCamelCase__         =    val[:dim, :]
                    UpperCamelCase__         =    val[dim : dim * 2, :]
                    UpperCamelCase__         =    val[-dim:, :]
                elif "bias" in key:
                    UpperCamelCase__         =    val[:dim]
                    UpperCamelCase__         =    val[dim : dim * 2]
                    UpperCamelCase__         =    val[-dim:]
            else:
                UpperCamelCase__         =    config.hidden_size
                UpperCamelCase__         =    'vit.encoder.layer.'
                if "weight" in key:
                    UpperCamelCase__         =    val[:dim, :]
                    UpperCamelCase__         =    val[dim : dim * 2, :]
                    UpperCamelCase__         =    val[-dim:, :]
                elif "bias" in key:
                    UpperCamelCase__         =    val[:dim]
                    UpperCamelCase__         =    val[dim : dim * 2]
                    UpperCamelCase__         =    val[-dim:]

        else:
            UpperCamelCase__         =    val

    return orig_state_dict







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)					->	Dict:
    """simple docstring"""

    UpperCamelCase__         =    ViTMAEConfig()
    if "large" in checkpoint_url:
        UpperCamelCase__         =    10_24
        UpperCamelCase__         =    40_96
        UpperCamelCase__         =    24
        UpperCamelCase__         =    16
    elif "huge" in checkpoint_url:
        UpperCamelCase__         =    14
        UpperCamelCase__         =    12_80
        UpperCamelCase__         =    51_20
        UpperCamelCase__         =    32
        UpperCamelCase__         =    16

    UpperCamelCase__         =    ViTMAEForPreTraining(SCREAMING_SNAKE_CASE					)

    UpperCamelCase__         =    torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE ,	map_location='cpu'					)['model']

    UpperCamelCase__         =    ViTMAEImageProcessor(size=config.image_size					)

    UpperCamelCase__         =    convert_state_dict(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)

    model.load_state_dict(SCREAMING_SNAKE_CASE					)
    model.eval()

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

    UpperCamelCase__         =    Image.open(requests.get(SCREAMING_SNAKE_CASE ,	stream=SCREAMING_SNAKE_CASE					).raw					)
    UpperCamelCase__         =    ViTMAEImageProcessor(size=config.image_size					)
    UpperCamelCase__         =    image_processor(images=SCREAMING_SNAKE_CASE ,	return_tensors='pt'					)

    # forward pass
    torch.manual_seed(2					)
    UpperCamelCase__         =    model(**SCREAMING_SNAKE_CASE					)
    UpperCamelCase__         =    outputs.logits

    if "large" in checkpoint_url:
        UpperCamelCase__         =    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:
        UpperCamelCase__         =    torch.tensor(
            [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]]					)
    else:
        UpperCamelCase__         =    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] ,	SCREAMING_SNAKE_CASE ,	atol=1E-4					)

    print(F'Saving model to {pytorch_dump_folder_path}'					)
    model.save_pretrained(SCREAMING_SNAKE_CASE					)

    print(F'Saving image processor to {pytorch_dump_folder_path}'					)
    image_processor.save_pretrained(SCREAMING_SNAKE_CASE					)


if __name__ == "__main__":
  A__					: int=	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."""
  )

  A__					: List[Any]=	parser.parse_args()
  convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)












"""simple docstring"""





import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
  import tensorflow as tf

if is_tensorflow_text_available():
  from transformers.models.bert import TFBertTokenizer


A__					: List[Any]=	["""bert-base-uncased""", """bert-base-cased"""]
A__					: Optional[int]=	"""hf-internal-testing/tiny-bert-tf-only"""

if is_tf_available():
  class    __lowerCamelCase    (  tf.keras.Model  ):

     def __init__(					self ,				snake_case_      )		->       Optional[int]:
         super().__init__()
         UpperCamelCase__         =    tokenizer
         UpperCamelCase__         =    AutoConfig.from_pretrained(snake_case_      )
         UpperCamelCase__         =    TFAutoModel.from_config(snake_case_      )







     def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       int:
         UpperCamelCase__         =    self.tokenizer(snake_case_      )
         UpperCamelCase__         =    self.bert(**snake_case_      )
         return out["pooler_output"]
@require_tf
@require_tensorflow_text
class    __lowerCamelCase    (  unittest.TestCase  ):

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       super().setUp()

       UpperCamelCase__         =    [
           BertTokenizer.from_pretrained(snake_case_      ) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
       ]  # repeat for when fast_bert_tokenizer=false
       UpperCamelCase__         =    [TFBertTokenizer.from_pretrained(snake_case_      ) for checkpoint in TOKENIZER_CHECKPOINTS] + [
           TFBertTokenizer.from_pretrained(snake_case_ ,				use_fast_bert_tokenizer=snake_case_      )
           for checkpoint in TOKENIZER_CHECKPOINTS
       ]
       assert len(self.tokenizers      ) == len(self.tf_tokenizers      )

       UpperCamelCase__         =    [
           'This is a straightforward English test sentence.',
           'This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.',
           'Now we\'re going to add some Chinese: 一 二 三 一二三',
           'And some much more rare Chinese: 齉 堃 齉堃',
           'Je vais aussi écrire en français pour tester les accents',
           'Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ',
       ]
       UpperCamelCase__         =    list(zip(self.test_sentences ,				self.test_sentences[::-1]      )      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       for tokenizer, tf_tokenizer in zip(self.tokenizers ,				self.tf_tokenizers      ):
           for test_inputs in (self.test_sentences, self.paired_sentences):
               UpperCamelCase__         =    tokenizer(snake_case_ ,				return_tensors='tf' ,				padding='longest'      )
               UpperCamelCase__         =    tf_tokenizer(snake_case_      )

               for key in python_outputs.keys():
                   self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape      )      )
                   self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key] ,				tf.intaa      ) == tf_outputs[key]      )      )

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       for tf_tokenizer in self.tf_tokenizers:
           UpperCamelCase__         =    tf_tokenizer(self.paired_sentences      )
           UpperCamelCase__         =    tf_tokenizer(
               text=[sentence[0] for sentence in self.paired_sentences] ,				text_pair=[sentence[1] for sentence in self.paired_sentences] ,				)
           for key in merged_outputs.keys():
               self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key] ,				tf.intaa      ) == separated_outputs[key]      )      )

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       for tf_tokenizer in self.tf_tokenizers:
           UpperCamelCase__         =    tf.function(snake_case_      )
           for test_inputs in (self.test_sentences, self.paired_sentences):
               UpperCamelCase__         =    tf.constant(snake_case_      )
               UpperCamelCase__         =    compiled_tokenizer(snake_case_      )
               UpperCamelCase__         =    tf_tokenizer(snake_case_      )

               for key in eager_outputs.keys():
                   self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]      )      )







   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       for tf_tokenizer in self.tf_tokenizers:
           UpperCamelCase__         =    ModelToSave(tokenizer=snake_case_      )
           UpperCamelCase__         =    tf.convert_to_tensor(self.test_sentences      )
           UpperCamelCase__         =    model(snake_case_      )  # Build model with some sample inputs
           with TemporaryDirectory() as tempdir:
               UpperCamelCase__         =    Path(snake_case_      ) / 'saved.model'
               model.save(snake_case_      )
               UpperCamelCase__         =    tf.keras.models.load_model(snake_case_      )
           UpperCamelCase__         =    loaded_model(snake_case_      )
           # We may see small differences because the loaded model is compiled, so we need an epsilon for the test
           self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output      )      ) ,				1E-5      )




