

"""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 :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		int=1_3     ,     __SCREAMING_SNAKE_CASE :		int=7     ,     __SCREAMING_SNAKE_CASE :		Any=True     ,     __SCREAMING_SNAKE_CASE :		List[str]=True     ,     __SCREAMING_SNAKE_CASE :		Tuple=True     ,     __SCREAMING_SNAKE_CASE :		Any=True     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=9_9     ,     __SCREAMING_SNAKE_CASE :		List[Any]=1_6     ,     __SCREAMING_SNAKE_CASE :		Any=3_2     ,     __SCREAMING_SNAKE_CASE :		int=2     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=4     ,     __SCREAMING_SNAKE_CASE :		str=3_7     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]="gelu"     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]=0.1     ,     __SCREAMING_SNAKE_CASE :		Dict=0.1     ,     __SCREAMING_SNAKE_CASE :		int=5_1_2     ,     __SCREAMING_SNAKE_CASE :		Any=1_6     ,     __SCREAMING_SNAKE_CASE :		Dict=2     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]=0.0_2     ,     __SCREAMING_SNAKE_CASE :		List[Any]=3     ,     __SCREAMING_SNAKE_CASE :		int=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 :		List[str]     ,     __SCREAMING_SNAKE_CASE :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		str     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		int     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]):
							A			=					TFAlbertModel(config=__A)
							# 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(__A)

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

							A			=					model(__A)

							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 :		Tuple     ,     __SCREAMING_SNAKE_CASE :		str     ,     __SCREAMING_SNAKE_CASE :		int     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		List[str]     ,     __SCREAMING_SNAKE_CASE :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		List[str]     ,     __SCREAMING_SNAKE_CASE :		str):
							A			=					self.num_labels
							A			=					TFAlbertForPreTraining(config=__A)
							A			=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							A			=					model(__A)
							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 :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]     ,     __SCREAMING_SNAKE_CASE :		Dict):
							A			=					TFAlbertForMaskedLM(config=__A)
							A			=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							A			=					model(__A)
							self.parent.assertEqual(result.logits.shape     ,     (self.batch_size, self.seq_length, self.vocab_size))


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


		def 					SCREAMING_SNAKE_CASE__   (self :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		Any):
							A			=					TFAlbertForQuestionAnswering(config=__A)
							A			=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							A			=					model(__A)
							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 :		List[str]     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]     ,     __SCREAMING_SNAKE_CASE :		Dict     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		Dict):
							A			=					self.num_choices
							A			=					TFAlbertForMultipleChoice(config=__A)
							A			=					tf.tile(tf.expand_dims(__A     ,     1)     ,     (1, self.num_choices, 1))
							A			=					tf.tile(tf.expand_dims(__A     ,     1)     ,     (1, self.num_choices, 1))
							A			=					tf.tile(tf.expand_dims(__A     ,     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(__A)
							self.parent.assertListEqual(list(result["logits"].shape)     ,     [self.batch_size, self.num_choices])


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


		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[int]):
							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 (   UpperCamelCase__     ,		UpperCamelCase__     ,		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 :		List[str]     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		Any     ,     __SCREAMING_SNAKE_CASE :		List[str]=False):
							A			=					super()._prepare_for_class(__A     ,     __A     ,     return_labels=__A)

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

							return inputs_dict


		def 					SCREAMING_SNAKE_CASE__   (self :		Union[str, Any]):
							A			=					TFAlbertModelTester(self)
							A			=					ConfigTester(self     ,     config_class=__A     ,     hidden_size=3_7)


		def 					SCREAMING_SNAKE_CASE__   (self :		Any):
							self.config_tester.run_common_tests()


		def 					SCREAMING_SNAKE_CASE__   (self :		str):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_model(*__A)


		def 					SCREAMING_SNAKE_CASE__   (self :		Union[str, Any]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_pretraining(*__A)


		def 					SCREAMING_SNAKE_CASE__   (self :		str):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_masked_lm(*__A)


		def 					SCREAMING_SNAKE_CASE__   (self :		Any):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_multiple_choice(*__A)


		def 					SCREAMING_SNAKE_CASE__   (self :		List[Any]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_sequence_classification(*__A)


		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[int]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_albert_for_question_answering(*__A)


		@slow
		def 					SCREAMING_SNAKE_CASE__   (self :		int):



							for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												A			=					TFAlbertModel.from_pretrained(__A)
												self.assertIsNotNone(__A)





@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(__A)[0]

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

							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]     ,     __A     ,     atol=1E-4)












import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin




class      UpperCamelCase_				(   UpperCamelCase__			):
							lowerCamelCase_							=    ["image_processor", "tokenizer"]
							lowerCamelCase_							=    "AutoImageProcessor"
							lowerCamelCase_							=    "AutoTokenizer"


							def __init__(							self			:Any							, __A			:List[str]=None							, __A			:Dict=None							, **__A			:List[str]						)      ->      List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					None
									if "feature_extractor" in kwargs:
											warnings.warn(
											    """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
											    """ instead."""							, __A							, )
											SCREAMING_SNAKE_CASE__								=					kwargs.pop("""feature_extractor"""						)

									SCREAMING_SNAKE_CASE__								=					image_processor if image_processor is not None else feature_extractor
									if image_processor is None:
											raise ValueError("""You need to specify an `image_processor`."""						)
									if tokenizer is None:
											raise ValueError("""You need to specify a `tokenizer`."""						)

									super().__init__(__A							, __A						)
									SCREAMING_SNAKE_CASE__								=					self.image_processor
									SCREAMING_SNAKE_CASE__								=					False


							def __call__(							self			:List[str]							, *__A			:int							, **__A			:Optional[int]						)      ->      Optional[Any]:



									"""simple docstring"""



									if self._in_target_context_manager:
											return self.current_processor(*__A							, **__A						)

									SCREAMING_SNAKE_CASE__								=					kwargs.pop("""images"""							, __A						)
									SCREAMING_SNAKE_CASE__								=					kwargs.pop("""text"""							, __A						)
									if len(__A						) > 0:
											SCREAMING_SNAKE_CASE__								=					args[0]
											SCREAMING_SNAKE_CASE__								=					args[1:]

									if images is None and text is None:
											raise ValueError("""You need to specify either an `images` or `text` input to process."""						)

									if images is not None:
											SCREAMING_SNAKE_CASE__								=					self.image_processor(__A							, *__A							, **__A						)
									if text is not None:
											SCREAMING_SNAKE_CASE__								=					self.tokenizer(__A							, **__A						)

									if text is None:
											return inputs
									elif images is None:
											return encodings
									else:
											SCREAMING_SNAKE_CASE__								=					encodings["""input_ids"""]
											return inputs


							def    _snake_case     (							self			:Any							, *__A			:Optional[Any]							, **__A			:int						)      ->      List[Any]:



									"""simple docstring"""



									return self.tokenizer.batch_decode(*__A							, **__A						)


							def    _snake_case     (							self			:str							, *__A			:Optional[int]							, **__A			:List[Any]						)      ->      List[str]:



									"""simple docstring"""



									return self.tokenizer.decode(*__A							, **__A						)


							@contextmanager
							def    _snake_case     (							self			:Dict						)      ->      List[str]:



									"""simple docstring"""



									warnings.warn(
									    """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """
									    """labels by using the argument `text` of the regular `__call__` method (either in the same call as """
									    """your images inputs, or in a separate call."""						)
									SCREAMING_SNAKE_CASE__								=					True
									SCREAMING_SNAKE_CASE__								=					self.tokenizer
									yield
									SCREAMING_SNAKE_CASE__								=					self.image_processor
									SCREAMING_SNAKE_CASE__								=					False


							@property
							def    _snake_case     (							self			:List[str]						)      ->      int:



									"""simple docstring"""



									warnings.warn(
									    """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""							, __A							, )
									return self.image_processor_class


							@property
							def    _snake_case     (							self			:str						)      ->      List[Any]:



									"""simple docstring"""



									warnings.warn(
									    """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""							, __A							, )
									return self.image_processor