


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 timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import (
    BitConfig,
    ViTHybridConfig,
    ViTHybridForImageClassification,
    ViTHybridImageProcessor,
    ViTHybridModel,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCamelCase        =     logging.get_logger(__name__)



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase=False ):
     a_    :     str										=    []

     # fmt: off
     # stem:
     rename_keys.append(("""cls_token""", """vit.embeddings.cls_token""") )
     rename_keys.append(("""pos_embed""", """vit.embeddings.position_embeddings""") )

     rename_keys.append(("""patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight""") )
     rename_keys.append(("""patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias""") )

     # backbone
     rename_keys.append(("""patch_embed.backbone.stem.conv.weight""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.convolution.weight""") )
     rename_keys.append(("""patch_embed.backbone.stem.norm.weight""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.weight""") )
     rename_keys.append(("""patch_embed.backbone.stem.norm.bias""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.bias""") )

     for stage_idx in range(len(config.backbone_config.depths ) ):
          for layer_idx in range(config.backbone_config.depths[stage_idx] ):
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv1.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv1.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.bias''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.bias''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv2.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv2.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.bias''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.bias''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv3.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv3.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.bias''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.bias''') )

          rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.conv.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.conv.weight''') )
          rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.weight''') )
          rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.bias''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.bias''') )

     # transformer encoder
     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''') )

     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"
          a_    :     int										=    [(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"""),
              ] )
     # fmt: on

     return rename_keys



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase=False ):
     for i in range(config.num_hidden_layers ):
          if base_model:
               a_    :     int										=    """"""
          else:
               a_    :     int										=    """vit."""
          # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
          a_    :     List[Any]										=    state_dict.pop(F'''blocks.{i}.attn.qkv.weight''' )
          a_    :     List[Any]										=    state_dict.pop(F'''blocks.{i}.attn.qkv.bias''' )
          # next, add query, keys and values (in that order) to the state dict
          a_    :     Dict										=    in_proj_weight[
              : config.hidden_size, :
          ]
          a_    :     Dict										=    in_proj_bias[: config.hidden_size]
          a_    :     Tuple										=    in_proj_weight[
              config.hidden_size : config.hidden_size * 2, :
          ]
          a_    :     List[Any]										=    in_proj_bias[
              config.hidden_size : config.hidden_size * 2
          ]
          a_    :     List[Any]										=    in_proj_weight[
              -config.hidden_size :, :
          ]
          a_    :     Dict										=    in_proj_bias[-config.hidden_size :]



def  _a			(						__UpperCamelCase ):
     a_    :     Optional[Any]										=    ["""head.weight""", """head.bias"""]
     for k in ignore_keys:
          state_dict.pop(__UpperCamelCase  ,  __UpperCamelCase )



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase ):
     a_    :     Optional[Any]										=    dct.pop(__UpperCamelCase )
     a_    :     List[Any]										=    val



def  _a			(						):
     a_    :     int										=    """http://images.cocodataset.org/val2017/000000039769.jpg"""
     a_    :     Optional[int]										=    Image.open(requests.get(__UpperCamelCase  ,  stream=__UpperCamelCase ).raw )
     return im



@torch.no_grad()
def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase=False ):
     a_    :     str										=    BitConfig(
         global_padding="""same"""  ,  layer_type="""bottleneck"""  ,  depths=(3, 4, 9)  ,  out_features=["""stage3"""]  ,  embedding_dynamic_padding=__UpperCamelCase  ,  )
     a_    :     int										=    ViTHybridConfig(backbone_config=__UpperCamelCase  ,  image_size=3_8_4  ,  num_labels=1_0_0_0 )
     a_    :     Tuple										=    False

     # load original model from timm
     a_    :     Dict										=    timm.create_model(__UpperCamelCase  ,  pretrained=__UpperCamelCase )
     timm_model.eval()

     # load state_dict of original model, remove and rename some keys
     a_    :     Optional[Any]										=    timm_model.state_dict()
     if base_model:
          remove_classification_head_(__UpperCamelCase )
     a_    :     List[Any]										=    create_rename_keys(__UpperCamelCase  ,  __UpperCamelCase )
     for src, dest in rename_keys:
          rename_key(__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase )
     read_in_q_k_v(__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase )

     a_    :     Dict										=    """huggingface/label-files"""
     a_    :     List[Any]										=    """imagenet-1k-id2label.json"""
     a_    :     List[Any]										=    json.load(open(hf_hub_download(__UpperCamelCase  ,  __UpperCamelCase  ,  repo_type="""dataset""" )  ,  """r""" ) )
     a_    :     int										=    {int(__UpperCamelCase ): v for k, v in idalabel.items()}
     a_    :     Dict										=    idalabel
     a_    :     int										=    {v: k for k, v in idalabel.items()}

     # load HuggingFace model
     if vit_name[-5:] == "in21k":
          a_    :     List[str]										=    ViTHybridModel(__UpperCamelCase ).eval()
     else:
          a_    :     List[str]										=    ViTHybridForImageClassification(__UpperCamelCase ).eval()
     model.load_state_dict(__UpperCamelCase )

     # create image processor
     a_    :     List[str]										=    create_transform(**resolve_data_config({}  ,  model=__UpperCamelCase ) )
     a_    :     Tuple										=    transform.transforms

     a_    :     int										=    {
         """bilinear""": PILImageResampling.BILINEAR,
         """bicubic""": PILImageResampling.BICUBIC,
         """nearest""": PILImageResampling.NEAREST,
     }

     a_    :     Optional[Any]										=    ViTHybridImageProcessor(
         do_resize=__UpperCamelCase  ,  size={"""shortest_edge""": timm_transforms[0].size}  ,  resample=pillow_resamplings[timm_transforms[0].interpolation.value]  ,  do_center_crop=__UpperCamelCase  ,  crop_size={"""height""": timm_transforms[1].size[0], """width""": timm_transforms[1].size[1]}  ,  do_normalize=__UpperCamelCase  ,  image_mean=timm_transforms[-1].mean.tolist()  ,  image_std=timm_transforms[-1].std.tolist()  ,  )

     a_    :     List[Any]										=    prepare_img()
     a_    :     List[Any]										=    transform(__UpperCamelCase ).unsqueeze(0 )
     a_    :     Union[str, Any]										=    processor(__UpperCamelCase  ,  return_tensors="""pt""" ).pixel_values

     # verify pixel values
     assert torch.allclose(__UpperCamelCase  ,  __UpperCamelCase )

     # verify logits
     with torch.no_grad():
          a_    :     Union[str, Any]										=    model(__UpperCamelCase )
          a_    :     Optional[int]										=    outputs.logits

     print("""Predicted class:"""  ,  logits.argmax(-1 ).item() )
     if base_model:
          a_    :     Optional[int]										=    timm_model.forward_features(__UpperCamelCase )
          assert timm_pooled_output.shape == outputs.pooler_output.shape
          assert torch.allclose(__UpperCamelCase  ,  outputs.pooler_output  ,  atol=1E-3 )
     else:
          a_    :     List[str]										=    timm_model(__UpperCamelCase )
          assert timm_logits.shape == outputs.logits.shape
          assert torch.allclose(__UpperCamelCase  ,  outputs.logits  ,  atol=1E-3 )
     print("""Looks ok!""" )

     if pytorch_dump_folder_path is not None:
          Path(__UpperCamelCase ).mkdir(exist_ok=__UpperCamelCase )
          print(F'''Saving model {vit_name} to {pytorch_dump_folder_path}''' )
          model.save_pretrained(__UpperCamelCase )
          print(F'''Saving processor to {pytorch_dump_folder_path}''' )
          processor.save_pretrained(__UpperCamelCase )

     if push_to_hub:
          print(F'''Pushing model and processor to the hub {vit_name}''' )
          model.push_to_hub(F'''ybelkada/{vit_name}''' )
          processor.push_to_hub(F'''ybelkada/{vit_name}''' )


if __name__ == "__main__":
       __lowerCamelCase        =     argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '''--vit_name''',
           default='''vit_base_r50_s16_384''',
           type=str,
           help='''Name of the hybrid 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.'''
       )
       parser.add_argument(
           '''--push_to_hub''', action='''store_true''', help='''Whether to upload the model to the HuggingFace hub.'''
       )

       __lowerCamelCase        =     parser.parse_args()
       convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path, args.push_to_hub)







import os
import re
import shutil
import sys
import tempfile
import unittest

import black


__lowerCamelCase        =     os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated.
__lowerCamelCase        =     '''    def __init__(self, config):
        super().__init__()
        self.transform = BertPredictionHeadTransform(config)

        # The output weights are the same as the input embeddings, but there is
        # an output-only bias for each token.
        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)

        self.bias = nn.Parameter(torch.zeros(config.vocab_size))

        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
        self.decoder.bias = self.bias

    def forward(self, hidden_states):
        hidden_states = self.transform(hidden_states)
        hidden_states = self.decoder(hidden_states)
        return hidden_states
