





import logging
import os
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

from filelock import FileLock

from transformers import PreTrainedTokenizer, is_tf_available, is_torch_available


A   : List[Any]			=				logging.getLogger(__name__)


@dataclass
class   A      :
			'''simple docstring'''




			__lowerCamelCase     :	str
			__lowerCamelCase     :	List[str]
			__lowerCamelCase     :	Optional[List[str]]


@dataclass
class   A      :
			'''simple docstring'''




			__lowerCamelCase     :	List[int]
			__lowerCamelCase     :	List[int]
			__lowerCamelCase     :	Optional[List[int]]          =   None
			__lowerCamelCase     :	Optional[List[int]]          =   None


class   A      (SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''




			__lowerCamelCase     :	Dict          =   '''train'''
			__lowerCamelCase     :	int          =   '''dev'''
			__lowerCamelCase     :	List[Any]          =   '''test'''


class   A      :
			'''simple docstring'''




			@staticmethod
			def        a_	(      __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   Union[Split, str]       )     ->     List[InputExample]:







					"""simple docstring"""






					raise NotImplementedError






			@staticmethod
			def        a_	(      __lowerCAmelCase       :   str       )     ->     List[str]:







					"""simple docstring"""






					raise NotImplementedError







			@staticmethod
			def        a_	(      __lowerCAmelCase       :   List[InputExample]							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   PreTrainedTokenizer							,     __lowerCAmelCase       :   Union[str, Any]=False							,     __lowerCAmelCase       :   str="[CLS]"							,     __lowerCAmelCase       :   Optional[Any]=1							,     __lowerCAmelCase       :   List[str]="[SEP]"							,     __lowerCAmelCase       :   List[str]=False							,     __lowerCAmelCase       :   Optional[Any]=False							,     __lowerCAmelCase       :   Dict=0							,     __lowerCAmelCase       :   Dict=0							,     __lowerCAmelCase       :   Union[str, Any]=-1_00							,     __lowerCAmelCase       :   str=0							,     __lowerCAmelCase       :   Optional[Any]=True							,     )     ->     List[InputFeatures]:







					"""simple docstring"""






					A__  				=       {label: i for i, label in enumerate(__lowerCAmelCase       )}

					A__  				=       []
					for ex_index, example in enumerate(__lowerCAmelCase       ):
							if ex_index % 1_00_00 == 0:
									logger.info("""Writing example %d of %d"""							,     __lowerCAmelCase							,     len(__lowerCAmelCase       )       )

							A__  				=       []
							A__  				=       []
							for word, label in zip(example.words							,     example.labels       ):
									A__  				=       tokenizer.tokenize(__lowerCAmelCase       )

									# bert-base-multilingual-cased sometimes output "nothing ([]) when calling tokenize with just a space.
									if len(__lowerCAmelCase       ) > 0:
											tokens.extend(__lowerCAmelCase       )
											# Use the real label id for the first token of the word, and padding ids for the remaining tokens
											label_ids.extend([label_map[label]] + [pad_token_label_id] * (len(__lowerCAmelCase       ) - 1)       )

            # Account for [CLS] and [SEP] with "- 2" and with "- 3" for RoBERTa.
							A__  				=       tokenizer.num_special_tokens_to_add()
							if len(__lowerCAmelCase       ) > max_seq_length - special_tokens_count:
									A__  				=       tokens[: (max_seq_length - special_tokens_count)]
									A__  				=       label_ids[: (max_seq_length - special_tokens_count)]

							# The convention in BERT is:
							# (a) For sequence pairs:
							#  tokens:   [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
							#  type_ids:   0   0  0    0    0     0       0   0   1  1  1  1   1   1
							# (b) For single sequences:
							#  tokens:   [CLS] the dog is hairy . [SEP]
							#  type_ids:   0   0   0   0  0     0   0
							#
							# Where "type_ids" are used to indicate whether this is the first
							# sequence or the second sequence. The embedding vectors for `type=0` and
							# `type=1` were learned during pre-training and are added to the wordpiece
							# embedding vector (and position vector). This is not *strictly* necessary
							# since the [SEP] token unambiguously separates the sequences, but it makes
							# it easier for the model to learn the concept of sequences.
							#
							# For classification tasks, the first vector (corresponding to [CLS]) is
							# used as the "sentence vector". Note that this only makes sense because
							# the entire model is fine-tuned.
							tokens += [sep_token]
							label_ids += [pad_token_label_id]
							if sep_token_extra:
									# roberta uses an extra separator b/w pairs of sentences
									tokens += [sep_token]
									label_ids += [pad_token_label_id]
							A__  				=       [sequence_a_segment_id] * len(__lowerCAmelCase       )

							if cls_token_at_end:
									tokens += [cls_token]
									label_ids += [pad_token_label_id]
									segment_ids += [cls_token_segment_id]
							else:
									A__  				=       [cls_token] + tokens
									A__  				=       [pad_token_label_id] + label_ids
									A__  				=       [cls_token_segment_id] + segment_ids

							A__  				=       tokenizer.convert_tokens_to_ids(__lowerCAmelCase       )

							# The mask has 1 for real tokens and 0 for padding tokens. Only real
							# tokens are attended to.
							A__  				=       [1 if mask_padding_with_zero else 0] * len(__lowerCAmelCase       )

							# Zero-pad up to the sequence length.
							A__  				=       max_seq_length - len(__lowerCAmelCase       )
							if pad_on_left:
									A__  				=       ([pad_token] * padding_length) + input_ids
									A__  				=       ([0 if mask_padding_with_zero else 1] * padding_length) + input_mask
									A__  				=       ([pad_token_segment_id] * padding_length) + segment_ids
									A__  				=       ([pad_token_label_id] * padding_length) + label_ids
							else:
									input_ids += [pad_token] * padding_length
									input_mask += [0 if mask_padding_with_zero else 1] * padding_length
									segment_ids += [pad_token_segment_id] * padding_length
									label_ids += [pad_token_label_id] * padding_length

							assert len(__lowerCAmelCase       ) == max_seq_length
							assert len(__lowerCAmelCase       ) == max_seq_length
							assert len(__lowerCAmelCase       ) == max_seq_length
							assert len(__lowerCAmelCase       ) == max_seq_length

							if ex_index < 5:
									logger.info("""*** Example ***"""       )
									logger.info("""guid: %s"""							,     example.guid       )
									logger.info("""tokens: %s"""							,     """ """.join([str(__lowerCAmelCase       ) for x in tokens]       )       )
									logger.info("""input_ids: %s"""							,     """ """.join([str(__lowerCAmelCase       ) for x in input_ids]       )       )
									logger.info("""input_mask: %s"""							,     """ """.join([str(__lowerCAmelCase       ) for x in input_mask]       )       )
									logger.info("""segment_ids: %s"""							,     """ """.join([str(__lowerCAmelCase       ) for x in segment_ids]       )       )
									logger.info("""label_ids: %s"""							,     """ """.join([str(__lowerCAmelCase       ) for x in label_ids]       )       )

							if "token_type_ids" not in tokenizer.model_input_names:
									A__  				=       None

							features.append(
							    InputFeatures(
							        input_ids=__lowerCAmelCase							,     attention_mask=__lowerCAmelCase							,     token_type_ids=__lowerCAmelCase							,     label_ids=__lowerCAmelCase       )       )
					return features


if is_torch_available():
					import torch
					from torch import nn
					from torch.utils.data import Dataset


					class   A      (SCREAMING_SNAKE_CASE   ):
								'''simple docstring'''




								__lowerCamelCase     :	List[InputFeatures]
								__lowerCamelCase     :	int          =   nn.CrossEntropyLoss().ignore_index






								def __init__(      self       :   str							,     __lowerCAmelCase       :   TokenClassificationTask							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   PreTrainedTokenizer							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   Optional[int] = None							,     __lowerCAmelCase       :   int=False							,     __lowerCAmelCase       :   Split = Split.train							,     )     ->     str:







										"""simple docstring"""






										A__  				=       os.path.join(
										    __lowerCAmelCase							,     """cached_{}_{}_{}""".format(mode.value							,     tokenizer.__class__.__name__							,     str(__lowerCAmelCase       )       )							,     )

										# Make sure only the first process in distributed training processes the dataset,
										# and the others will use the cache.
										A__  				=       cached_features_file + """.lock"""
										with FileLock(__lowerCAmelCase       ):
												if os.path.exists(__lowerCAmelCase       ) and not overwrite_cache:
														logger.info(f'Loading features from cached file {cached_features_file}'       )
														A__  				=       torch.load(__lowerCAmelCase       )
												else:
														logger.info(f'Creating features from dataset file at {data_dir}'       )
														A__  				=       token_classification_task.read_examples_from_file(__lowerCAmelCase							,     __lowerCAmelCase       )
														# TODO clean up all this to leverage built-in features of tokenizers
														A__  				=       token_classification_task.convert_examples_to_features(
														    __lowerCAmelCase							,     __lowerCAmelCase							,     __lowerCAmelCase							,     __lowerCAmelCase							,     cls_token_at_end=bool(model_type in ["""xlnet"""]       )							,     cls_token=tokenizer.cls_token							,     cls_token_segment_id=2 if model_type in ["""xlnet"""] else 0							,     sep_token=tokenizer.sep_token							,     sep_token_extra=__lowerCAmelCase							,     pad_on_left=bool(tokenizer.padding_side == """left"""       )							,     pad_token=tokenizer.pad_token_id							,     pad_token_segment_id=tokenizer.pad_token_type_id							,     pad_token_label_id=self.pad_token_label_id							,     )
														logger.info(f'Saving features into cached file {cached_features_file}'       )
														torch.save(self.features							,     __lowerCAmelCase       )






								def __len__(      self       :   Union[str, Any]       )     ->     str:







										"""simple docstring"""






										return len(self.features       )







								def __getitem__(      self       :   Optional[int]							,     __lowerCAmelCase       :   int       )     ->     InputFeatures:







										"""simple docstring"""






										return self.features[i]


if is_tf_available():
					import tensorflow as tf


					class   A      :
								'''simple docstring'''




								__lowerCamelCase     :	List[InputFeatures]
								__lowerCamelCase     :	int          =   -100






								def __init__(      self       :   int							,     __lowerCAmelCase       :   TokenClassificationTask							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   PreTrainedTokenizer							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   Optional[int] = None							,     __lowerCAmelCase       :   List[str]=False							,     __lowerCAmelCase       :   Split = Split.train							,     )     ->     Optional[Any]:







										"""simple docstring"""






										A__  				=       token_classification_task.read_examples_from_file(__lowerCAmelCase							,     __lowerCAmelCase       )
										# TODO clean up all this to leverage built-in features of tokenizers
										A__  				=       token_classification_task.convert_examples_to_features(
										    __lowerCAmelCase							,     __lowerCAmelCase							,     __lowerCAmelCase							,     __lowerCAmelCase							,     cls_token_at_end=bool(model_type in ["""xlnet"""]       )							,     cls_token=tokenizer.cls_token							,     cls_token_segment_id=2 if model_type in ["""xlnet"""] else 0							,     sep_token=tokenizer.sep_token							,     sep_token_extra=__lowerCAmelCase							,     pad_on_left=bool(tokenizer.padding_side == """left"""       )							,     pad_token=tokenizer.pad_token_id							,     pad_token_segment_id=tokenizer.pad_token_type_id							,     pad_token_label_id=self.pad_token_label_id							,     )

										def gen():
												for ex in self.features:
														if ex.token_type_ids is None:
																yield (
																    {"input_ids": ex.input_ids, "attention_mask": ex.attention_mask},
																    ex.label_ids,
																)
														else:
																yield (
																    {
																        "input_ids": ex.input_ids,
																        "attention_mask": ex.attention_mask,
																        "token_type_ids": ex.token_type_ids,
																    },
																    ex.label_ids,
																)

										if "token_type_ids" not in tokenizer.model_input_names:
												A__  				=       tf.data.Dataset.from_generator(
												    __lowerCAmelCase							,     ({"""input_ids""": tf.intaa, """attention_mask""": tf.intaa}, tf.intaa)							,     (
												        {"""input_ids""": tf.TensorShape([None]       ), """attention_mask""": tf.TensorShape([None]       )},
												        tf.TensorShape([None]       ),
												    )							,     )
										else:
												A__  				=       tf.data.Dataset.from_generator(
												    __lowerCAmelCase							,     ({"""input_ids""": tf.intaa, """attention_mask""": tf.intaa, """token_type_ids""": tf.intaa}, tf.intaa)							,     (
												        {
												            """input_ids""": tf.TensorShape([None]       ),
												            """attention_mask""": tf.TensorShape([None]       ),
												            """token_type_ids""": tf.TensorShape([None]       ),
												        },
												        tf.TensorShape([None]       ),
												    )							,     )






								def        a_	(      self       :   Tuple       )     ->     Union[str, Any]:







										"""simple docstring"""






										A__  				=       self.dataset.apply(tf.data.experimental.assert_cardinality(len(self.features       )       )       )

										return self.dataset






								def __len__(      self       :   Union[str, Any]       )     ->     Any:







										"""simple docstring"""






										return len(self.features       )







								def __getitem__(      self       :   int							,     __lowerCAmelCase       :   Any       )     ->     InputFeatures:







										"""simple docstring"""






										return self.features[i]










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

import black


A   : Dict			=				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.
A   : Optional[int]			=				'''    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   ):
			'''simple docstring'''




			def        a_	(      self       :   Union[str, Any]       )     ->     List[str]:







					"""simple docstring"""






					A__  				=       tempfile.mkdtemp()
					os.makedirs(os.path.join(self.transformer_dir							,     """models/bert/"""       )       )
					A__  				=       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        a_	(      self       :   str       )     ->     Optional[int]:







					"""simple docstring"""






					A__  				=       """src/transformers"""
					shutil.rmtree(self.transformer_dir       )






			def        a_	(      self       :   List[str]							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   Optional[int]							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   Tuple=None       )     ->     Dict:







					"""simple docstring"""






					A__  				=       comment + f'\nclass {class_name}(nn.Module):\n' + class_code
					if overwrite_result is not None:
							A__  				=       comment + f'\nclass {class_name}(nn.Module):\n' + overwrite_result
					A__  				=       black.Mode(target_versions={black.TargetVersion.PYaa}							,     line_length=1_19       )
					A__  				=       black.format_str(__lowerCAmelCase							,     mode=__lowerCAmelCase       )
					A__  				=       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        a_	(      self       :   Tuple       )     ->     List[Any]:







					"""simple docstring"""






					A__  				=       check_copies.find_code_in_transformers("""models.bert.modeling_bert.BertLMPredictionHead"""       )
					self.assertEqual(__lowerCAmelCase							,     __lowerCAmelCase       )






			def        a_	(      self       :   Tuple       )     ->     Any:







					"""simple docstring"""






					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__  				=       """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        a_	(      self       :   Optional[int]       )     ->     Optional[int]:







					"""simple docstring"""






					A__  				=       check_copies.LOCALIZED_READMES["""README_zh-hans.md"""]

					A__  				=       (
					    """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__  				=       (
					    """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__  				=       (
					    """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__  				=       check_copies.convert_to_localized_md(
					    __lowerCAmelCase							,     __lowerCAmelCase							,     localized_readme["""format_model_list"""]       )

					self.assertFalse(__lowerCAmelCase       )
					self.assertEqual(__lowerCAmelCase							,     __lowerCAmelCase       )

					A__				,      A__  				=       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__  				=       (
					    """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__  				=       (
					    """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__  				=       (
					    """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__  				=       check_copies.convert_to_localized_md(
					    __lowerCAmelCase							,     __lowerCAmelCase							,     localized_readme["""format_model_list"""]       )

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



