



'''simple docstring'''





import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      MODEL_FOR_PRETRAINING_MAPPING,
      AlbertForMaskedLM,
      AlbertForMultipleChoice,
      AlbertForPreTraining,
      AlbertForQuestionAnswering,
      AlbertForSequenceClassification,
      AlbertForTokenClassification,
      AlbertModel,
  )
  from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST






class __A     :



 '''simple docstring'''







 def __init__(self					,  A					,  A=13					,  A=7					,  A=True					,  A=True					,  A=True					,  A=True					,  A=99					,  A=16					,  A=36					,  A=6					,  A=6					,  A=6					,  A=37					,  A="gelu"					,  A=0.1					,  A=0.1					,  A=512					,  A=16					,  A=2					,  A=0.02					,  A=3					,  A=4					,  A=None					,  )       ->	List[str]:


      """simple docstring"""



      _a           =    parent
      _a           =    batch_size
      _a           =    seq_length
      _a           =    is_training
      _a           =    use_input_mask
      _a           =    use_token_type_ids
      _a           =    use_labels
      _a           =    vocab_size
      _a           =    embedding_size
      _a           =    hidden_size
      _a           =    num_hidden_layers
      _a           =    num_hidden_groups
      _a           =    num_attention_heads
      _a           =    intermediate_size
      _a           =    hidden_act
      _a           =    hidden_dropout_prob
      _a           =    attention_probs_dropout_prob
      _a           =    max_position_embeddings
      _a           =    type_vocab_size
      _a           =    type_sequence_label_size
      _a           =    initializer_range
      _a           =    num_labels
      _a           =    num_choices
      _a           =    scope



 def    a__    (self			)       ->	Optional[int]:


      """simple docstring"""



      _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           =    self.get_config()

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



 def    a__    (self			)       ->	Tuple:


      """simple docstring"""



      return AlbertConfig(
          vocab_size=self.vocab_size					,  hidden_size=self.hidden_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					,  num_hidden_groups=self.num_hidden_groups					,  )



 def    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A					,  A			)       ->	int:


      """simple docstring"""



      _a           =    AlbertModel(config=A			)
      model.to(A			)
      model.eval()
      _a           =    model(A					,  attention_mask=A					,  token_type_ids=A			)
      _a           =    model(A					,  token_type_ids=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    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A					,  A			)       ->	str:


      """simple docstring"""



      _a           =    AlbertForPreTraining(config=A			)
      model.to(A			)
      model.eval()
      _a           =    model(
          A					,  attention_mask=A					,  token_type_ids=A					,  labels=A					,  sentence_order_label=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, config.num_labels)			)



 def    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A					,  A			)       ->	Optional[int]:


      """simple docstring"""



      _a           =    AlbertForMaskedLM(config=A			)
      model.to(A			)
      model.eval()
      _a           =    model(A					,  attention_mask=A					,  token_type_ids=A					,  labels=A			)
      self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.seq_length, self.vocab_size)			)



 def    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A					,  A			)       ->	Dict:


      """simple docstring"""



      _a           =    AlbertForQuestionAnswering(config=A			)
      model.to(A			)
      model.eval()
      _a           =    model(
          A					,  attention_mask=A					,  token_type_ids=A					,  start_positions=A					,  end_positions=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    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A					,  A			)       ->	Optional[int]:


      """simple docstring"""



      _a           =    self.num_labels
      _a           =    AlbertForSequenceClassification(A			)
      model.to(A			)
      model.eval()
      _a           =    model(A					,  attention_mask=A					,  token_type_ids=A					,  labels=A			)
      self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.num_labels)			)



 def    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A					,  A			)       ->	str:


      """simple docstring"""



      _a           =    self.num_labels
      _a           =    AlbertForTokenClassification(config=A			)
      model.to(A			)
      model.eval()
      _a           =    model(A					,  attention_mask=A					,  token_type_ids=A					,  labels=A			)
      self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.seq_length, self.num_labels)			)



 def    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A					,  A			)       ->	Any:


      """simple docstring"""



      _a           =    self.num_choices
      _a           =    AlbertForMultipleChoice(config=A			)
      model.to(A			)
      model.eval()
      _a           =    input_ids.unsqueeze(1			).expand(-1					,  self.num_choices					,  -1			).contiguous()
      _a           =    token_type_ids.unsqueeze(1			).expand(-1					,  self.num_choices					,  -1			).contiguous()
      _a           =    input_mask.unsqueeze(1			).expand(-1					,  self.num_choices					,  -1			).contiguous()
      _a           =    model(
          A					,  attention_mask=A					,  token_type_ids=A					,  labels=A					,  )
      self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.num_choices)			)



 def    a__    (self			)       ->	str:


      """simple docstring"""



      _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_torch