'''


class   a__	(						unittest.TestCase    ):

       def 						UpperCAmelCase(   self      :     Dict    ):
            a_    :     Optional[Any]										=    tempfile.mkdtemp()
            os.makedirs(os.path.join(self.transformer_dir      ,							"""models/bert/"""    )    )
            a_    :     Optional[Any]										=    self.transformer_dir
            shutil.copy(
                os.path.join(lowerCamelCase_      ,							"""src/transformers/models/bert/modeling_bert.py"""    )      ,							os.path.join(self.transformer_dir      ,							"""models/bert/modeling_bert.py"""    )      ,							)

       def 						UpperCAmelCase(   self      :     Dict    ):
            a_    :     Any										=    """src/transformers"""
            shutil.rmtree(self.transformer_dir    )

       def 						UpperCAmelCase(   self      :     Dict      ,							lowerCamelCase_      :     str      ,							lowerCamelCase_      :     Optional[int]      ,							lowerCamelCase_      :     int      ,							lowerCamelCase_      :     Tuple=None    ):
            a_    :     Any										=    comment + F'''\nclass {class_name}(nn.Module):\n''' + class_code
            if overwrite_result is not None:
                 a_    :     Any										=    comment + F'''\nclass {class_name}(nn.Module):\n''' + overwrite_result
            a_    :     Dict										=    black.Mode(target_versions={black.TargetVersion.PYaa}      ,							line_length=1_1_9    )
            a_    :     Optional[Any]										=    black.format_str(lowerCamelCase_      ,							mode=lowerCamelCase_    )
            a_    :     Optional[Any]										=    os.path.join(self.transformer_dir      ,							"""new_code.py"""    )
            with open(lowerCamelCase_      ,							"""w"""      ,							newline="""\n"""    ) as f:
                 f.write(lowerCamelCase_    )
            if overwrite_result is None:
                 self.assertTrue(len(check_copies.is_copy_consistent(lowerCamelCase_    )    ) == 0    )
            else:
                 check_copies.is_copy_consistent(f.name      ,							overwrite=lowerCamelCase_    )
                 with open(lowerCamelCase_      ,							"""r"""    ) as f:
                      self.assertTrue(f.read()      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     Dict    ):
            a_    :     Tuple										=    check_copies.find_code_in_transformers("""models.bert.modeling_bert.BertLMPredictionHead"""    )
            self.assertEqual(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     Optional[int]    ):
            # Base copy consistency
            self.check_copy_consistency(
                """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"""      ,							"""BertLMPredictionHead"""      ,							REFERENCE_CODE + """\n"""      ,							)

            # With no empty line at the end
            self.check_copy_consistency(
                """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"""      ,							"""BertLMPredictionHead"""      ,							lowerCamelCase_      ,							)

            # Copy consistency with rename
            self.check_copy_consistency(
                """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"""      ,							"""TestModelLMPredictionHead"""      ,							re.sub("""Bert"""      ,							"""TestModel"""      ,							lowerCamelCase_    )      ,							)

            # Copy consistency with a really long name
            a_    :     int										=    """TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason"""
            self.check_copy_consistency(
                F'''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}'''      ,							F'''{long_class_name}LMPredictionHead'''      ,							re.sub("""Bert"""      ,							lowerCamelCase_      ,							lowerCamelCase_    )      ,							)

            # Copy consistency with overwrite
            self.check_copy_consistency(
                """# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"""      ,							"""TestModelLMPredictionHead"""      ,							lowerCamelCase_      ,							overwrite_result=re.sub("""Bert"""      ,							"""TestModel"""      ,							lowerCamelCase_    )      ,							)

       def 						UpperCAmelCase(   self      :     int    ):
            a_    :     Optional[Any]										=    check_copies.LOCALIZED_READMES["""README_zh-hans.md"""]

            a_    :     Tuple										=    (
                """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the"""
                """ Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for"""
                """ Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong"""
                """ Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1."""
                """ **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace),"""
                """ released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and"""
                """ lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same"""
                """ method has been applied to compress GPT2 into"""
                """ [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into"""
                """ [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),"""
                """ Multilingual BERT into"""
                """ [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German"""
                """ version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**"""
                """ (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders"""
                """ as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang"""
                """ Luong, Quoc V. Le, Christopher D. Manning."""
            )
            a_    :     Optional[Any]										=    (
                """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"""
                """ Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
                """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
                """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"""
            )
            a_    :     Any										=    (
                """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"""
                """ Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
                """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
                """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1."""
                """ **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文"""
                """ [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and"""
                """ lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same"""
                """ method has been applied to compress GPT2 into"""
                """ [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into"""
                """ [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),"""
                """ Multilingual BERT into"""
                """ [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German"""
                """ version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自"""
                """ Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather"""
                """ than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le,"""
                """ Christopher D. Manning 发布。\n"""
            )

            a_			,			a_    :     Optional[int]										=    check_copies.convert_to_localized_md(
                lowerCamelCase_      ,							lowerCamelCase_      ,							localized_readme["""format_model_list"""]    )

            self.assertFalse(lowerCamelCase_    )
            self.assertEqual(lowerCamelCase_      ,							lowerCamelCase_    )

            a_			,			a_    :     Tuple										=    check_copies.convert_to_localized_md(
                lowerCamelCase_      ,							lowerCamelCase_      ,							localized_readme["""format_model_list"""]    )

            # Check whether the number of models is equal to README.md after conversion.
            self.assertTrue(lowerCamelCase_    )

            a_    :     Optional[int]										=    (
                """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the"""
                """ Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for"""
                """ Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong"""
                """ Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut."""
            )
            a_    :     Union[str, Any]										=    (
                """1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and"""
                """ the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
                """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
                """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"""
            )
            a_    :     str										=    (
                """1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"""
                """ Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"""
                """ Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"""
                """ Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"""
            )

            a_			,			a_    :     Tuple										=    check_copies.convert_to_localized_md(
                lowerCamelCase_      ,							lowerCamelCase_      ,							localized_readme["""format_model_list"""]    )

            # Check if the model link is synchronized.
            self.assertEqual(lowerCamelCase_      ,							lowerCamelCase_    )



