





import re
import tempfile
from pathlib import Path

import pytest
import yaml

from datasets.utils.readme import ReadMe


# @pytest.fixture
# def example_yaml_structure():

_snake_case  :   int						   =  yaml.safe_load(
    '\\nname: ""\nallow_empty: false\nallow_empty_text: true\nsubsections:\n  - name: "Dataset Card for X" # First-level markdown heading\n    allow_empty: false\n    allow_empty_text: true\n    subsections:\n      - name: "Table of Contents"\n        allow_empty: false\n        allow_empty_text: false\n        subsections: null\n      - name: "Dataset Description"\n        allow_empty: false\n        allow_empty_text: false\n        subsections:\n          - name: "Dataset Summary"\n            allow_empty: false\n            allow_empty_text: false\n            subsections: null\n          - name: "Supported Tasks and Leaderboards"\n            allow_empty: true\n            allow_empty_text: true\n            subsections: null\n          - name: Languages\n            allow_empty: false\n            allow_empty_text: true\n            subsections: null\n'
)


_snake_case  :   Optional[Any]						   =  {
    'name': 'root',
    'text': '',
    'is_empty_text': True,
    'subsections': [
        {
            'name': 'Dataset Card for My Dataset',
            'text': '',
            'is_empty_text': True,
            'subsections': [
                {'name': 'Table of Contents', 'text': 'Some text here.', 'is_empty_text': False, 'subsections': []},
                {
                    'name': 'Dataset Description',
                    'text': 'Some text here.',
                    'is_empty_text': False,
                    'subsections': [
                        {
                            'name': 'Dataset Summary',
                            'text': 'Some text here.',
                            'is_empty_text': False,
                            'subsections': [],
                        },
                        {
                            'name': 'Supported Tasks and Leaderboards',
                            'text': '',
                            'is_empty_text': True,
                            'subsections': [],
                        },
                        {'name': 'Languages', 'text': 'Language Text', 'is_empty_text': False, 'subsections': []},
                    ],
                },
            ],
        }
    ],
}


_snake_case  :   Optional[Any]						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n'


_snake_case  :   Any						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n#### Extra Ignored Subsection\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n'

_snake_case  :   str						   =  {
    'name': 'root',
    'text': '',
    'is_empty_text': True,
    'subsections': [
        {
            'name': 'Dataset Card for My Dataset',
            'text': '',
            'is_empty_text': True,
            'subsections': [
                {'name': 'Table of Contents', 'text': 'Some text here.', 'is_empty_text': False, 'subsections': []},
                {
                    'name': 'Dataset Description',
                    'text': 'Some text here.',
                    'is_empty_text': False,
                    'subsections': [
                        {
                            'name': 'Dataset Summary',
                            'text': 'Some text here.',
                            'is_empty_text': False,
                            'subsections': [
                                {
                                    'name': 'Extra Ignored Subsection',
                                    'text': '',
                                    'is_empty_text': True,
                                    'subsections': [],
                                }
                            ],
                        },
                        {
                            'name': 'Supported Tasks and Leaderboards',
                            'text': '',
                            'is_empty_text': True,
                            'subsections': [],
                        },
                        {'name': 'Languages', 'text': 'Language Text', 'is_empty_text': False, 'subsections': []},
                    ],
                },
            ],
        }
    ],
}

_snake_case  :   List[Any]						   =  '\\n---\n---\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n'

_snake_case  :   List[str]						   =  (
    'The following issues were found for the README at `{path}`:\n-\tEmpty YAML markers are present in the README.'
)

_snake_case  :   Union[str, Any]						   =  '\\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n'

_snake_case  :   Union[str, Any]						   =  (
    'The following issues were found for the README at `{path}`:\n-\tNo YAML markers are present in the README.'
)

_snake_case  :   str						   =  '\\n---\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n'

_snake_case  :   Dict						   =  'The following issues were found for the README at `{path}`:\n-\tOnly the start of YAML tags present in the README.'

_snake_case  :   Union[str, Any]						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n'
_snake_case  :   Any						   =  'The following issues were found for the README at `{path}`:\n-\tExpected some content in section `Dataset Summary` but it is empty.\n-\tExpected some text in section `Dataset Summary` but it is empty (text in subsections are ignored).'


_snake_case  :   str						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n'
_snake_case  :   Optional[int]						   =  'The following issues were found for the README at `{path}`:\n-\tExpected some content in section `Dataset Card for My Dataset` but it is empty.\n-\tSection `Dataset Card for My Dataset` expected the following subsections: `Table of Contents`, `Dataset Description`. Found \'None\'.'

