





"""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       snake_case		:

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

      def 						SCREAMING_SNAKE_CASE_      (      self       :Optional[Any]						):
       __SCREAMING_SNAKE_CASE			:      Union[str, Any] 							=	ids_tensor([self.batch_size, self.seq_length]						,							self.vocab_size						)

       __SCREAMING_SNAKE_CASE			:      Optional[int] 							=	None
       if self.use_input_mask:
        __SCREAMING_SNAKE_CASE			:      Union[str, Any] 							=	random_attention_mask([self.batch_size, self.seq_length]						)

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

       __SCREAMING_SNAKE_CASE			:      Optional[int] 							=	None
       __SCREAMING_SNAKE_CASE			:      List[Any] 							=	None
       __SCREAMING_SNAKE_CASE			:      Any 							=	None
       if self.use_labels:
        __SCREAMING_SNAKE_CASE			:      Any 							=	ids_tensor([self.batch_size]						,							self.type_sequence_label_size						)
        __SCREAMING_SNAKE_CASE			:      Optional[int] 							=	ids_tensor([self.batch_size, self.seq_length]						,							self.num_labels						)
        __SCREAMING_SNAKE_CASE			:      Union[str, Any] 							=	ids_tensor([self.batch_size]						,							self.num_choices						)

       __SCREAMING_SNAKE_CASE			:      int 							=	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]						,							_lowerCamelCase       :Dict						,							_lowerCamelCase       :Union[str, Any]						,							_lowerCamelCase       :Dict						,							_lowerCamelCase       :Optional[int]						,							_lowerCamelCase       :Optional[Any]						,							_lowerCamelCase       :str						,							_lowerCamelCase       :Tuple						):
       __SCREAMING_SNAKE_CASE			:      int 							=	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)
       __SCREAMING_SNAKE_CASE			:      Any 							=	{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
       __SCREAMING_SNAKE_CASE			:      int 							=	model(__SCREAMING_SNAKE_CASE						)

       __SCREAMING_SNAKE_CASE			:      int 							=	[input_ids, input_mask]
       __SCREAMING_SNAKE_CASE			:      str 							=	model(__SCREAMING_SNAKE_CASE						)

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

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

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

      def 						SCREAMING_SNAKE_CASE_      (      self       :Optional[Any]						,							_lowerCamelCase       :int						,							_lowerCamelCase       :int						,							_lowerCamelCase       :Any						,							_lowerCamelCase       :Union[str, Any]						,							_lowerCamelCase       :Tuple						,							_lowerCamelCase       :Tuple						,							_lowerCamelCase       :Any						):
       __SCREAMING_SNAKE_CASE			:      str 							=	self.num_labels
       __SCREAMING_SNAKE_CASE			:      List[Any] 							=	TFAlbertForTokenClassification(config=__SCREAMING_SNAKE_CASE						)
       __SCREAMING_SNAKE_CASE			:      str 							=	{
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
           '''token_type_ids''': token_type_ids,
       }
       __SCREAMING_SNAKE_CASE			:      Optional[Any] 							=	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       :List[str]						):
       __SCREAMING_SNAKE_CASE			:      List[Any] 							=	self.prepare_config_and_inputs()
       (
           (
           __SCREAMING_SNAKE_CASE				
       )							,				(
           __SCREAMING_SNAKE_CASE				
       )							,				(
           __SCREAMING_SNAKE_CASE				
       )							,				(
           __SCREAMING_SNAKE_CASE				
       )							,				(
           __SCREAMING_SNAKE_CASE				
       )							,				(
           __SCREAMING_SNAKE_CASE				
       )							,				(
           __SCREAMING_SNAKE_CASE				
       )							,								
       )			:      Tuple 							=	config_and_inputs
       __SCREAMING_SNAKE_CASE			:      Dict 							=	{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
       return config, inputs_dict







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

      def 						SCREAMING_SNAKE_CASE_      (      self       :Dict						,							_lowerCamelCase       :Tuple						,							_lowerCamelCase       :Tuple						,							_lowerCamelCase       :str=False						):
       __SCREAMING_SNAKE_CASE			:      Dict 							=	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						):
         __SCREAMING_SNAKE_CASE			:      Union[str, Any] 							=	tf.zeros(self.model_tester.batch_size						,							dtype=tf.intaa						)

       return inputs_dict

      def 						SCREAMING_SNAKE_CASE_      (      self       :Union[str, Any]						):
       __SCREAMING_SNAKE_CASE			:      Dict 							=	TFAlbertModelTester(self						)
       __SCREAMING_SNAKE_CASE			:      Optional[int] 							=	ConfigTester(self						,							config_class=__SCREAMING_SNAKE_CASE						,							hidden_size=3_7						)

      def 						SCREAMING_SNAKE_CASE_      (      self       :Optional[int]						):
       self.config_tester.run_common_tests()

      def 						SCREAMING_SNAKE_CASE_      (      self       :Any						):
       __SCREAMING_SNAKE_CASE			:      Tuple 							=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_albert_model(*__SCREAMING_SNAKE_CASE						)

      def 						SCREAMING_SNAKE_CASE_      (      self       :Any						):
       __SCREAMING_SNAKE_CASE			:      int 							=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_albert_for_pretraining(*__SCREAMING_SNAKE_CASE						)

      def 						SCREAMING_SNAKE_CASE_      (      self       :str						):
       __SCREAMING_SNAKE_CASE			:      Tuple 							=	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       :Optional[Any]						):
       __SCREAMING_SNAKE_CASE			:      Dict 							=	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       :Optional[Any]						):
       __SCREAMING_SNAKE_CASE			:      Optional[Any] 							=	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       :int						):
       __SCREAMING_SNAKE_CASE			:      int 							=	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       :Dict						):
       for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        __SCREAMING_SNAKE_CASE			:      List[str] 							=	TFAlbertModel.from_pretrained(__SCREAMING_SNAKE_CASE						)
        self.assertIsNotNone(__SCREAMING_SNAKE_CASE						)







@require_tf
class       snake_case		(       unittest.TestCase       ):

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

       __SCREAMING_SNAKE_CASE			:      Union[str, Any] 							=	[1, 6, 3_0_0_0_0]
       self.assertEqual(output.shape						,							__SCREAMING_SNAKE_CASE						)

       __SCREAMING_SNAKE_CASE			:      Any 							=	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"""





