
import unittest

import numpy as np

from transformers import AlbertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
							import jax.numpy as jnp

							from transformers.models.albert.modeling_flax_albert import (
							    FlaxAlbertForMaskedLM,
							    FlaxAlbertForMultipleChoice,
							    FlaxAlbertForPreTraining,
							    FlaxAlbertForQuestionAnswering,
							    FlaxAlbertForSequenceClassification,
							    FlaxAlbertForTokenClassification,
							    FlaxAlbertModel,
							)





class     lowerCamelCase      (       unittest.TestCase					):







	def __init__(     self      :Union[str, Any]   ,     lowercase      :Optional[int]   ,     lowercase      :List[str]=1_3   ,     lowercase      :Optional[Any]=7   ,     lowercase      :Any=True   ,     lowercase      :Dict=True   ,     lowercase      :Any=True   ,     lowercase      :List[Any]=True   ,     lowercase      :Dict=9_9   ,     lowercase      :Tuple=3_2   ,     lowercase      :Dict=5   ,     lowercase      :Any=4   ,     lowercase      :Tuple=3_7   ,     lowercase      :str="gelu"   ,     lowercase      :Union[str, Any]=0.1   ,     lowercase      :Any=0.1   ,     lowercase      :Union[str, Any]=5_1_2   ,     lowercase      :List[Any]=1_6   ,     lowercase      :List[str]=2   ,     lowercase      :Any=0.02   ,     lowercase      :Dict=4   ,     )		->      Union[str, Any]:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= parent
				SCREAMING_SNAKE_CASE     						= batch_size
				SCREAMING_SNAKE_CASE     						= seq_length
				SCREAMING_SNAKE_CASE     						= is_training
				SCREAMING_SNAKE_CASE     						= use_attention_mask
				SCREAMING_SNAKE_CASE     						= use_token_type_ids
				SCREAMING_SNAKE_CASE     						= use_labels
				SCREAMING_SNAKE_CASE     						= vocab_size
				SCREAMING_SNAKE_CASE     						= hidden_size
				SCREAMING_SNAKE_CASE     						= num_hidden_layers
				SCREAMING_SNAKE_CASE     						= num_attention_heads
				SCREAMING_SNAKE_CASE     						= intermediate_size
				SCREAMING_SNAKE_CASE     						= hidden_act
				SCREAMING_SNAKE_CASE     						= hidden_dropout_prob
				SCREAMING_SNAKE_CASE     						= attention_probs_dropout_prob
				SCREAMING_SNAKE_CASE     						= max_position_embeddings
				SCREAMING_SNAKE_CASE     						= type_vocab_size
				SCREAMING_SNAKE_CASE     						= type_sequence_label_size
				SCREAMING_SNAKE_CASE     						= initializer_range
				SCREAMING_SNAKE_CASE     						= num_choices







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







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= ids_tensor([self.batch_size, self.seq_length]   ,     self.vocab_size			)

				SCREAMING_SNAKE_CASE     						= None
				if self.use_attention_mask:
							SCREAMING_SNAKE_CASE     						= random_attention_mask([self.batch_size, self.seq_length]			)

				SCREAMING_SNAKE_CASE     						= None
				if self.use_token_type_ids:
							SCREAMING_SNAKE_CASE     						= ids_tensor([self.batch_size, self.seq_length]   ,     self.type_vocab_size			)

				SCREAMING_SNAKE_CASE     						= AlbertConfig(
				    vocab_size=self.vocab_size   ,     hidden_size=self.hidden_size   ,     num_hidden_layers=self.num_hidden_layers   ,     num_attention_heads=self.num_attention_heads   ,     intermediate_size=self.intermediate_size   ,     hidden_act=self.hidden_act   ,     hidden_dropout_prob=self.hidden_dropout_prob   ,     attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,     max_position_embeddings=self.max_position_embeddings   ,     type_vocab_size=self.type_vocab_size   ,     is_decoder=lowercase   ,     initializer_range=self.initializer_range   ,     )

				return config, input_ids, token_type_ids, attention_mask







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







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= self.prepare_config_and_inputs()
				SCREAMING_SNAKE_CASE						,							SCREAMING_SNAKE_CASE						,							SCREAMING_SNAKE_CASE						,							SCREAMING_SNAKE_CASE     						= config_and_inputs
				SCREAMING_SNAKE_CASE     						= {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
				return config, inputs_dict





@require_flax
class     lowerCamelCase      (       __lowerCamelCase ,		unittest.TestCase					):
	UpperCamelCase_  :					Tuple    		=	(
	    (
	        FlaxAlbertModel,
	        FlaxAlbertForPreTraining,
	        FlaxAlbertForMaskedLM,
	        FlaxAlbertForMultipleChoice,
	        FlaxAlbertForQuestionAnswering,
	        FlaxAlbertForSequenceClassification,
	        FlaxAlbertForTokenClassification,
	        FlaxAlbertForQuestionAnswering,
	    )
	    if is_flax_available()
	    else ()
	)







	def  snake_case__     (     self      :Any			)		->      List[str]:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= FlaxAlbertModelTester(self			)







	@slow
	def  snake_case__     (     self      :Dict			)		->      List[Any]:







				"""simple docstring"""






				for model_class_name in self.all_model_classes:
							SCREAMING_SNAKE_CASE     						= model_class_name.from_pretrained('''albert-base-v2'''			)
							SCREAMING_SNAKE_CASE     						= model(np.ones((1, 1)			)			)
							self.assertIsNotNone(lowercase			)





@require_flax
class     lowerCamelCase      (       unittest.TestCase					):







	@slow
	def  snake_case__     (     self      :int			)		->      str:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= FlaxAlbertModel.from_pretrained('''albert-base-v2'''			)
				SCREAMING_SNAKE_CASE     						= np.array([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]]			)
				SCREAMING_SNAKE_CASE     						= np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]			)
				SCREAMING_SNAKE_CASE     						= model(lowercase   ,     attention_mask=lowercase			)[0]
				SCREAMING_SNAKE_CASE     						= (1, 1_1, 7_6_8)
				self.assertEqual(output.shape   ,     lowercase			)
				SCREAMING_SNAKE_CASE     						= np.array(
				    [[[-0.65_13, 1.50_35, -0.27_66], [-0.65_15, 1.50_46, -0.27_80], [-0.65_12, 1.50_49, -0.27_84]]]			)

				self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]   ,     lowercase   ,     atol=1e-4			)			)

