



"""simple docstring"""
import time
from dataclasses import dataclass
from multiprocessing import Pool
from unittest import TestCase
from unittest.mock import patch

import multiprocess
import numpy as np
import pytest

from datasets.utils.py_utils import (
    NestedDataStructure,
    asdict,
    iflatmap_unordered,
    map_nested,
    temp_seed,
    temporary_assignment,
    zip_dict,
)

from .utils import require_tf, require_torch





def      __magic_name__				(							lowercase ):  # picklable for multiprocessing
   return x.sum()





def      __magic_name__				(							lowercase ):  # picklable for multiprocessing
   return i + 1
@dataclass
class 					a	:
  UpperCamelCase	:				int
  UpperCamelCase	:				str







class 					a	(  UpperCAmelCase__       ):



  def 	lowerCamelCase__       (						self :					int		)     ->					List[Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Optional[int]     			={}
     SCREAMING_SNAKE_CASE_: Optional[Any]     			=[]
     SCREAMING_SNAKE_CASE_: List[str]     			=1
     SCREAMING_SNAKE_CASE_: List[Any]     			=[1, 2]
     SCREAMING_SNAKE_CASE_: Optional[int]     			={"""a""": 1, """b""": 2}
     SCREAMING_SNAKE_CASE_: Tuple     			={"""a""": [1, 2], """b""": [3, 4]}
     SCREAMING_SNAKE_CASE_: Optional[Any]     			={"""a""": {"""1""": 1}, """b""": 2}
     SCREAMING_SNAKE_CASE_: List[str]     			={"""a""": 1, """b""": 2, """c""": 3, """d""": 4}
     SCREAMING_SNAKE_CASE_: List[str]     			={}
     SCREAMING_SNAKE_CASE_: Dict     			=[]
     SCREAMING_SNAKE_CASE_: Dict     			=2
     SCREAMING_SNAKE_CASE_: Any     			=[2, 3]
     SCREAMING_SNAKE_CASE_: Dict     			={"""a""": 2, """b""": 3}
     SCREAMING_SNAKE_CASE_: Any     			={"""a""": [2, 3], """b""": [4, 5]}
     SCREAMING_SNAKE_CASE_: str     			={"""a""": {"""1""": 2}, """b""": 3}
     SCREAMING_SNAKE_CASE_: str     			={"""a""": 2, """b""": 3, """c""": 4, """d""": 5}
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase		)       ,		lowerCAmelCase		)

     SCREAMING_SNAKE_CASE_: Tuple     			=2
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		num_proc=lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		num_proc=lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		num_proc=lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		num_proc=lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		num_proc=lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		num_proc=lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		num_proc=lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		num_proc=lowerCAmelCase		)       ,		lowerCAmelCase		)

     SCREAMING_SNAKE_CASE_: Tuple     			={"""a""": np.eye(2		), """b""": np.zeros(3		), """c""": np.ones(2		)}
     SCREAMING_SNAKE_CASE_: Tuple     			={"""a""": 2, """b""": 0, """c""": 2}
     SCREAMING_SNAKE_CASE_: str     			={
         """a""": np.eye(2		).astype(lowerCAmelCase		),
         """b""": np.zeros(3		).astype(lowerCAmelCase		),
         """c""": np.ones(2		).astype(lowerCAmelCase		),
     }
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		map_numpy=lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(
         {k: v.tolist() for k, v in map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		map_numpy=lowerCAmelCase		).items()}       ,		{k: v.tolist() for k, v in expected_map_nested_sna_int.items()}       ,		)
     self.assertEqual(map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		map_numpy=lowerCAmelCase       ,		num_proc=lowerCAmelCase		)       ,		lowerCAmelCase		)
     self.assertEqual(
         {k: v.tolist() for k, v in map_nested(lowerCAmelCase       ,		lowerCAmelCase       ,		map_numpy=lowerCAmelCase       ,		num_proc=lowerCAmelCase		).items()}       ,		{k: v.tolist() for k, v in expected_map_nested_sna_int.items()}       ,		)
     with self.assertRaises(lowerCAmelCase		):  # can't pickle a local lambda
        map_nested(lambda lowerCAmelCase		: x + 1       ,		lowerCAmelCase       ,		num_proc=lowerCAmelCase		)



  def 	lowerCamelCase__       (						self :					List[Any]		)     ->					Optional[int]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Union[str, Any]     			={"""a""": 1, """b""": 2}
     SCREAMING_SNAKE_CASE_: int     			={"""a""": 3, """b""": 4}
     SCREAMING_SNAKE_CASE_: Any     			={"""a""": 5, """b""": 6}
     SCREAMING_SNAKE_CASE_: Optional[Any]     			=sorted([("""a""", (1, 3, 5)), ("""b""", (2, 4, 6))]		)
     self.assertEqual(sorted(zip_dict(lowerCAmelCase       ,		lowerCAmelCase       ,		lowerCAmelCase		)		)       ,		lowerCAmelCase		)





  def 	lowerCamelCase__       (						self :					List[Any]		)     ->					Tuple:


     '''simple docstring'''




     class 					a	:
       UpperCamelCase	:				int     						=					'bar'







     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=Foo()
     self.assertEqual(foo.my_attr       ,		"""bar"""		)
     with temporary_assignment(lowerCAmelCase       ,		"""my_attr"""       ,		"""BAR"""		):
        self.assertEqual(foo.my_attr       ,		"""BAR"""		)
     self.assertEqual(foo.my_attr       ,		"""bar"""		)







