

"""simple docstring"""




from __future__ import annotations

import unittest

from transformers import AlbertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import TF_MODEL_FOR_PRETRAINING_MAPPING
	from transformers.models.albert.modeling_tf_albert import (
	    TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
	    TFAlbertForMaskedLM,
	    TFAlbertForMultipleChoice,
	    TFAlbertForPreTraining,
	    TFAlbertForQuestionAnswering,
	    TFAlbertForSequenceClassification,
	    TFAlbertForTokenClassification,
	    TFAlbertModel,
	)





class 			__UpperCamelCase :


		def __init__(self :		Tuple     ,     __SCREAMING_SNAKE_CASE :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		List[Any]=1_3     ,     __SCREAMING_SNAKE_CASE :		List[Any]=7     ,     __SCREAMING_SNAKE_CASE :		int=True     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=True     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]=True     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=True     ,     __SCREAMING_SNAKE_CASE :		Tuple=9_9     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=1_6     ,     __SCREAMING_SNAKE_CASE :		Tuple=3_2     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]=2     ,     __SCREAMING_SNAKE_CASE :		List[Any]=4     ,     __SCREAMING_SNAKE_CASE :		Tuple=3_7     ,     __SCREAMING_SNAKE_CASE :		Any="gelu"     ,     __SCREAMING_SNAKE_CASE :		int=0.1     ,     __SCREAMING_SNAKE_CASE :		Any=0.1     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=5_1_2     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=1_6     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=2     ,     __SCREAMING_SNAKE_CASE :		str=0.0_2     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]=3     ,     __SCREAMING_SNAKE_CASE :		Dict=4     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]=None     ,     ):
							A			=					parent
							A			=					1_3
							A			=					7
							A			=					True
							A			=					True
							A			=					True
							A			=					True
							A			=					9_9
							A			=					1_6
							A			=					3_2
							A			=					2
							A			=					4
							A			=					3_7
							A			=					"gelu"
							A			=					0.1
							A			=					0.1
							A			=					5_1_2
							A			=					1_6
							A			=					2
							A			=					0.0_2
							A			=					3
							A			=					4
							A			=					None


		def 					SCREAMING_SNAKE_CASE__   (self :		Tuple):
							A			=					ids_tensor([self.batch_size, self.seq_length]     ,     self.vocab_size)

							A			=					None
							if self.use_input_mask:
												A			=					random_attention_mask([self.batch_size, self.seq_length])

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

							A			=					None
							A			=					None
							A			=					None
							if self.use_labels:
												A			=					ids_tensor([self.batch_size]     ,     self.type_sequence_label_size)
												A			=					ids_tensor([self.batch_size, self.seq_length]     ,     self.num_labels)
												A			=					ids_tensor([self.batch_size]     ,     self.num_choices)

							A			=					AlbertConfig(
							    vocab_size=self.vocab_size     ,     hidden_size=self.hidden_size     ,     embedding_size=self.embedding_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     ,     initializer_range=self.initializer_range     ,     )

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


		def 					SCREAMING_SNAKE_CASE__   (self :		Union[str, Any]     ,     __SCREAMING_SNAKE_CASE :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		str     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		List[str]     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		int     ,     __SCREAMING_SNAKE_CASE :		Optional[int]):
							A			=					TFAlbertModel(config=__SCREAMING_SNAKE_CASE)
							# inputs = {'input_ids': input_ids,
							#           'attention_mask': input_mask,
							#           'token_type_ids': token_type_ids}
							# sequence_output, pooled_output = model(**inputs)
							A			=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							A			=					model(__SCREAMING_SNAKE_CASE)

							A			=					[input_ids, input_mask]
							A			=					model(__SCREAMING_SNAKE_CASE)

							A			=					model(__SCREAMING_SNAKE_CASE)

							self.parent.assertEqual(result.last_hidden_state.shape     ,     (self.batch_size, self.seq_length, self.hidden_size))
							self.parent.assertEqual(result.pooler_output.shape     ,     (self.batch_size, self.hidden_size))


		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		int     ,     __SCREAMING_SNAKE_CASE :		str     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		List[Any]):
							A			=					self.num_labels
							A			=					TFAlbertForPreTraining(config=__SCREAMING_SNAKE_CASE)
							A			=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							A			=					model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.prediction_logits.shape     ,     (self.batch_size, self.seq_length, self.vocab_size))
							self.parent.assertEqual(result.sop_logits.shape     ,     (self.batch_size, self.num_labels))


		def 					SCREAMING_SNAKE_CASE__   (self :		Dict     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		int     ,     __SCREAMING_SNAKE_CASE :		List[str]     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Tuple):
							A			=					TFAlbertForMaskedLM(config=__SCREAMING_SNAKE_CASE)
							A			=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							A			=					model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.logits.shape     ,     (self.batch_size, self.seq_length, self.vocab_size))


		def 					SCREAMING_SNAKE_CASE__   (self :		Tuple     ,     __SCREAMING_SNAKE_CASE :		int     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		Optional[int]):
							A			=					self.num_labels
							A			=					TFAlbertForSequenceClassification(config=__SCREAMING_SNAKE_CASE)
							A			=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							A			=					model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.logits.shape     ,     (self.batch_size, self.num_labels))


		def 					SCREAMING_SNAKE_CASE__   (self :		Union[str, Any]     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]):
							A			=					TFAlbertForQuestionAnswering(config=__SCREAMING_SNAKE_CASE)
							A			=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							A			=					model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.start_logits.shape     ,     (self.batch_size, self.seq_length))
							self.parent.assertEqual(result.end_logits.shape     ,     (self.batch_size, self.seq_length))


		def 					SCREAMING_SNAKE_CASE__   (self :		Any     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]     ,     __SCREAMING_SNAKE_CASE :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		str     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		Tuple):
							A			=					self.num_choices
							A			=					TFAlbertForMultipleChoice(config=__SCREAMING_SNAKE_CASE)
							A			=					tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE     ,     1)     ,     (1, self.num_choices, 1))
							A			=					tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE     ,     1)     ,     (1, self.num_choices, 1))
							A			=					tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE     ,     1)     ,     (1, self.num_choices, 1))
							A			=					{
							    "input_ids": multiple_choice_inputs_ids,
							    "attention_mask": multiple_choice_input_mask,
							    "token_type_ids": multiple_choice_token_type_ids,
							}
							A			=					model(__SCREAMING_SNAKE_CASE)
							self.parent.assertListEqual(list(result["logits"].shape)     ,     [self.batch_size, self.num_choices])


		def 					SCREAMING_SNAKE_CASE__   (self :		Dict     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		Tuple):
							A			=					self.num_labels
							A			=					TFAlbertForTokenClassification(config=__SCREAMING_SNAKE_CASE)
							A			=					{
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}
							A			=					model(__SCREAMING_SNAKE_CASE)
							self.parent.assertListEqual(list(result["logits"].shape)     ,     [self.batch_size, self.seq_length, self.num_labels])


		def 					SCREAMING_SNAKE_CASE__   (self :		str):
							A			=					self.prepare_config_and_inputs()
							(
							    (
							    A
							)			,    (
							    A
							)			,    (
							    A
							)			,    (
							    A
							)			,    (
							    A
							)			,    (
							    A
							)			,    (
							    A
							)			,    
							)			=					config_and_inputs
							A			=					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
							return config, inputs_dict