from ..utils import DummyObject, requires_backends





class       snake_case		(       metaclass=__UpperCAmelCase       ):
      lowerCamelCase__      =			['''torch''', '''transformers''', '''invisible_watermark''']

      def __init__(      self       :Optional[int]						,							*_lowerCamelCase       :int						,							**_lowerCamelCase       :Any						):
       requires_backends(self						,							['''torch''', '''transformers''', '''invisible_watermark''']						)

      @classmethod
      def 						SCREAMING_SNAKE_CASE_      (      cls       :Dict						,							*_lowerCamelCase       :Optional[Any]						,							**_lowerCamelCase       :int						):
       requires_backends(cls						,							['''torch''', '''transformers''', '''invisible_watermark''']						)



      @classmethod
      def 						SCREAMING_SNAKE_CASE_      (      cls       :Optional[int]						,							*_lowerCamelCase       :Optional[Any]						,							**_lowerCamelCase       :Union[str, Any]						):
       requires_backends(cls						,							['''torch''', '''transformers''', '''invisible_watermark''']						)







class       snake_case		(       metaclass=__UpperCAmelCase       ):
      lowerCamelCase__      =			['''torch''', '''transformers''', '''invisible_watermark''']

      def __init__(      self       :Dict						,							*_lowerCamelCase       :Dict						,							**_lowerCamelCase       :Optional[Any]						):
       requires_backends(self						,							['''torch''', '''transformers''', '''invisible_watermark''']						)

      @classmethod
      def 						SCREAMING_SNAKE_CASE_      (      cls       :Optional[int]						,							*_lowerCamelCase       :int						,							**_lowerCamelCase       :Optional[int]						):
       requires_backends(cls						,							['''torch''', '''transformers''', '''invisible_watermark''']						)



      @classmethod
      def 						SCREAMING_SNAKE_CASE_      (      cls       :List[Any]						,							*_lowerCamelCase       :Dict						,							**_lowerCamelCase       :List[str]						):
       requires_backends(cls						,							['''torch''', '''transformers''', '''invisible_watermark''']						)