@pytest.mark.parametrize(
    """iterable_length, num_proc, expected_num_proc"""							,			[
        (1, None, 1),
        (1, 1, 1),
        (2, None, 1),
        (2, 1, 1),
        (2, 2, 1),
        (2, 3, 1),
        (3, 2, 1),
        (16, 16, 16),
        (16, 17, 16),
        (17, 16, 16),
    ]							,			)
def      __magic_name__				(							lowercase							,			lowercase							,			lowercase ):
   with patch("""datasets.utils.py_utils._single_map_nested""" ) as mock_single_map_nested, patch(
       """datasets.parallel.parallel.Pool""" ) as mock_multiprocessing_pool:
      SCREAMING_SNAKE_CASE_: Dict     			={f'''{i}''': i for i in range(lowercase )}
      SCREAMING_SNAKE_CASE_: List[str]     			=map_nested(lambda lowercase : x + 10							,			lowercase							,			num_proc=lowercase							,			parallel_min_length=16 )
      if expected_num_proc == 1:
         assert mock_single_map_nested.called
         assert not mock_multiprocessing_pool.called
      else:
         assert not mock_single_map_nested.called
         assert mock_multiprocessing_pool.called
         assert mock_multiprocessing_pool.call_args[0][0] == expected_num_proc
class 					a	(  UpperCAmelCase__       ):



  @require_tf
  def 	lowerCamelCase__       (						self :					Tuple		)     ->					int:


     '''simple docstring'''




     import tensorflow as tf
     from tensorflow.keras import layers

     SCREAMING_SNAKE_CASE_: Dict     			=layers.Dense(2		)

     def gen_random_output():
        SCREAMING_SNAKE_CASE_: int     			=tf.random.uniform((1, 3)		)
        return model(lowerCAmelCase		).numpy()

     with temp_seed(42       ,		set_tensorflow=lowerCAmelCase		):
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=gen_random_output()
     with temp_seed(42       ,		set_tensorflow=lowerCAmelCase		):
        SCREAMING_SNAKE_CASE_: Any     			=gen_random_output()
     SCREAMING_SNAKE_CASE_: str     			=gen_random_output()

     np.testing.assert_equal(lowerCAmelCase       ,		lowerCAmelCase		)
     self.assertGreater(np.abs(outa - outa		).sum()       ,		0		)



  @require_torch
  def 	lowerCamelCase__       (						self :					Optional[Any]		)     ->					int:


     '''simple docstring'''




     import torch

     def gen_random_output():
        SCREAMING_SNAKE_CASE_: int     			=torch.nn.Linear(3       ,		2		)
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=torch.rand(1       ,		3		)
        return model(lowerCAmelCase		).detach().numpy()

     with temp_seed(42       ,		set_pytorch=lowerCAmelCase		):
        SCREAMING_SNAKE_CASE_: Optional[Any]     			=gen_random_output()
     with temp_seed(42       ,		set_pytorch=lowerCAmelCase		):
        SCREAMING_SNAKE_CASE_: Optional[int]     			=gen_random_output()
     SCREAMING_SNAKE_CASE_: str     			=gen_random_output()

     np.testing.assert_equal(lowerCAmelCase       ,		lowerCAmelCase		)
     self.assertGreater(np.abs(outa - outa		).sum()       ,		0		)





  def 	lowerCamelCase__       (						self :					Tuple		)     ->					str:


     '''simple docstring'''




     def gen_random_output():
        return np.random.rand(1       ,		3		)

     with temp_seed(42		):
        SCREAMING_SNAKE_CASE_: Union[str, Any]     			=gen_random_output()
     with temp_seed(42		):
        SCREAMING_SNAKE_CASE_: Dict     			=gen_random_output()
     SCREAMING_SNAKE_CASE_: Optional[Any]     			=gen_random_output()

     np.testing.assert_equal(lowerCAmelCase       ,		lowerCAmelCase		)
     self.assertGreater(np.abs(outa - outa		).sum()       ,		0		)