@require_tf
class 			__UpperCamelCase (   _A     ,		_A     ,		unittest.TestCase						):
		SCREAMING_SNAKE_CASE								=    (
		    (
		        TFAlbertModel,
		        TFAlbertForPreTraining,
		        TFAlbertForMaskedLM,
		        TFAlbertForSequenceClassification,
		        TFAlbertForQuestionAnswering,
		        TFAlbertForTokenClassification,
		        TFAlbertForMultipleChoice,
		    )
		    if is_tf_available()
		    else ()
		)
		SCREAMING_SNAKE_CASE								=    (
		    {
		        "feature-extraction": TFAlbertModel,
		        "fill-mask": TFAlbertForMaskedLM,
		        "question-answering": TFAlbertForQuestionAnswering,
		        "text-classification": TFAlbertForSequenceClassification,
		        "token-classification": TFAlbertForTokenClassification,
		        "zero-shot": TFAlbertForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)
		SCREAMING_SNAKE_CASE								=    False
		SCREAMING_SNAKE_CASE								=    False


		def 					SCREAMING_SNAKE_CASE__   (self :		Any     ,     __SCREAMING_SNAKE_CASE :		List[str]     ,     __SCREAMING_SNAKE_CASE :		str     ,     __SCREAMING_SNAKE_CASE :		Tuple=False):
							A			=					super()._prepare_for_class(__SCREAMING_SNAKE_CASE     ,     __SCREAMING_SNAKE_CASE     ,     return_labels=__SCREAMING_SNAKE_CASE)

							if return_labels:
												if model_class in get_values(__SCREAMING_SNAKE_CASE):
																	A			=					tf.zeros(self.model_tester.batch_size     ,     dtype=tf.intaa)

							return inputs_dict


		def 					SCREAMING_SNAKE_CASE__   (self :		int):
							A			=					TFAlbertModelTester(self)
							A			=					ConfigTester(self     ,     config_class=__SCREAMING_SNAKE_CASE     ,     hidden_size=3_7)


		def 					SCREAMING_SNAKE_CASE__   (self :		List[str]):
							self.config_tester.run_common_tests()


		def 					SCREAMING_SNAKE_CASE__   (self :		int):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_model(*__SCREAMING_SNAKE_CASE)


		def 					SCREAMING_SNAKE_CASE__   (self :		List[str]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_pretraining(*__SCREAMING_SNAKE_CASE)


		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[Any]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_masked_lm(*__SCREAMING_SNAKE_CASE)


		def 					SCREAMING_SNAKE_CASE__   (self :		List[str]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_multiple_choice(*__SCREAMING_SNAKE_CASE)


		def 					SCREAMING_SNAKE_CASE__   (self :		str):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_sequence_classification(*__SCREAMING_SNAKE_CASE)


		def 					SCREAMING_SNAKE_CASE__   (self :		List[str]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_question_answering(*__SCREAMING_SNAKE_CASE)


		@slow
		def 					SCREAMING_SNAKE_CASE__   (self :		Any):
							for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												A			=					TFAlbertModel.from_pretrained(__SCREAMING_SNAKE_CASE)
												self.assertIsNotNone(__SCREAMING_SNAKE_CASE)





@require_tf
class 			__UpperCamelCase (   unittest.TestCase						):


		@slow
		def 					SCREAMING_SNAKE_CASE__   (self :		Dict):
							A			=					TFAlbertForPreTraining.from_pretrained("albert-base-v2")
							A			=					tf.constant([[0, 1, 2, 3, 4, 5]])
							A			=					model(__SCREAMING_SNAKE_CASE)[0]

							A			=					[1, 6, 3_0_0_0_0]
							self.assertEqual(output.shape     ,     __SCREAMING_SNAKE_CASE)

							A			=					tf.constant(
							    [
							        [
							            [4.5_9_5_6_6_8, 0.7_4_4_6_2_7_5_4, -1.8_1_8_1_4_7],
							            [4.5_9_5_4_3_4_7, 0.7_4_5_4_1_8_4, -1.8_1_8_8_2_5_8],
							            [4.5_9_5_4_9_0_5, 0.7_4_4_8_2_3_5, -1.8_1_8_2_3_1_6],
							        ]
							    ])
							tf.debugging.assert_near(output[:, :3, :3]     ,     __SCREAMING_SNAKE_CASE     ,     atol=1E-4)








"""simple docstring"""




def    __SCREAMING_SNAKE_CASE						(						lowercase__ = 1_000      ):
					"""simple docstring"""
					return sum(i for i in range(lowercase__      ) if i % 3 == 0 or i % 5 == 0      )


if __name__ == "__main__":
	print(f"""{solution() = }""")