from __future__ import annotations





class     lowerCamelCase      :







	def __init__(     self      :List[Any]   ,     lowercase      :list[list[int]]			)		->      Dict:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= 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(lowercase			) != 0:
							SCREAMING_SNAKE_CASE     						= len(rows[0]			)
							if cols == 0:
										raise error
							for row in rows:
										if len(lowercase			) != cols:
													raise error
										for value in row:
													if not isinstance(lowercase   ,     (int, float)			):
																raise error
							SCREAMING_SNAKE_CASE     						= rows
				else:
							SCREAMING_SNAKE_CASE     						= []







	def  snake_case__     (     self      :List[str]			)		->      list[list[int]]:







				"""simple docstring"""






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







	@property
	def  snake_case__     (     self      :Any			)		->      int:







				"""simple docstring"""






				return len(self.rows			)







	@property
	def  snake_case__     (     self      :List[Any]			)		->      int:







				"""simple docstring"""






				return len(self.rows[0]			)







	@property
	def  snake_case__     (     self      :Dict			)		->      tuple[int, int]:







				"""simple docstring"""






				return (self.num_rows, self.num_columns)







	@property
	def  snake_case__     (     self      :Any			)		->      bool:







				"""simple docstring"""






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







	def  snake_case__     (     self      :Tuple			)		->      Matrix:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= [
				    [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(lowercase			)







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







				"""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  snake_case__     (     self      :int			)		->      bool:







				"""simple docstring"""






				return bool(self.determinant()			)







	def  snake_case__     (     self      :List[str]   ,     lowercase      :int   ,     lowercase      :int			)		->      int:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= [
				    [
				        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(lowercase			).determinant()







	def  snake_case__     (     self      :Union[str, Any]   ,     lowercase      :int   ,     lowercase      :int			)		->      int:







				"""simple docstring"""






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







	def  snake_case__     (     self      :List[Any]			)		->      Matrix:







				"""simple docstring"""






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







	def  snake_case__     (     self      :Dict			)		->      Matrix:







				"""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  snake_case__     (     self      :str			)		->      Matrix:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= [
				    [self.cofactors().rows[column][row] for column in range(self.num_columns			)]
				    for row in range(self.num_rows			)
				]
				return Matrix(lowercase			)







	def  snake_case__     (     self      :Any			)		->      Matrix:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= 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      :Union[str, Any]			)		->      str:







				"""simple docstring"""






				return str(self.rows			)







	def __str__(     self      :List[str]			)		->      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(lowercase			) for value in row]			) + '''.]'''
				            for row in self.rows
				        ]			)
				    + "]"
				)







	def  snake_case__     (     self      :int   ,     lowercase      :list[int]   ,     lowercase      :int | None = None			)		->      None:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE     						= TypeError('''Row must be a list containing all ints and/or floats'''			)
				if not isinstance(lowercase   ,     lowercase			):
							raise type_error
				for value in row:
							if not isinstance(lowercase   ,     (int, float)			):
										raise type_error
				if len(lowercase			) != 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(lowercase			)
				else:
							SCREAMING_SNAKE_CASE     						= self.rows[0:position] + [row] + self.rows[position:]







	def  snake_case__     (     self      :Union[str, Any]   ,     lowercase      :list[int]   ,     lowercase      :int | None = None			)		->      None:







				"""simple docstring"""






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







	def __eq__(     self      :Union[str, Any]   ,     lowercase      :object			)		->      bool:







				"""simple docstring"""






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







	def __ne__(     self      :int   ,     lowercase      :object			)		->      bool:







				"""simple docstring"""






				return not self == other







	def __neg__(     self      :int			)		->      Matrix:







				"""simple docstring"""






				return self * -1







	def __add__(     self      :Optional[Any]   ,     lowercase      :Matrix			)		->      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      :Optional[Any]   ,     lowercase      :Matrix			)		->      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[int]   ,     lowercase      :Matrix | int | float			)		->      Matrix:







				"""simple docstring"""






				if isinstance(lowercase   ,     (int, float)			):
							return Matrix(
							    [[int(element * other			) for element in row] for row in self.rows]			)
				elif isinstance(lowercase   ,     lowercase			):
							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(lowercase   ,     lowercase			) 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      :str   ,     lowercase      :int			)		->      Matrix:







				"""simple docstring"""






				if not isinstance(lowercase   ,     lowercase			):
							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'''			)
				SCREAMING_SNAKE_CASE     						= self
				for _ in range(other - 1			):
							result *= self
				return result







	@classmethod
	def  snake_case__     (     cls      :List[Any]   ,     lowercase      :list[int]   ,     lowercase      :list[int]			)		->      int:







				"""simple docstring"""






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


if __name__ == "__main__":
							import doctest

							doctest.testmod()