@pytest.mark.parametrize("""input_data"""							,			[{}] )
def      __magic_name__				(							lowercase ):
   SCREAMING_SNAKE_CASE_: List[Any]     			=NestedDataStructure(lowercase ).data
   assert output_data == input_data





@pytest.mark.parametrize(
    """data, expected_output"""							,			[
        ({}, []),
        ([], []),
        ("""foo""", ["""foo"""]),
        (["""foo""", """bar"""], ["""foo""", """bar"""]),
        ([["""foo""", """bar"""]], ["""foo""", """bar"""]),
        ([[["""foo"""], ["""bar"""]]], ["""foo""", """bar"""]),
        ([[["""foo"""], """bar"""]], ["""foo""", """bar"""]),
        ({"""a""": 1, """b""": 2}, [1, 2]),
        ({"""a""": [1, 2], """b""": [3, 4]}, [1, 2, 3, 4]),
        ({"""a""": [[1, 2]], """b""": [[3, 4]]}, [1, 2, 3, 4]),
        ({"""a""": [[1, 2]], """b""": [3, 4]}, [1, 2, 3, 4]),
        ({"""a""": [[[1], [2]]], """b""": [[[3], [4]]]}, [1, 2, 3, 4]),
        ({"""a""": [[[1], [2]]], """b""": [[3, 4]]}, [1, 2, 3, 4]),
        ({"""a""": [[[1], [2]]], """b""": [3, 4]}, [1, 2, 3, 4]),
        ({"""a""": [[[1], [2]]], """b""": [3, [4]]}, [1, 2, 3, 4]),
        ({"""a""": {"""1""": 1}, """b""": 2}, [1, 2]),
        ({"""a""": {"""1""": [1]}, """b""": 2}, [1, 2]),
        ({"""a""": {"""1""": [1]}, """b""": [2]}, [1, 2]),
    ]							,			)
def      __magic_name__				(							lowercase							,			lowercase ):
   SCREAMING_SNAKE_CASE_: Tuple     			=NestedDataStructure(lowercase ).flatten()
   assert output == expected_output





def      __magic_name__				(							):
   SCREAMING_SNAKE_CASE_: int     			=A(x=1							,			y="""foobar""" )
   SCREAMING_SNAKE_CASE_: List[str]     			={"""x""": 1, """y""": """foobar"""}
   assert asdict(lowercase ) == expected_output

   SCREAMING_SNAKE_CASE_: Optional[Any]     			={"""a""": {"""b""": A(x=10							,			y="""foo""" )}, """c""": [A(x=20							,			y="""bar""" )]}
   SCREAMING_SNAKE_CASE_: List[str]     			={"""a""": {"""b""": {"""x""": 10, """y""": """foo"""}}, """c""": [{"""x""": 20, """y""": """bar"""}]}
   assert asdict(lowercase ) == expected_output

   with pytest.raises(lowercase ):
      asdict([1, A(x=10							,			y="""foo""" )] )





def      __magic_name__				(							lowercase ):
   return text.split()





def      __magic_name__				(							lowercase ):
   yield (time.time(), content)
   time.sleep(2 )
   yield (time.time(), content)





