
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


SCREAMING_SNAKE_CASE_     				=   {'configuration_hubert': ['HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'HubertConfig']}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE_     				=   [
      'HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'HubertForCTC',
      'HubertForSequenceClassification',
      'HubertModel',
      'HubertPreTrainedModel',
  ]


try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE_     				=   [
      'TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFHubertForCTC',
      'TFHubertModel',
      'TFHubertPreTrainedModel',
  ]

if TYPE_CHECKING:
  from .configuration_hubert import HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, HubertConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_hubert import (
        HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        HubertForCTC,
        HubertForSequenceClassification,
        HubertModel,
        HubertPreTrainedModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_hubert import (
        TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFHubertForCTC,
        TFHubertModel,
        TFHubertPreTrainedModel,
    )


else:
  import sys

  SCREAMING_SNAKE_CASE_     				=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



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







       def __init__(					self							,lowerCamelCase_							,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							,):



          '''simple docstring'''

          _UpperCAmelCase   	=					parent
          _UpperCAmelCase   	=					13
          _UpperCAmelCase   	=					7
          _UpperCAmelCase   	=					True
          _UpperCAmelCase   	=					True
          _UpperCAmelCase   	=					True
          _UpperCAmelCase   	=					True
          _UpperCAmelCase   	=					99
          _UpperCAmelCase   	=					16
          _UpperCAmelCase   	=					32
          _UpperCAmelCase   	=					2
          _UpperCAmelCase   	=					4
          _UpperCAmelCase   	=					37
          _UpperCAmelCase   	=					"gelu"
          _UpperCAmelCase   	=					0.1
          _UpperCAmelCase   	=					0.1
          _UpperCAmelCase   	=					512
          _UpperCAmelCase   	=					16
          _UpperCAmelCase   	=					2
          _UpperCAmelCase   	=					0.0_2
          _UpperCAmelCase   	=					3
          _UpperCAmelCase   	=					4
          _UpperCAmelCase   	=					None







       def    _snake_case			(					self		):



          '''simple docstring'''

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

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

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

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

          _UpperCAmelCase   	=					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    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase   	=					TFAlbertModel(config=lowerCamelCase_		)
          # inputs = {'input_ids': input_ids,
          #           'attention_mask': input_mask,
          #           'token_type_ids': token_type_ids}
          # sequence_output, pooled_output = model(**inputs)
          _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          _UpperCAmelCase   	=					model(lowerCamelCase_		)

          _UpperCAmelCase   	=					[input_ids, input_mask]
          _UpperCAmelCase   	=					model(lowerCamelCase_		)

          _UpperCAmelCase   	=					model(lowerCamelCase_		)

          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    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.num_labels
          _UpperCAmelCase   	=					TFAlbertForPreTraining(config=lowerCamelCase_		)
          _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          _UpperCAmelCase   	=					model(lowerCamelCase_		)
          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    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase   	=					TFAlbertForMaskedLM(config=lowerCamelCase_		)
          _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          _UpperCAmelCase   	=					model(lowerCamelCase_		)
          self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.seq_length, self.vocab_size)		)







       def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.num_labels
          _UpperCAmelCase   	=					TFAlbertForSequenceClassification(config=lowerCamelCase_		)
          _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          _UpperCAmelCase   	=					model(lowerCamelCase_		)
          self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.num_labels)		)







       def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase   	=					TFAlbertForQuestionAnswering(config=lowerCamelCase_		)
          _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          _UpperCAmelCase   	=					model(lowerCamelCase_		)
          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    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.num_choices
          _UpperCAmelCase   	=					TFAlbertForMultipleChoice(config=lowerCamelCase_		)
          _UpperCAmelCase   	=					tf.tile(tf.expand_dims(lowerCamelCase_							,1		)							,(1, self.num_choices, 1)		)
          _UpperCAmelCase   	=					tf.tile(tf.expand_dims(lowerCamelCase_							,1		)							,(1, self.num_choices, 1)		)
          _UpperCAmelCase   	=					tf.tile(tf.expand_dims(lowerCamelCase_							,1		)							,(1, self.num_choices, 1)		)
          _UpperCAmelCase   	=					{
              "input_ids": multiple_choice_inputs_ids,
              "attention_mask": multiple_choice_input_mask,
              "token_type_ids": multiple_choice_token_type_ids,
          }
          _UpperCAmelCase   	=					model(lowerCamelCase_		)
          self.parent.assertListEqual(list(result["logits"].shape		)							,[self.batch_size, self.num_choices]		)







       def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.num_labels
          _UpperCAmelCase   	=					TFAlbertForTokenClassification(config=lowerCamelCase_		)
          _UpperCAmelCase   	=					{
              "input_ids": input_ids,
              "attention_mask": input_mask,
              "token_type_ids": token_type_ids,
          }
          _UpperCAmelCase   	=					model(lowerCamelCase_		)
          self.parent.assertListEqual(list(result["logits"].shape		)							,[self.batch_size, self.seq_length, self.num_labels]		)







       def    _snake_case			(					self		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.prepare_config_and_inputs()
          (
              (
              _UpperCAmelCase
          )	,							(
              _UpperCAmelCase
          )	,							(
              _UpperCAmelCase
          )	,							(
              _UpperCAmelCase
          )	,							(
              _UpperCAmelCase
          )	,							(
              _UpperCAmelCase
          )	,							(
              _UpperCAmelCase
          )	,							
          )   	=					config_and_inputs
          _UpperCAmelCase   	=					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
          return config, inputs_dict






@require_tf
class     __a			(					lowerCAmelCase_				,	lowerCAmelCase_				,	unittest.TestCase			):
       _lowerCamelCase							:							Any       =			(
           (
               TFAlbertModel,
               TFAlbertForPreTraining,
               TFAlbertForMaskedLM,
               TFAlbertForSequenceClassification,
               TFAlbertForQuestionAnswering,
               TFAlbertForTokenClassification,
               TFAlbertForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       _lowerCamelCase							:							int       =			(
           {
               'feature-extraction': TFAlbertModel,
               'fill-mask': TFAlbertForMaskedLM,
               'question-answering': TFAlbertForQuestionAnswering,
               'text-classification': TFAlbertForSequenceClassification,
               'token-classification': TFAlbertForTokenClassification,
               'zero-shot': TFAlbertForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       _lowerCamelCase							:							List[str]       =			False
       _lowerCamelCase							:							Optional[Any]       =			False







       def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_=False		):



          '''simple docstring'''

          _UpperCAmelCase   	=					super()._prepare_for_class(lowerCamelCase_							,lowerCamelCase_							,return_labels=lowerCamelCase_		)

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

          return inputs_dict







       def    _snake_case			(					self		):



          '''simple docstring'''

          _UpperCAmelCase   	=					TFAlbertModelTester(self		)
          _UpperCAmelCase   	=					ConfigTester(self							,config_class=lowerCamelCase_							,hidden_size=37		)







       def    _snake_case			(					self		):



          '''simple docstring'''

          self.config_tester.run_common_tests()







       def    _snake_case			(					self		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_model(*lowerCamelCase_		)







       def    _snake_case			(					self		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_pretraining(*lowerCamelCase_		)







       def    _snake_case			(					self		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_masked_lm(*lowerCamelCase_		)







       def    _snake_case			(					self		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_multiple_choice(*lowerCamelCase_		)







       def    _snake_case			(					self		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_sequence_classification(*lowerCamelCase_		)







       def    _snake_case			(					self		):



          '''simple docstring'''

          _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_question_answering(*lowerCamelCase_		)







       @slow
       def    _snake_case			(					self		):



          '''simple docstring'''

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






@require_tf
class     __a			(					unittest.TestCase			):







       @slow
       def    _snake_case			(					self		):



          '''simple docstring'''

          _UpperCAmelCase   	=					TFAlbertForPreTraining.from_pretrained("albert-base-v2"		)
          _UpperCAmelCase   	=					tf.constant([[0, 1, 2, 3, 4, 5]]		)
          _UpperCAmelCase   	=					model(lowerCamelCase_		)[0]

          _UpperCAmelCase   	=					[1, 6, 3_0000]
          self.assertEqual(output.shape							,lowerCamelCase_		)

          _UpperCAmelCase   	=					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]							,lowerCamelCase_							,atol=1e-4		)

