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        lowercase_  :



	"""simple docstring"""





	def __init__(							self		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE=13		,      __SCREAMING_SNAKE_CASE=7		,      __SCREAMING_SNAKE_CASE=True		,      __SCREAMING_SNAKE_CASE=True		,      __SCREAMING_SNAKE_CASE=True		,      __SCREAMING_SNAKE_CASE=True		,      __SCREAMING_SNAKE_CASE=99		,      __SCREAMING_SNAKE_CASE=16		,      __SCREAMING_SNAKE_CASE=32		,      __SCREAMING_SNAKE_CASE=2		,      __SCREAMING_SNAKE_CASE=4		,      __SCREAMING_SNAKE_CASE=37		,      __SCREAMING_SNAKE_CASE="gelu"		,      __SCREAMING_SNAKE_CASE=0.1		,      __SCREAMING_SNAKE_CASE=0.1		,      __SCREAMING_SNAKE_CASE=512		,      __SCREAMING_SNAKE_CASE=16		,      __SCREAMING_SNAKE_CASE=2		,      __SCREAMING_SNAKE_CASE=0.0_2		,      __SCREAMING_SNAKE_CASE=3		,      __SCREAMING_SNAKE_CASE=4		,      __SCREAMING_SNAKE_CASE=None		,      )						->Tuple:
								lowerCAmelCase     		=		parent
								lowerCAmelCase     		=		13
								lowerCAmelCase     		=		7
								lowerCAmelCase     		=		True
								lowerCAmelCase     		=		True
								lowerCAmelCase     		=		True
								lowerCAmelCase     		=		True
								lowerCAmelCase     		=		99
								lowerCAmelCase     		=		16
								lowerCAmelCase     		=		32
								lowerCAmelCase     		=		2
								lowerCAmelCase     		=		4
								lowerCAmelCase     		=		37
								lowerCAmelCase     		=		'''gelu'''
								lowerCAmelCase     		=		0.1
								lowerCAmelCase     		=		0.1
								lowerCAmelCase     		=		512
								lowerCAmelCase     		=		16
								lowerCAmelCase     		=		2
								lowerCAmelCase     		=		0.0_2
								lowerCAmelCase     		=		3
								lowerCAmelCase     		=		4
								lowerCAmelCase     		=		None


	def       SCREAMING_SNAKE_CASE_    (							self    )						->str:
								lowerCAmelCase     		=		ids_tensor([self.batch_size, self.seq_length]		,      self.vocab_size    )

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

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

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

								lowerCAmelCase     		=		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		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE    )						->str:
								lowerCAmelCase     		=		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)
								lowerCAmelCase     		=		{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
								lowerCAmelCase     		=		model(__SCREAMING_SNAKE_CASE    )

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

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


	def       SCREAMING_SNAKE_CASE_    (							self		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE    )						->Union[str, Any]:
								lowerCAmelCase     		=		self.num_labels
								lowerCAmelCase     		=		TFAlbertForSequenceClassification(config=__SCREAMING_SNAKE_CASE    )
								lowerCAmelCase     		=		{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
								lowerCAmelCase     		=		model(__SCREAMING_SNAKE_CASE    )
								self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.num_labels)    )


	def       SCREAMING_SNAKE_CASE_    (							self		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE    )						->Any:
								lowerCAmelCase     		=		TFAlbertForQuestionAnswering(config=__SCREAMING_SNAKE_CASE    )
								lowerCAmelCase     		=		{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
								lowerCAmelCase     		=		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		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE    )						->str:
								lowerCAmelCase     		=		self.num_choices
								lowerCAmelCase     		=		TFAlbertForMultipleChoice(config=__SCREAMING_SNAKE_CASE    )
								lowerCAmelCase     		=		tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE		,      1    )		,      (1, self.num_choices, 1)    )
								lowerCAmelCase     		=		tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE		,      1    )		,      (1, self.num_choices, 1)    )
								lowerCAmelCase     		=		tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE		,      1    )		,      (1, self.num_choices, 1)    )
								lowerCAmelCase     		=		{
								    '''input_ids''': multiple_choice_inputs_ids,
								    '''attention_mask''': multiple_choice_input_mask,
								    '''token_type_ids''': multiple_choice_token_type_ids,
								}
								lowerCAmelCase     		=		model(__SCREAMING_SNAKE_CASE    )
								self.parent.assertListEqual(list(result['''logits'''].shape    )		,      [self.batch_size, self.num_choices]    )


	def       SCREAMING_SNAKE_CASE_    (							self		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE    )						->Any:
								lowerCAmelCase     		=		self.num_labels
								lowerCAmelCase     		=		TFAlbertForTokenClassification(config=__SCREAMING_SNAKE_CASE    )
								lowerCAmelCase     		=		{
								    '''input_ids''': input_ids,
								    '''attention_mask''': input_mask,
								    '''token_type_ids''': token_type_ids,
								}
								lowerCAmelCase     		=		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:
								lowerCAmelCase     		=		self.prepare_config_and_inputs()
								(
								    (
								    lowerCAmelCase				
								)		,				(
								    lowerCAmelCase				
								)		,				(
								    lowerCAmelCase				
								)		,				(
								    lowerCAmelCase				
								)		,				(
								    lowerCAmelCase				
								)		,				(
								    lowerCAmelCase				
								)		,				(
								    lowerCAmelCase				
								)		,								
								)     		=		config_and_inputs
								lowerCAmelCase     		=		{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
								return config, inputs_dict




@require_tf
class        lowercase_  (  UpperCamelCase_				,					UpperCamelCase_				,					unittest.TestCase						):



	"""simple docstring"""





	UpperCAmelCase_  : Union[str, Any]       =    (
	    (
	        TFAlbertModel,
	        TFAlbertForPreTraining,
	        TFAlbertForMaskedLM,
	        TFAlbertForSequenceClassification,
	        TFAlbertForQuestionAnswering,
	        TFAlbertForTokenClassification,
	        TFAlbertForMultipleChoice,
	    )
	    if is_tf_available()
	    else ()
	)
	UpperCAmelCase_  : Dict       =    (
	    {
	        """feature-extraction""": TFAlbertModel,
	        """fill-mask""": TFAlbertForMaskedLM,
	        """question-answering""": TFAlbertForQuestionAnswering,
	        """text-classification""": TFAlbertForSequenceClassification,
	        """token-classification""": TFAlbertForTokenClassification,
	        """zero-shot""": TFAlbertForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	UpperCAmelCase_  : Union[str, Any]       =    False
	UpperCAmelCase_  : List[str]       =    False


	def       SCREAMING_SNAKE_CASE_    (							self		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE=False    )						->Any:
								lowerCAmelCase     		=		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    ):
																						lowerCAmelCase     		=		tf.zeros(self.model_tester.batch_size		,      dtype=tf.intaa    )

								return inputs_dict


	def       SCREAMING_SNAKE_CASE_    (							self    )						->Tuple:
								lowerCAmelCase     		=		TFAlbertModelTester(self    )
								lowerCAmelCase     		=		ConfigTester(self		,      config_class=__SCREAMING_SNAKE_CASE		,      hidden_size=37    )


	def       SCREAMING_SNAKE_CASE_    (							self    )						->str:
								self.config_tester.run_common_tests()


	def       SCREAMING_SNAKE_CASE_    (							self    )						->Any:
								lowerCAmelCase     		=		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_albert_model(*__SCREAMING_SNAKE_CASE    )


	def       SCREAMING_SNAKE_CASE_    (							self    )						->str:
								lowerCAmelCase     		=		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_albert_for_pretraining(*__SCREAMING_SNAKE_CASE    )


	def       SCREAMING_SNAKE_CASE_    (							self    )						->Union[str, Any]:
								lowerCAmelCase     		=		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    )						->Dict:
								lowerCAmelCase     		=		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    )						->List[Any]:
								lowerCAmelCase     		=		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[Any]:
								lowerCAmelCase     		=		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]:
															lowerCAmelCase     		=		TFAlbertModel.from_pretrained(__SCREAMING_SNAKE_CASE    )
															self.assertIsNotNone(__SCREAMING_SNAKE_CASE    )