class __A     (    A  ,  A  ,  unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase       :			Any		=			(
     (
         AlbertModel,
         AlbertForPreTraining,
         AlbertForMaskedLM,
         AlbertForMultipleChoice,
         AlbertForSequenceClassification,
         AlbertForTokenClassification,
         AlbertForQuestionAnswering,
     )
     if is_torch_available()
     else ()
 )
 __lowerCamelCase       :			str		=			(
     {
         'feature-extraction': AlbertModel,
         'fill-mask': AlbertForMaskedLM,
         'question-answering': AlbertForQuestionAnswering,
         'text-classification': AlbertForSequenceClassification,
         'token-classification': AlbertForTokenClassification,
         'zero-shot': AlbertForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 __lowerCamelCase       :			str		=			True



 def    a__    (self					,  A					,  A					,  A=False			)       ->	Optional[Any]:


      """simple docstring"""



      _a           =    super()._prepare_for_class(A					,  A					,  return_labels=A			)

      if return_labels:
           if model_class in get_values(A			):
                _a           =    torch.zeros(
                    (self.model_tester.batch_size, self.model_tester.seq_length)					,  dtype=torch.long					,  device=A			)
                _a           =    torch.zeros(
                    self.model_tester.batch_size					,  dtype=torch.long					,  device=A			)
      return inputs_dict



 def    a__    (self			)       ->	Optional[Any]:


      """simple docstring"""



      _a           =    AlbertModelTester(self			)
      _a           =    ConfigTester(self					,  config_class=A					,  hidden_size=37			)



 def    a__    (self			)       ->	Any:


      """simple docstring"""



      self.config_tester.run_common_tests()



 def    a__    (self			)       ->	int:


      """simple docstring"""



      _a           =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A			)



 def    a__    (self			)       ->	Optional[Any]:


      """simple docstring"""



      _a           =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_pretraining(*A			)



 def    a__    (self			)       ->	str:


      """simple docstring"""



      _a           =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*A			)



 def    a__    (self			)       ->	str:


      """simple docstring"""



      _a           =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*A			)



 def    a__    (self			)       ->	Dict:


      """simple docstring"""



      _a           =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*A			)



 def    a__    (self			)       ->	List[str]:


      """simple docstring"""



      _a           =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*A			)



 def    a__    (self			)       ->	str:


      """simple docstring"""



      _a           =    self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
           _a           =    type
           self.model_tester.create_and_check_model(*A			)



 @slow
 def    a__    (self			)       ->	Any:


      """simple docstring"""



      for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a           =    AlbertModel.from_pretrained(A			)
           self.assertIsNotNone(A			)






@require_torch
class __A     (    unittest.TestCase		):



 '''simple docstring'''







 @slow
 def    a__    (self			)       ->	Union[str, Any]:


      """simple docstring"""



      _a           =    AlbertModel.from_pretrained('''albert-base-v2'''			)
      _a           =    torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]			)
      _a           =    torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]			)
      with torch.no_grad():
           _a           =    model(A					,  attention_mask=A			)[0]
      _a           =    torch.Size((1, 11, 768)			)
      self.assertEqual(output.shape					,  A			)
      _a           =    torch.tensor(
          [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]]			)

      self.assertTrue(torch.allclose(output[:, 1:4, 1:4]					,  A					,  atol=1E-4			)			)








'''simple docstring'''





from __future__ import annotations




def lowerCAmelCase    (__A):



     """simple docstring"""



     return len(set(__A)) == len(__A)


if __name__ == "__main__":
  import doctest

  doctest.testmod()



