



import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases





def 		a__      (		_UpperCamelCase      :			Dict			,_UpperCamelCase      :			Any				):
   assert isinstance(_UpperCamelCase			,_UpperCamelCase				)
   assert dataset.num_rows == 4
   assert dataset.num_columns == 3
   assert dataset.column_names == ["col_1", "col_2", "col_3"]
   for feature, expected_dtype in expected_features.items():
      assert dataset.features[feature].dtype == expected_dtype





@pytest.mark.parametrize('''keep_in_memory'''			,[False, True]				)
def 		a__      (		_UpperCamelCase      :			str			,_UpperCamelCase      :			Optional[Any]			,_UpperCamelCase      :			Optional[Any]				):
   __lowerCamelCase    				=     tmp_path / '''cache'''
   __lowerCamelCase    				=     {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
   with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
      __lowerCamelCase    				=     JsonDatasetReader(_UpperCamelCase			,cache_dir=_UpperCamelCase			,keep_in_memory=_UpperCamelCase				).read()
   _check_json_dataset(_UpperCamelCase			,_UpperCamelCase				)





@pytest.mark.parametrize(
    '''features'''			,[
        None,
        {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''},
        {'''col_1''': '''string''', '''col_2''': '''string''', '''col_3''': '''string'''},
        {'''col_1''': '''int32''', '''col_2''': '''int32''', '''col_3''': '''int32'''},
        {'''col_1''': '''float32''', '''col_2''': '''float32''', '''col_3''': '''float32'''},
    ]			,)
def 		a__      (		_UpperCamelCase      :			Optional[Any]			,_UpperCamelCase      :			Union[str, Any]			,_UpperCamelCase      :			Tuple				):
   __lowerCamelCase    				=     tmp_path / '''cache'''
   __lowerCamelCase    				=     {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
   __lowerCamelCase    				=     features.copy() if features else default_expected_features
   __lowerCamelCase    				=     (
       Features({feature: Value(_UpperCamelCase				) for feature, dtype in features.items()}				) if features is not None else None
   )
   __lowerCamelCase    				=     JsonDatasetReader(_UpperCamelCase			,features=_UpperCamelCase			,cache_dir=_UpperCamelCase				).read()
   _check_json_dataset(_UpperCamelCase			,_UpperCamelCase				)





@pytest.mark.parametrize(
    '''features'''			,[
        None,
        {'''col_3''': '''float64''', '''col_1''': '''string''', '''col_2''': '''int64'''},
    ]			,)
def 		a__      (		_UpperCamelCase      :			List[Any]			,_UpperCamelCase      :			List[str]			,_UpperCamelCase      :			List[Any]				):
   __lowerCamelCase    				=     tmp_path / '''cache'''
   __lowerCamelCase    				=     {'''col_3''': '''float64''', '''col_1''': '''string''', '''col_2''': '''int64'''}
   __lowerCamelCase    				=     features.copy() if features else default_expected_features
   __lowerCamelCase    				=     (
       Features({feature: Value(_UpperCamelCase				) for feature, dtype in features.items()}				) if features is not None else None
   )
   __lowerCamelCase    				=     JsonDatasetReader(_UpperCamelCase			,features=_UpperCamelCase			,cache_dir=_UpperCamelCase				).read()
   assert isinstance(_UpperCamelCase			,_UpperCamelCase				)
   assert dataset.num_rows == 2
   assert dataset.num_columns == 3
   assert dataset.column_names == ["col_3", "col_1", "col_2"]
   for feature, expected_dtype in expected_features.items():
      assert dataset.features[feature].dtype == expected_dtype





def 		a__      (		_UpperCamelCase      :			Optional[Any]			,_UpperCamelCase      :			str				):
   # jsonl_312_path features are {"col_3": "float64", "col_1": "string", "col_2": "int64"}
   __lowerCamelCase    				=     {'''col_2''': '''int64''', '''col_3''': '''float64''', '''col_1''': '''string'''}
   __lowerCamelCase    				=     features.copy()
   __lowerCamelCase    				=     (
       Features({feature: Value(_UpperCamelCase				) for feature, dtype in features.items()}				) if features is not None else None
   )
   __lowerCamelCase    				=     tmp_path / '''cache'''
   __lowerCamelCase    				=     JsonDatasetReader(_UpperCamelCase			,features=_UpperCamelCase			,cache_dir=_UpperCamelCase				).read()
   assert isinstance(_UpperCamelCase			,_UpperCamelCase				)
   assert dataset.num_rows == 2
   assert dataset.num_columns == 3
   assert dataset.column_names == ["col_2", "col_3", "col_1"]
   for feature, expected_dtype in expected_features.items():
      assert dataset.features[feature].dtype == expected_dtype





@pytest.mark.parametrize('''split'''			,[None, NamedSplit('''train'''				), '''train''', '''test''']				)
def 		a__      (		_UpperCamelCase      :			List[str]			,_UpperCamelCase      :			Any			,_UpperCamelCase      :			Optional[Any]				):
   __lowerCamelCase    				=     tmp_path / '''cache'''
   __lowerCamelCase    				=     {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
   __lowerCamelCase    				=     JsonDatasetReader(_UpperCamelCase			,cache_dir=_UpperCamelCase			,split=_UpperCamelCase				).read()
   _check_json_dataset(_UpperCamelCase			,_UpperCamelCase				)
   assert dataset.split == split if split else "train"





@pytest.mark.parametrize('''path_type'''			,[str, list]				)
def 		a__      (		_UpperCamelCase      :			Optional[int]			,_UpperCamelCase      :			Optional[int]			,_UpperCamelCase      :			Union[str, Any]				):
   if issubclass(_UpperCamelCase			,_UpperCamelCase				):
      __lowerCamelCase    				=     jsonl_path
   elif issubclass(_UpperCamelCase			,_UpperCamelCase				):
      __lowerCamelCase    				=     [jsonl_path]
   __lowerCamelCase    				=     tmp_path / '''cache'''
   __lowerCamelCase    				=     {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
   __lowerCamelCase    				=     JsonDatasetReader(_UpperCamelCase			,cache_dir=_UpperCamelCase				).read()
   _check_json_dataset(_UpperCamelCase			,_UpperCamelCase				)





def 		a__      (		_UpperCamelCase      :			str			,_UpperCamelCase      :			Any			,_UpperCamelCase      :			List[str]=("train",)				):
   assert isinstance(_UpperCamelCase			,_UpperCamelCase				)
   for split in splits:
      __lowerCamelCase    				=     dataset_dict[split]
      assert dataset.num_rows == 4
      assert dataset.num_columns == 3
      assert dataset.column_names == ["col_1", "col_2", "col_3"]
      for feature, expected_dtype in expected_features.items():
         assert dataset.features[feature].dtype == expected_dtype





@pytest.mark.parametrize('''keep_in_memory'''			,[False, True]				)
def 		a__      (		_UpperCamelCase      :			List[str]			,_UpperCamelCase      :			Dict			,_UpperCamelCase      :			Optional[int]				):
   __lowerCamelCase    				=     tmp_path / '''cache'''
   __lowerCamelCase    				=     {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
   with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
      __lowerCamelCase    				=     JsonDatasetReader({'''train''': jsonl_path}			,cache_dir=_UpperCamelCase			,keep_in_memory=_UpperCamelCase				).read()
   _check_json_datasetdict(_UpperCamelCase			,_UpperCamelCase				)





@pytest.mark.parametrize(
    '''features'''			,[
        None,
        {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''},
        {'''col_1''': '''string''', '''col_2''': '''string''', '''col_3''': '''string'''},
        {'''col_1''': '''int32''', '''col_2''': '''int32''', '''col_3''': '''int32'''},
        {'''col_1''': '''float32''', '''col_2''': '''float32''', '''col_3''': '''float32'''},
    ]			,)
def 		a__      (		_UpperCamelCase      :			Any			,_UpperCamelCase      :			Optional[int]			,_UpperCamelCase      :			List[Any]				):
   __lowerCamelCase    				=     tmp_path / '''cache'''
   __lowerCamelCase    				=     {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
   __lowerCamelCase    				=     features.copy() if features else default_expected_features
   __lowerCamelCase    				=     (
       Features({feature: Value(_UpperCamelCase				) for feature, dtype in features.items()}				) if features is not None else None
   )
   __lowerCamelCase    				=     JsonDatasetReader({'''train''': jsonl_path}			,features=_UpperCamelCase			,cache_dir=_UpperCamelCase				).read()
   _check_json_datasetdict(_UpperCamelCase			,_UpperCamelCase				)





@pytest.mark.parametrize('''split'''			,[None, NamedSplit('''train'''				), '''train''', '''test''']				)
def 		a__      (		_UpperCamelCase      :			Tuple			,_UpperCamelCase      :			List[str]			,_UpperCamelCase      :			Union[str, Any]				):
   if split:
      __lowerCamelCase    				=     {split: jsonl_path}
   else:
      __lowerCamelCase    				=     '''train'''
      __lowerCamelCase    				=     {'''train''': jsonl_path, '''test''': jsonl_path}
   __lowerCamelCase    				=     tmp_path / '''cache'''
   __lowerCamelCase    				=     {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
   __lowerCamelCase    				=     JsonDatasetReader(_UpperCamelCase			,cache_dir=_UpperCamelCase				).read()
   _check_json_datasetdict(_UpperCamelCase			,_UpperCamelCase			,splits=list(path.keys()				)				)
   assert all(dataset[split].split == split for split in path.keys()				)





def 		a__      (		_UpperCamelCase      :			int				):
   return json.load(_UpperCamelCase				)





def 		a__      (		_UpperCamelCase      :			int				):
   return [json.loads(_UpperCamelCase				) for line in buffer]





class 			__lowerCAmelCase  :




 @pytest.mark.parametrize('''lines, load_json_function'''						,					[(True, load_json_lines), (False, load_json)]					)
 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    with io.BytesIO() as buffer:
       JsonDatasetWriter(__UpperCAmelCase						,					__UpperCAmelCase						,					lines=__UpperCAmelCase					).write()
       buffer.seek(0					)
       __lowerCamelCase    				=     load_json_function(__UpperCAmelCase					)
    assert isinstance(__UpperCAmelCase						,					__UpperCAmelCase					)
    assert isinstance(exported_content[0]						,					__UpperCAmelCase					)
    assert len(__UpperCAmelCase					) == 10




 @pytest.mark.parametrize(
     '''orient, container, keys, len_at'''						,					[
         ('''records''', list, {'''tokens''', '''labels''', '''answers''', '''id'''}, None),
         ('''split''', dict, {'''columns''', '''data'''}, '''data'''),
         ('''index''', dict, set('''0123456789'''					), None),
         ('''columns''', dict, {'''tokens''', '''labels''', '''answers''', '''id'''}, '''tokens'''),
         ('''values''', list, None, None),
         ('''table''', dict, {'''schema''', '''data'''}, '''data'''),
     ]						,					)
 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    with io.BytesIO() as buffer:
       JsonDatasetWriter(__UpperCAmelCase						,					__UpperCAmelCase						,					lines=__UpperCAmelCase						,					orient=__UpperCAmelCase					).write()
       buffer.seek(0					)
       __lowerCamelCase    				=     load_json(__UpperCAmelCase					)
    assert isinstance(__UpperCAmelCase						,					__UpperCAmelCase					)
    if keys:
       if container is dict:
          assert exported_content.keys() == keys
       else:
          assert exported_content[0].keys() == keys
    else:
       assert not hasattr(__UpperCAmelCase						,					'''keys'''					) and not hasattr(exported_content[0]						,					'''keys'''					)
    if len_at:
       assert len(exported_content[len_at]					) == 10
    else:
       assert len(__UpperCAmelCase					) == 10




 @pytest.mark.parametrize('''lines, load_json_function'''						,					[(True, load_json_lines), (False, load_json)]					)
 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    with io.BytesIO() as buffer:
       JsonDatasetWriter(__UpperCAmelCase						,					__UpperCAmelCase						,					lines=__UpperCAmelCase						,					num_proc=2					).write()
       buffer.seek(0					)
       __lowerCamelCase    				=     load_json_function(__UpperCAmelCase					)
    assert isinstance(__UpperCAmelCase						,					__UpperCAmelCase					)
    assert isinstance(exported_content[0]						,					__UpperCAmelCase					)
    assert len(__UpperCAmelCase					) == 10




 @pytest.mark.parametrize(
     '''orient, container, keys, len_at'''						,					[
         ('''records''', list, {'''tokens''', '''labels''', '''answers''', '''id'''}, None),
         ('''split''', dict, {'''columns''', '''data'''}, '''data'''),
         ('''index''', dict, set('''0123456789'''					), None),
         ('''columns''', dict, {'''tokens''', '''labels''', '''answers''', '''id'''}, '''tokens'''),
         ('''values''', list, None, None),
         ('''table''', dict, {'''schema''', '''data'''}, '''data'''),
     ]						,					)
 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    with io.BytesIO() as buffer:
       JsonDatasetWriter(__UpperCAmelCase						,					__UpperCAmelCase						,					lines=__UpperCAmelCase						,					orient=__UpperCAmelCase						,					num_proc=2					).write()
       buffer.seek(0					)
       __lowerCamelCase    				=     load_json(__UpperCAmelCase					)
    assert isinstance(__UpperCAmelCase						,					__UpperCAmelCase					)
    if keys:
       if container is dict:
          assert exported_content.keys() == keys
       else:
          assert exported_content[0].keys() == keys
    else:
       assert not hasattr(__UpperCAmelCase						,					'''keys'''					) and not hasattr(exported_content[0]						,					'''keys'''					)
    if len_at:
       assert len(exported_content[len_at]					) == 10
    else:
       assert len(__UpperCAmelCase					) == 10




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase					):



    '''simple docstring'''
    with pytest.raises(__UpperCAmelCase					):
       with io.BytesIO() as buffer:
          JsonDatasetWriter(__UpperCAmelCase						,					__UpperCAmelCase						,					num_proc=0					)




 @pytest.mark.parametrize('''compression, extension'''						,					[('''gzip''', '''gz'''), ('''bz2''', '''bz2'''), ('''xz''', '''xz''')]					)
 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     tmp_path_factory.mktemp('''data'''					) / F"""test.json.{extension}"""
    __lowerCamelCase    				=     str(shared_datadir / F"""test_file.json.{extension}"""					)
    JsonDatasetWriter(__UpperCAmelCase						,					__UpperCAmelCase						,					compression=__UpperCAmelCase					).write()

    with fsspec.open(__UpperCAmelCase						,					'''rb'''						,					compression='''infer'''					) as f:
       __lowerCamelCase    				=     f.read()
    with fsspec.open(__UpperCAmelCase						,					'''rb'''						,					compression='''infer'''					) as f:
       __lowerCamelCase    				=     f.read()
    assert exported_content == original_content











import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor





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

   return name





def 		a__      (		_UpperCamelCase      :			Tuple			,_UpperCamelCase      :			Dict				):
   for key in orig_state_dict.copy().keys():
      __lowerCamelCase    				=     orig_state_dict.pop(_UpperCamelCase				)

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

      else:
         __lowerCamelCase    				=     val

   return orig_state_dict





def 		a__      (		_UpperCamelCase      :			Dict			,_UpperCamelCase      :			Any				):
   __lowerCamelCase    				=     ViTMAEConfig()
   if "large" in checkpoint_url:
      __lowerCamelCase    				=     10_24
      __lowerCamelCase    				=     40_96
      __lowerCamelCase    				=     24
      __lowerCamelCase    				=     16
   elif "huge" in checkpoint_url:
      __lowerCamelCase    				=     14
      __lowerCamelCase    				=     12_80
      __lowerCamelCase    				=     51_20
      __lowerCamelCase    				=     32
      __lowerCamelCase    				=     16

   __lowerCamelCase    				=     ViTMAEForPreTraining(_UpperCamelCase				)

   __lowerCamelCase    				=     torch.hub.load_state_dict_from_url(_UpperCamelCase			,map_location='''cpu'''				)['''model''']

   __lowerCamelCase    				=     ViTMAEImageProcessor(size=config.image_size				)

   __lowerCamelCase    				=     convert_state_dict(_UpperCamelCase			,_UpperCamelCase				)

   model.load_state_dict(_UpperCamelCase				)
   model.eval()

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

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

   # forward pass
   torch.manual_seed(2				)
   __lowerCamelCase    				=     model(**_UpperCamelCase				)
   __lowerCamelCase    				=     outputs.logits

   if "large" in checkpoint_url:
      __lowerCamelCase    				=     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:
      __lowerCamelCase    				=     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:
      __lowerCamelCase    				=     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]			,_UpperCamelCase			,atol=1e-4				)

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

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


if __name__ == "__main__":
  a_								=       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_								=       parser.parse_args()
  convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)