@require_tf
class        lowercase_  (  unittest.TestCase						):



	"""simple docstring"""





	@slow
	def       SCREAMING_SNAKE_CASE_    (							self    )						->Optional[int]:
								lowerCAmelCase     		=		TFAlbertForPreTraining.from_pretrained('''albert-base-v2'''    )
								lowerCAmelCase     		=		tf.constant([[0, 1, 2, 3, 4, 5]]    )
								lowerCAmelCase     		=		model(__SCREAMING_SNAKE_CASE    )[0]

								lowerCAmelCase     		=		[1, 6, 30000]
								self.assertEqual(output.shape		,      __SCREAMING_SNAKE_CASE    )

								lowerCAmelCase     		=		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    )




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


lowercase__      :    Dict          =     {
    '''configuration_sam''': [
        '''SAM_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''SamConfig''',
        '''SamMaskDecoderConfig''',
        '''SamPromptEncoderConfig''',
        '''SamVisionConfig''',
    ],
    '''processing_sam''': ['''SamProcessor'''],
}


try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowercase__      :    Dict          =     [
	    '''SAM_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''SamModel''',
	    '''SamPreTrainedModel''',
	]
try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowercase__      :    str          =     [
	    '''TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''TFSamModel''',
	    '''TFSamPreTrainedModel''',
	]
try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowercase__      :    Dict          =     ['''SamImageProcessor''']


if TYPE_CHECKING:
	from .configuration_sam import (
	    SAM_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    SamConfig,
	    SamMaskDecoderConfig,
	    SamPromptEncoderConfig,
	    SamVisionConfig,
	)
	from .processing_sam import SamProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_sam import SAM_PRETRAINED_MODEL_ARCHIVE_LIST, SamModel, SamPreTrainedModel

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_sam import TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST, TFSamModel, TFSamPreTrainedModel

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .image_processing_sam import SamImageProcessor

else:
	import sys

	lowercase__      :    Dict          =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