_snake_case  :   List[Any]						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Languages\nLanguage Text\n'

_snake_case  :   List[str]						   =  'The following issues were found for the README at `{path}`:\n-\tSection `Dataset Description` is missing subsection: `Supported Tasks and Leaderboards`.'


_snake_case  :   List[str]						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\n'

_snake_case  :   Optional[int]						   =  'The following issues were found for the README at `{path}`:\n-\tExpected some content in section `Languages` but it is empty.'

_snake_case  :   List[Any]						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n'
_snake_case  :   List[str]						   =  'The following issues were found for the README at `{path}`:\n-\tThe README has no first-level headings. One heading is expected. Skipping further validation for this README.'

_snake_case  :   str						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n# Dataset Card My Dataset\n'

_snake_case  :   Optional[Any]						   =  'The following issues were found for the README at `{path}`:\n-\tThe README has several first-level headings: `Dataset Card for My Dataset`, `Dataset Card My Dataset`. Only one heading is expected. Skipping further validation for this README.'

_snake_case  :   Tuple						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n'

_snake_case  :   Dict						   =  'The following issues were found for the README at `{path}`:\n-\tNo first-level heading starting with `Dataset Card for` found in README. Skipping further validation for this README.'

_snake_case  :   List[str]						   =  ''

_snake_case  :   List[str]						   =  'The following issues were found for the README at `{path}`:\n-\tThe README has no first-level headings. One heading is expected. Skipping further validation for this README.\n-\tNo YAML markers are present in the README.'

_snake_case  :   Optional[Any]						   =  '\\n---\nlanguage:\n- zh\n- en\n---\n\n# Dataset Card for My Dataset\n# Dataset Card for My Dataset\n## Table of Contents\nSome text here.\n## Dataset Description\nSome text here.\n### Dataset Summary\nSome text here.\n### Supported Tasks and Leaderboards\n### Languages\nLanguage Text\n'

_snake_case  :   Optional[Any]						   =  'The following issues were found while parsing the README at `{path}`:\n-\tMultiple sections with the same heading `Dataset Card for My Dataset` have been found. Please keep only one of these sections.'

@pytest.mark.parametrize(
    'readme_md, expected_dict',     [
        (README_CORRECT, CORRECT_DICT),
        (README_CORRECT_FOUR_LEVEL, CORRECT_DICT_FOUR_LEVEL),
    ],     )
def   a_   (			lowerCAmelCase_				:      int,     lowerCAmelCase_				:      Dict     ):
   assert ReadMe.from_string(lowerCAmelCase_,     lowerCAmelCase_     ).to_dict() == expected_dict

@pytest.mark.parametrize(
    'readme_md, expected_error',     [
        (README_NO_YAML, EXPECTED_ERROR_README_NO_YAML),
        (README_EMPTY_YAML, EXPECTED_ERROR_README_EMPTY_YAML),
        (README_INCORRECT_YAML, EXPECTED_ERROR_README_INCORRECT_YAML),
        (README_EMPTY, EXPECTED_ERROR_README_EMPTY),
        (README_NONE_SUBSECTION, EXPECTED_ERROR_README_NONE_SUBSECTION),
        (README_MISSING_FIRST_LEVEL, EXPECTED_ERROR_README_MISSING_FIRST_LEVEL),
        (README_MISSING_SUBSECTION, EXPECTED_ERROR_README_MISSING_SUBSECTION),
        (README_MISSING_TEXT, EXPECTED_ERROR_README_MISSING_TEXT),
        (README_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_WRONG_FIRST_LEVEL),
        (README_MULTIPLE_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_MULTIPLE_WRONG_FIRST_LEVEL),
        (README_MISSING_CONTENT, EXPECTED_ERROR_README_MISSING_CONTENT),
    ],     )
def   a_   (			lowerCAmelCase_				:      Optional[int],     lowerCAmelCase_				:      List[str]     ):
   with pytest.raises(lowerCAmelCase_,     match=re.escape(expected_error.format(path='root'     )     )     ):
      __lowerCAmelCase							     =     ReadMe.from_string(lowerCAmelCase_,     lowerCAmelCase_     )
      readme.validate()

@pytest.mark.parametrize(
    'readme_md, expected_error',     [
        (README_MULTIPLE_SAME_HEADING_1, EXPECTED_ERROR_README_MULTIPLE_SAME_HEADING_1),
    ],     )
