"""simple docstring"""







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

import black


SCREAMING_SNAKE_CASE									=						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.
SCREAMING_SNAKE_CASE									=						'    def __init__(self, config):\n        super().__init__()\n        self.transform = BertPredictionHeadTransform(config)\n\n        # The output weights are the same as the input embeddings, but there is\n        # an output-only bias for each token.\n        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)\n\n        self.bias = nn.Parameter(torch.zeros(config.vocab_size))\n\n        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`\n        self.decoder.bias = self.bias\n\n    def forward(self, hidden_states):\n        hidden_states = self.transform(hidden_states)\n        hidden_states = self.decoder(hidden_states)\n        return hidden_states\n'



class  _lowerCamelCase			(unittest.TestCase     ):







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					_lowercase :    Union[str, Any]							=							tempfile.mkdtemp()
					os.makedirs(os.path.join(self.transformer_dir			,					'models/bert/'						)						)
					_lowercase :    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						):

					"""simple docstring"""






					_lowercase :    str							=							'src/transformers'
					shutil.rmtree(self.transformer_dir						)







				def 							__UpperCAmelCase					( self    :       List[str]			,					lowerCamelCase_    :       Tuple			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       List[str]			,					lowerCamelCase_    :       str=None						):

					"""simple docstring"""






					_lowercase :    Any							=							comment + F'''\nclass {class_name}(nn.Module):\n''' + class_code
					if overwrite_result is not None:
						_lowercase :    Dict							=							comment + F'''\nclass {class_name}(nn.Module):\n''' + overwrite_result
					_lowercase :    Optional[Any]							=							black.Mode(target_versions={black.TargetVersion.PYaa}			,					line_length=1_1_9						)
					_lowercase :    List[Any]							=							black.format_str(lowerCamelCase_			,					mode=lowerCamelCase_						)
					_lowercase :    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    :       str						):

					"""simple docstring"""






					_lowercase :    str							=							check_copies.find_code_in_transformers('models.bert.modeling_bert.BertLMPredictionHead'						)
					self.assertEqual(lowerCamelCase_			,					lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       int						):

					"""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
					_lowercase :    str							=							'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    :       Tuple						):

					"""simple docstring"""






					_lowercase :    int							=							check_copies.LOCALIZED_READMES['README_zh-hans.md']

					_lowercase :    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.\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.'
					)
					_lowercase :    int							=							(
					    '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'
					)
					_lowercase :    Tuple							=							(
					    '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'
					)

					_lowercase				,      _lowercase :    Union[str, Any]							=							check_copies.convert_to_localized_md(
					    lowerCamelCase_			,					lowerCamelCase_			,					localized_readme['format_model_list']						)

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

					_lowercase				,      _lowercase :    List[Any]							=							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_						)

					_lowercase :    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.'
					)
					_lowercase :    Optional[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'
					)
					_lowercase :    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'
					)

					_lowercase				,      _lowercase :    Union[str, Any]							=							check_copies.convert_to_localized_md(
					    lowerCamelCase_			,					lowerCamelCase_			,					localized_readme['format_model_list']						)

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




"""simple docstring"""







from __future__ import annotations



class  _lowerCamelCase			:







				def __init__( self    :       Any			,					lowerCamelCase_    :       list[list[int]]						):

					"""simple docstring"""






					_lowercase :    Tuple							=							TypeError(
					    'Matrices must be formed from a list of zero or more lists containing at '
					    'least one and the same number of values, each of which must be of type '
					    'int or float.'						)
					if len(lowerCamelCase_						) != 0:
						_lowercase :    Dict							=							len(rows[0]						)
						if cols == 0:
							raise error
						for row in rows:
							if len(lowerCamelCase_						) != cols:
								raise error
							for value in row:
								if not isinstance(lowerCamelCase_			,					(int, float)						):
									raise error
						_lowercase :    int							=							rows
					else:
						_lowercase :    Optional[Any]							=							[]







				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					return [[row[i] for row in self.rows] for i in range(len(self.rows[0]						)						)]







				@property
				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					return len(self.rows						)







				@property
				def 							__UpperCAmelCase					( self    :       int						):

					"""simple docstring"""






					return len(self.rows[0]						)







				@property
				def 							__UpperCAmelCase					( self    :       Tuple						):

					"""simple docstring"""






					return (self.num_rows, self.num_columns)







				@property
				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					return self.order[0] == self.order[1]







				def 							__UpperCAmelCase					( self    :       Optional[Any]						):

					"""simple docstring"""






					_lowercase :    Optional[int]							=							[
					    [0 if column_num != row_num else 1 for column_num in range(self.num_rows						)]
					    for row_num in range(self.num_rows						)
					]
					return Matrix(lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					if not self.is_square:
						return 0
					if self.order == (0, 0):
						return 1
					if self.order == (1, 1):
						return int(self.rows[0][0]						)
					if self.order == (2, 2):
						return int(
						    (self.rows[0][0] * self.rows[1][1])
						    - (self.rows[0][1] * self.rows[1][0])						)
					else:
						return sum(
						    self.rows[0][column] * self.cofactors().rows[0][column]
						    for column in range(self.num_columns						)						)







				def 							__UpperCAmelCase					( self    :       Union[str, Any]						):

					"""simple docstring"""






					return bool(self.determinant()						)







				def 							__UpperCAmelCase					( self    :       int			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					_lowercase :    List[str]							=							[
					    [
					        self.rows[other_row][other_column]
					        for other_column in range(self.num_columns						)
					        if other_column != column
					    ]
					    for other_row in range(self.num_rows						)
					    if other_row != row
					]
					return Matrix(lowerCamelCase_						).determinant()







				def 							__UpperCAmelCase					( self    :       str			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if (row + column) % 2 == 0:
						return self.get_minor(lowerCamelCase_			,					lowerCamelCase_						)
					return -1 * self.get_minor(lowerCamelCase_			,					lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					return Matrix(
					    [
					        [self.get_minor(lowerCamelCase_			,					lowerCamelCase_						) for column in range(self.num_columns						)]
					        for row in range(self.num_rows						)
					    ]						)







				def 							__UpperCAmelCase					( self    :       Tuple						):

					"""simple docstring"""






					return Matrix(
					    [
					        [
					            self.minors().rows[row][column]
					            if (row + column) % 2 == 0
					            else self.minors().rows[row][column] * -1
					            for column in range(self.minors().num_columns						)
					        ]
					        for row in range(self.minors().num_rows						)
					    ]						)







				def 							__UpperCAmelCase					( self    :       Tuple						):

					"""simple docstring"""






					_lowercase :    str							=							[
					    [self.cofactors().rows[column][row] for column in range(self.num_columns						)]
					    for row in range(self.num_rows						)
					]
					return Matrix(lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       Union[str, Any]						):

					"""simple docstring"""






					_lowercase :    Dict							=							self.determinant()
					if not determinant:
						raise TypeError('Only matrices with a non-zero determinant have an inverse'						)
					return self.adjugate() * (1 / determinant)







				def __repr__( self    :       List[str]						):

					"""simple docstring"""






					return str(self.rows						)







				def __str__( self    :       str						):

					"""simple docstring"""






					if self.num_rows == 0:
						return "[]"
					if self.num_rows == 1:
						return "[[" + ". ".join(str(self.rows[0]						)						) + "]]"
					return (
					    "["
					    + "\n ".join(
					        [
					            '[' + '. '.join([str(lowerCamelCase_						) for value in row]						) + '.]'
					            for row in self.rows
					        ]						)
					    + "]"
					)







				def 							__UpperCAmelCase					( self    :       Union[str, Any]			,					lowerCamelCase_    :       list[int]			,					lowerCamelCase_    :       int | None = None						):

					"""simple docstring"""






					_lowercase :    Union[str, Any]							=							TypeError('Row must be a list containing all ints and/or floats'						)
					if not isinstance(lowerCamelCase_			,					lowerCamelCase_						):
						raise type_error
					for value in row:
						if not isinstance(lowerCamelCase_			,					(int, float)						):
							raise type_error
					if len(lowerCamelCase_						) != self.num_columns:
						raise ValueError(
						    'Row must be equal in length to the other rows in the matrix'						)
					if position is None:
						self.rows.append(lowerCamelCase_						)
					else:
						_lowercase :    Any							=							self.rows[0:position] + [row] + self.rows[position:]







				def 							__UpperCAmelCase					( self    :       str			,					lowerCamelCase_    :       list[int]			,					lowerCamelCase_    :       int | None = None						):

					"""simple docstring"""






					_lowercase :    Tuple							=							TypeError(
					    'Column must be a list containing all ints and/or floats'						)
					if not isinstance(lowerCamelCase_			,					lowerCamelCase_						):
						raise type_error
					for value in column:
						if not isinstance(lowerCamelCase_			,					(int, float)						):
							raise type_error
					if len(lowerCamelCase_						) != self.num_rows:
						raise ValueError(
						    'Column must be equal in length to the other columns in the matrix'						)
					if position is None:
						_lowercase :    List[Any]							=							[self.rows[i] + [column[i]] for i in range(self.num_rows						)]
					else:
						_lowercase :    Any							=							[
						    self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
						    for i in range(self.num_rows						)
						]







				def __eq__( self    :       Union[str, Any]			,					lowerCamelCase_    :       object						):

					"""simple docstring"""






					if not isinstance(lowerCamelCase_			,					lowerCamelCase_						):
						return NotImplemented
					return self.rows == other.rows







				def __ne__( self    :       Any			,					lowerCamelCase_    :       object						):

					"""simple docstring"""






					return not self == other







				def __neg__( self    :       int						):

					"""simple docstring"""






					return self * -1







				def __add__( self    :       Optional[int]			,					lowerCamelCase_    :       Matrix						):

					"""simple docstring"""






					if self.order != other.order:
						raise ValueError('Addition requires matrices of the same order'						)
					return Matrix(
					    [
					        [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns						)]
					        for i in range(self.num_rows						)
					    ]						)







				def __sub__( self    :       str			,					lowerCamelCase_    :       Matrix						):

					"""simple docstring"""






					if self.order != other.order:
						raise ValueError('Subtraction requires matrices of the same order'						)
					return Matrix(
					    [
					        [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns						)]
					        for i in range(self.num_rows						)
					    ]						)







				def __mul__( self    :       Optional[Any]			,					lowerCamelCase_    :       Matrix | int | float						):

					"""simple docstring"""






					if isinstance(lowerCamelCase_			,					(int, float)						):
						return Matrix(
						    [[int(element * other						) for element in row] for row in self.rows]						)
					elif isinstance(lowerCamelCase_			,					lowerCamelCase_						):
						if self.num_columns != other.num_rows:
							raise ValueError(
							    'The number of columns in the first matrix must '
							    'be equal to the number of rows in the second'						)
						return Matrix(
						    [
						        [Matrix.dot_product(lowerCamelCase_			,					lowerCamelCase_						) for column in other.columns()]
						        for row in self.rows
						    ]						)
					else:
						raise TypeError(
						    'A Matrix can only be multiplied by an int, float, or another matrix'						)







				def __pow__( self    :       Optional[Any]			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if not isinstance(lowerCamelCase_			,					lowerCamelCase_						):
						raise TypeError('A Matrix can only be raised to the power of an int'						)
					if not self.is_square:
						raise ValueError('Only square matrices can be raised to a power'						)
					if other == 0:
						return self.identity()
					if other < 0:
						if self.is_invertable():
							return self.inverse() ** (-other)
						raise ValueError(
						    'Only invertable matrices can be raised to a negative power'						)
					_lowercase :    str							=							self
					for _ in range(other - 1						):
						result *= self
					return result







				@classmethod
				def 							__UpperCAmelCase					( cls    :       str			,					lowerCamelCase_    :       list[int]			,					lowerCamelCase_    :       list[int]						):

					"""simple docstring"""






					return sum(row[i] * column[i] for i in range(len(lowerCamelCase_						)						)						)


if __name__ == "__main__":
						import doctest

						doctest.testmod()