def      __magic_name__				(							):
   with Pool(2 ) as pool:
      SCREAMING_SNAKE_CASE_: Any     			=list(iflatmap_unordered(lowercase							,			_split_text							,			kwargs_iterable=[{"""text""": """hello there"""}] * 10 ) )
      assert out.count("""hello""" ) == 10
      assert out.count("""there""" ) == 10
      assert len(lowercase ) == 20

   # check multiprocess from pathos (uses dill for pickling)
   with multiprocess.Pool(2 ) as pool:
      SCREAMING_SNAKE_CASE_: Union[str, Any]     			=list(iflatmap_unordered(lowercase							,			_split_text							,			kwargs_iterable=[{"""text""": """hello there"""}] * 10 ) )
      assert out.count("""hello""" ) == 10
      assert out.count("""there""" ) == 10
      assert len(lowercase ) == 20

   # check that we get items as fast as possible
   with Pool(2 ) as pool:
      SCREAMING_SNAKE_CASE_: Optional[int]     			=[]
      for yield_time, content in iflatmap_unordered(
          lowercase							,			_aseconds_generator_of_aitems_with_timing							,			kwargs_iterable=[{"""content""": """a"""}, {"""content""": """b"""}] ):
         assert yield_time < time.time() + 0.1, "we should each item directly after it was yielded"
         out.append(lowercase )
      assert out.count("""a""" ) == 2
      assert out.count("""b""" ) == 2
      assert len(lowercase ) == 4








"""simple docstring"""
import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor





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

   return name





def      __magic_name__				(							lowercase							,			lowercase ):
   for key in orig_state_dict.copy().keys():
      SCREAMING_SNAKE_CASE_: Optional[int]     			=orig_state_dict.pop(lowercase )

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

      else:
         SCREAMING_SNAKE_CASE_: Tuple     			=val

   return orig_state_dict





def      __magic_name__				(							lowercase							,			lowercase ):
   SCREAMING_SNAKE_CASE_: Dict     			=ViTMAEConfig()
   if "large" in checkpoint_url:
      SCREAMING_SNAKE_CASE_: List[Any]     			=1024
      SCREAMING_SNAKE_CASE_: Dict     			=4096
      SCREAMING_SNAKE_CASE_: Tuple     			=24
      SCREAMING_SNAKE_CASE_: int     			=16
   elif "huge" in checkpoint_url:
      SCREAMING_SNAKE_CASE_: Union[str, Any]     			=14
      SCREAMING_SNAKE_CASE_: Any     			=1280
      SCREAMING_SNAKE_CASE_: Dict     			=5120
      SCREAMING_SNAKE_CASE_: Optional[int]     			=32
      SCREAMING_SNAKE_CASE_: Optional[Any]     			=16

   SCREAMING_SNAKE_CASE_: Tuple     			=ViTMAEForPreTraining(lowercase )

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

   SCREAMING_SNAKE_CASE_: Optional[Any]     			=ViTMAEImageProcessor(size=config.image_size )

   SCREAMING_SNAKE_CASE_: str     			=convert_state_dict(lowercase							,			lowercase )

   model.load_state_dict(lowercase )
   model.eval()

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

   SCREAMING_SNAKE_CASE_: List[Any]     			=Image.open(requests.get(lowercase							,			stream=lowercase ).raw )
   SCREAMING_SNAKE_CASE_: int     			=ViTMAEImageProcessor(size=config.image_size )
   SCREAMING_SNAKE_CASE_: int     			=image_processor(images=lowercase							,			return_tensors="""pt""" )

   # forward pass
   torch.manual_seed(2 )
   SCREAMING_SNAKE_CASE_: Optional[Any]     			=model(**lowercase )
   SCREAMING_SNAKE_CASE_: Optional[int]     			=outputs.logits

   if "large" in checkpoint_url:
      SCREAMING_SNAKE_CASE_: Dict     			=torch.tensor(
          [[-0.7_309, -0.7_128, -1.0_169], [-1.0_161, -0.9_058, -1.1_878], [-1.0_478, -0.9_411, -1.1_911]] )
   elif "huge" in checkpoint_url:
      SCREAMING_SNAKE_CASE_: Tuple     			=torch.tensor(
          [[-1.1_599, -0.9_199, -1.2_221], [-1.1_952, -0.9_269, -1.2_307], [-1.2_143, -0.9_337, -1.2_262]] )
   else:
      SCREAMING_SNAKE_CASE_: Any     			=torch.tensor(
          [[-0.9_192, -0.8_481, -1.1_259], [-1.1_349, -1.0_034, -1.2_599], [-1.1_757, -1.0_429, -1.2_726]] )

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

   print(f'''Saving model to {pytorch_dump_folder_path}''' )
   model.save_pretrained(lowercase )

   print(f'''Saving image processor to {pytorch_dump_folder_path}''' )
   image_processor.save_pretrained(lowercase )


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

   _UpperCAmelCase     =			parser.parse_args()
   convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)