def   a_   (			lowerCAmelCase_				:      Any,     lowerCAmelCase_				:      int     ):
   with pytest.raises(lowerCAmelCase_,     match=re.escape(expected_error.format(path='root'     )     )     ):
      ReadMe.from_string(lowerCAmelCase_,     lowerCAmelCase_     )

@pytest.mark.parametrize(
    'readme_md,',     [
        (README_MULTIPLE_SAME_HEADING_1),
    ],     )
def   a_   (			lowerCAmelCase_				:      List[Any]     ):
   ReadMe.from_string(lowerCAmelCase_,     lowerCAmelCase_,     suppress_parsing_errors=lowerCAmelCase_     )

@pytest.mark.parametrize(
    'readme_md, expected_dict',     [
        (README_CORRECT, CORRECT_DICT),
        (README_CORRECT_FOUR_LEVEL, CORRECT_DICT_FOUR_LEVEL),
    ],     )
def   a_   (			lowerCAmelCase_				:      List[str],     lowerCAmelCase_				:      int     ):
   with tempfile.TemporaryDirectory() as tmp_dir:
      __lowerCAmelCase							     =     Path(lowerCAmelCase_     ) / 'README.md'
      with open(lowerCAmelCase_,     'w+'     ) as readme_file:
         readme_file.write(lowerCAmelCase_     )
      __lowerCAmelCase							     =     ReadMe.from_readme(lowerCAmelCase_,     lowerCAmelCase_     ).to_dict()
      assert out["name"] == path
      assert out["text"] == ""
      assert out["is_empty_text"]
      assert out["subsections"] == expected_dict["subsections"]

@pytest.mark.parametrize(
    'readme_md, expected_error',     [
        (README_NO_YAML, EXPECTED_ERROR_README_NO_YAML),
        (README_EMPTY_YAML, EXPECTED_ERROR_README_EMPTY_YAML),
        (README_INCORRECT_YAML, EXPECTED_ERROR_README_INCORRECT_YAML),
        (README_EMPTY, EXPECTED_ERROR_README_EMPTY),
        (README_NONE_SUBSECTION, EXPECTED_ERROR_README_NONE_SUBSECTION),
        (README_MISSING_FIRST_LEVEL, EXPECTED_ERROR_README_MISSING_FIRST_LEVEL),
        (README_MISSING_SUBSECTION, EXPECTED_ERROR_README_MISSING_SUBSECTION),
        (README_MISSING_TEXT, EXPECTED_ERROR_README_MISSING_TEXT),
        (README_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_WRONG_FIRST_LEVEL),
        (README_MULTIPLE_WRONG_FIRST_LEVEL, EXPECTED_ERROR_README_MULTIPLE_WRONG_FIRST_LEVEL),
        (README_MISSING_CONTENT, EXPECTED_ERROR_README_MISSING_CONTENT),
    ],     )
def   a_   (			lowerCAmelCase_				:      Tuple,     lowerCAmelCase_				:      Optional[int]     ):
   with tempfile.TemporaryDirectory() as tmp_dir:
      __lowerCAmelCase							     =     Path(lowerCAmelCase_     ) / 'README.md'
      with open(lowerCAmelCase_,     'w+'     ) as readme_file:
         readme_file.write(lowerCAmelCase_     )
      __lowerCAmelCase							     =     expected_error.format(path=lowerCAmelCase_     )
      with pytest.raises(lowerCAmelCase_,     match=re.escape(lowerCAmelCase_     )     ):
         __lowerCAmelCase							     =     ReadMe.from_readme(lowerCAmelCase_,     lowerCAmelCase_     )
         readme.validate()

@pytest.mark.parametrize(
    'readme_md, expected_error',     [
        (README_MULTIPLE_SAME_HEADING_1, EXPECTED_ERROR_README_MULTIPLE_SAME_HEADING_1),
    ],     )
def   a_   (			lowerCAmelCase_				:      Optional[Any],     lowerCAmelCase_				:      Any     ):
   with tempfile.TemporaryDirectory() as tmp_dir:
      __lowerCAmelCase							     =     Path(lowerCAmelCase_     ) / 'README.md'
      with open(lowerCAmelCase_,     'w+'     ) as readme_file:
         readme_file.write(lowerCAmelCase_     )
      __lowerCAmelCase							     =     expected_error.format(path=lowerCAmelCase_     )
      with pytest.raises(lowerCAmelCase_,     match=re.escape(lowerCAmelCase_     )     ):
         ReadMe.from_readme(lowerCAmelCase_,     lowerCAmelCase_     )




@pytest.mark.parametrize(
    'readme_md,',     [
        (README_MULTIPLE_SAME_HEADING_1),
    ],     )
def   a_   (			lowerCAmelCase_				:      int     ):
   with tempfile.TemporaryDirectory() as tmp_dir:
      __lowerCAmelCase							     =     Path(lowerCAmelCase_     ) / 'README.md'
      with open(lowerCAmelCase_,     'w+'     ) as readme_file:
         readme_file.write(lowerCAmelCase_     )
      ReadMe.from_readme(lowerCAmelCase_,     lowerCAmelCase_,     suppress_parsing_errors=lowerCAmelCase_     )








import argparse
import json
from pathlib import Path

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

from transformers import DeiTImageProcessor, ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
from transformers.utils import logging


logging.set_verbosity_info()
_snake_case  :   List[str]						   =  logging.get_logger(__name__)

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

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

   if base_model:
      # layernorm + pooler
      rename_keys.extend(
          [
              ('norm.weight', 'layernorm.weight'),
              ('norm.bias', 'layernorm.bias'),
              ('pre_logits.fc.weight', 'pooler.dense.weight'),
              ('pre_logits.fc.bias', 'pooler.dense.bias'),
          ]     )

      # if just the base model, we should remove "vit" from all keys that start with "vit"
      __lowerCAmelCase							     =     [(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   a_   (			lowerCAmelCase_				:      List[Any],     lowerCAmelCase_				:      Dict,     lowerCAmelCase_				:      int=False     ):
   for i in range(config.num_hidden_layers     ):
      if base_model:
         __lowerCAmelCase							     =     ''
      else:
         __lowerCAmelCase							     =     'vit.'
      # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
      __lowerCAmelCase							     =     state_dict.pop(F"""blocks.{i}.attn.qkv.weight"""     )
      __lowerCAmelCase							     =     state_dict.pop(F"""blocks.{i}.attn.qkv.bias"""     )
      # next, add query, keys and values (in that order) to the state dict
      __lowerCAmelCase							     =     in_proj_weight[
          : config.hidden_size, :
      ]
      __lowerCAmelCase							     =     in_proj_bias[: config.hidden_size]
      __lowerCAmelCase							     =     in_proj_weight[
          config.hidden_size : config.hidden_size * 2, :
      ]
      __lowerCAmelCase							     =     in_proj_bias[
          config.hidden_size : config.hidden_size * 2
      ]
      __lowerCAmelCase							     =     in_proj_weight[
          -config.hidden_size :, :
      ]
      __lowerCAmelCase							     =     in_proj_bias[-config.hidden_size :]

def   a_   (			lowerCAmelCase_				:      Optional[int]     ):
   __lowerCAmelCase							     =     ['head.weight', 'head.bias']
   for k in ignore_keys:
      state_dict.pop(lowerCAmelCase_,     lowerCAmelCase_     )

def   a_   (			lowerCAmelCase_				:      Optional[Any],     lowerCAmelCase_				:      Tuple,     lowerCAmelCase_				:      Optional[int]     ):
   __lowerCAmelCase							     =     dct.pop(lowerCAmelCase_     )
   __lowerCAmelCase							     =     val

def   a_   (			):
   __lowerCAmelCase							     =     'http://images.cocodataset.org/val2017/000000039769.jpg'
   __lowerCAmelCase							     =     Image.open(requests.get(lowerCAmelCase_,     stream=lowerCAmelCase_     ).raw     )
   return im

@torch.no_grad()
def   a_   (			lowerCAmelCase_				:      List[str],     lowerCAmelCase_				:      Union[str, Any]     ):
   __lowerCAmelCase							     =     ViTConfig()
   __lowerCAmelCase							     =     False
   # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
   if vit_name[-5:] == "in21k":
      __lowerCAmelCase							     =     True
      __lowerCAmelCase							     =     int(vit_name[-12:-10]     )
      __lowerCAmelCase							     =     int(vit_name[-9:-6]     )
   else:
      __lowerCAmelCase							     =     1000
      __lowerCAmelCase							     =     'huggingface/label-files'
      __lowerCAmelCase							     =     'imagenet-1k-id2label.json'
      __lowerCAmelCase							     =     json.load(open(hf_hub_download(lowerCAmelCase_,     lowerCAmelCase_,     repo_type='dataset'     ),     'r'     )     )
      __lowerCAmelCase							     =     {int(lowerCAmelCase_     ): v for k, v in idalabel.items()}
      __lowerCAmelCase							     =     idalabel
      __lowerCAmelCase							     =     {v: k for k, v in idalabel.items()}
      __lowerCAmelCase							     =     int(vit_name[-6:-4]     )
      __lowerCAmelCase							     =     int(vit_name[-3:]     )
   # size of the architecture
   if "deit" in vit_name:
      if vit_name[9:].startswith('tiny'     ):
         __lowerCAmelCase							     =     192
         __lowerCAmelCase							     =     768
         __lowerCAmelCase							     =     12
         __lowerCAmelCase							     =     3
      elif vit_name[9:].startswith('small'     ):
         __lowerCAmelCase							     =     384
         __lowerCAmelCase							     =     1536
         __lowerCAmelCase							     =     12
         __lowerCAmelCase							     =     6
      else:
         pass
   else:
      if vit_name[4:].startswith('small'     ):
         __lowerCAmelCase							     =     768
         __lowerCAmelCase							     =     2304
         __lowerCAmelCase							     =     8
         __lowerCAmelCase							     =     8
      elif vit_name[4:].startswith('base'     ):
         pass
      elif vit_name[4:].startswith('large'     ):
         __lowerCAmelCase							     =     1024
         __lowerCAmelCase							     =     4096
         __lowerCAmelCase							     =     24
         __lowerCAmelCase							     =     16
      elif vit_name[4:].startswith('huge'     ):
         __lowerCAmelCase							     =     1280
         __lowerCAmelCase							     =     5120
         __lowerCAmelCase							     =     32
         __lowerCAmelCase							     =     16

    # load original model from timm
   __lowerCAmelCase							     =     timm.create_model(lowerCAmelCase_,     pretrained=lowerCAmelCase_     )
   timm_model.eval()

   # load state_dict of original model, remove and rename some keys
   __lowerCAmelCase							     =     timm_model.state_dict()
   if base_model:
      remove_classification_head_(lowerCAmelCase_     )
   __lowerCAmelCase							     =     create_rename_keys(lowerCAmelCase_,     lowerCAmelCase_     )
   for src, dest in rename_keys:
      rename_key(lowerCAmelCase_,     lowerCAmelCase_,     lowerCAmelCase_     )
   read_in_q_k_v(lowerCAmelCase_,     lowerCAmelCase_,     lowerCAmelCase_     )

   # load HuggingFace model
   if vit_name[-5:] == "in21k":
      __lowerCAmelCase							     =     ViTModel(lowerCAmelCase_     ).eval()
   else:
      __lowerCAmelCase							     =     ViTForImageClassification(lowerCAmelCase_     ).eval()
   model.load_state_dict(lowerCAmelCase_     )

   # Check outputs on an image, prepared by ViTImageProcessor/DeiTImageProcessor
   if "deit" in vit_name:
      __lowerCAmelCase							     =     DeiTImageProcessor(size=config.image_size     )
   else:
      __lowerCAmelCase							     =     ViTImageProcessor(size=config.image_size     )
   __lowerCAmelCase							     =     image_processor(images=prepare_img(),     return_tensors='pt'     )
   __lowerCAmelCase							     =     encoding['pixel_values']
   __lowerCAmelCase							     =     model(lowerCAmelCase_     )

   if base_model:
      __lowerCAmelCase							     =     timm_model.forward_features(lowerCAmelCase_     )
      assert timm_pooled_output.shape == outputs.pooler_output.shape
      assert torch.allclose(lowerCAmelCase_,     outputs.pooler_output,     atol=1E-3     )
   else:
      __lowerCAmelCase							     =     timm_model(lowerCAmelCase_     )
      assert timm_logits.shape == outputs.logits.shape
      assert torch.allclose(lowerCAmelCase_,     outputs.logits,     atol=1E-3     )

   Path(lowerCAmelCase_     ).mkdir(exist_ok=lowerCAmelCase_     )
   print(F"""Saving model {vit_name} 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__":
     _snake_case  :   List[Any]						   =  argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--vit_name',
         default='vit_base_patch16_224',
         type=str,
         help='Name of the ViT timm model you\'d like to convert.',
     )
     parser.add_argument(
         '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
     )

     _snake_case  :   Optional[int]						   =  parser.parse_args()
     convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path)

