'''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 							SCREAMING_SNAKE_CASE :
  """simple docstring"""







  def __init__(	self :       List[str]       ,       __lowerCAmelCase :       str       ,       __lowerCAmelCase :       Dict=13       ,       __lowerCAmelCase :       Dict=7       ,       __lowerCAmelCase :       List[Any]=True       ,       __lowerCAmelCase :       int=True       ,       __lowerCAmelCase :       List[str]=True       ,       __lowerCAmelCase :       Any=True       ,       __lowerCAmelCase :       Tuple=99       ,       __lowerCAmelCase :       Union[str, Any]=16       ,       __lowerCAmelCase :       Tuple=36       ,       __lowerCAmelCase :       Tuple=6       ,       __lowerCAmelCase :       Union[str, Any]=6       ,       __lowerCAmelCase :       Union[str, Any]=6       ,       __lowerCAmelCase :       Tuple=37       ,       __lowerCAmelCase :       Any="gelu"       ,       __lowerCAmelCase :       Any=0.1       ,       __lowerCAmelCase :       Optional[Any]=0.1       ,       __lowerCAmelCase :       List[Any]=512       ,       __lowerCAmelCase :       Optional[int]=16       ,       __lowerCAmelCase :       Union[str, Any]=2       ,       __lowerCAmelCase :       int=0.0_2       ,       __lowerCAmelCase :       Optional[int]=3       ,       __lowerCAmelCase :       str=4       ,       __lowerCAmelCase :       List[str]=None       ,       ):


        """simple docstring"""



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



  def 	a (	self :       int       ):


        """simple docstring"""



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

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



  def 	a (	self :       Optional[int]       ):


        """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 :       str       ,       __lowerCAmelCase :       List[Any]       ,       __lowerCAmelCase :       List[str]       ,       __lowerCAmelCase :       Dict       ,       __lowerCAmelCase :       Optional[Any]       ,       __lowerCAmelCase :       List[str]       ,       __lowerCAmelCase :       List[Any]       ,       __lowerCAmelCase :       str       ):


        """simple docstring"""



        _lowerCAmelCase		 = AlbertModel(config=__a       )
        model.to(__a       )
        model.eval()
        _lowerCAmelCase		 = model(__a       ,       attention_mask=__a       ,       token_type_ids=__a       )
        _lowerCAmelCase		 = model(__a       ,       token_type_ids=__a       )
        _lowerCAmelCase		 = 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 :       List[Any]       ,       __lowerCAmelCase :       Optional[int]       ,       __lowerCAmelCase :       List[Any]       ,       __lowerCAmelCase :       Tuple       ,       __lowerCAmelCase :       List[str]       ,       __lowerCAmelCase :       str       ,       __lowerCAmelCase :       List[Any]       ,       __lowerCAmelCase :       Dict       ):


        """simple docstring"""



        _lowerCAmelCase		 = AlbertForPreTraining(config=__a       )
        model.to(__a       )
        model.eval()
        _lowerCAmelCase		 = 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 :       int       ,       __lowerCAmelCase :       int       ,       __lowerCAmelCase :       Dict       ,       __lowerCAmelCase :       str       ,       __lowerCAmelCase :       Optional[Any]       ,       __lowerCAmelCase :       Optional[int]       ,       __lowerCAmelCase :       Optional[Any]       ,       __lowerCAmelCase :       Optional[int]       ):


        """simple docstring"""



        _lowerCAmelCase		 = AlbertForMaskedLM(config=__a       )
        model.to(__a       )
        model.eval()
        _lowerCAmelCase		 = 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 :       Optional[Any]       ,       __lowerCAmelCase :       Union[str, Any]       ,       __lowerCAmelCase :       List[str]       ,       __lowerCAmelCase :       Any       ,       __lowerCAmelCase :       Optional[Any]       ,       __lowerCAmelCase :       str       ,       __lowerCAmelCase :       Any       ,       __lowerCAmelCase :       int       ):


        """simple docstring"""



        _lowerCAmelCase		 = AlbertForQuestionAnswering(config=__a       )
        model.to(__a       )
        model.eval()
        _lowerCAmelCase		 = 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 :       Tuple       ,       __lowerCAmelCase :       Dict       ,       __lowerCAmelCase :       Union[str, Any]       ,       __lowerCAmelCase :       Optional[Any]       ,       __lowerCAmelCase :       int       ,       __lowerCAmelCase :       Optional[int]       ,       __lowerCAmelCase :       List[str]       ,       __lowerCAmelCase :       int       ):


        """simple docstring"""



        _lowerCAmelCase		 = self.num_labels
        _lowerCAmelCase		 = AlbertForSequenceClassification(__a       )
        model.to(__a       )
        model.eval()
        _lowerCAmelCase		 = 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 :       Optional[int]       ,       __lowerCAmelCase :       int       ,       __lowerCAmelCase :       Any       ,       __lowerCAmelCase :       List[str]       ,       __lowerCAmelCase :       Optional[Any]       ,       __lowerCAmelCase :       int       ,       __lowerCAmelCase :       Union[str, Any]       ,       __lowerCAmelCase :       Tuple       ):


        """simple docstring"""



        _lowerCAmelCase		 = self.num_labels
        _lowerCAmelCase		 = AlbertForTokenClassification(config=__a       )
        model.to(__a       )
        model.eval()
        _lowerCAmelCase		 = 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 :       Dict       ,       __lowerCAmelCase :       Any       ,       __lowerCAmelCase :       int       ,       __lowerCAmelCase :       str       ,       __lowerCAmelCase :       Optional[int]       ,       __lowerCAmelCase :       Union[str, Any]       ,       __lowerCAmelCase :       Any       ,       __lowerCAmelCase :       List[str]       ):


        """simple docstring"""



        _lowerCAmelCase		 = self.num_choices
        _lowerCAmelCase		 = AlbertForMultipleChoice(config=__a       )
        model.to(__a       )
        model.eval()
        _lowerCAmelCase		 = input_ids.unsqueeze(1       ).expand(-1       ,       self.num_choices       ,       -1       ).contiguous()
        _lowerCAmelCase		 = token_type_ids.unsqueeze(1       ).expand(-1       ,       self.num_choices       ,       -1       ).contiguous()
        _lowerCAmelCase		 = input_mask.unsqueeze(1       ).expand(-1       ,       self.num_choices       ,       -1       ).contiguous()
        _lowerCAmelCase		 = 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 :       int       ):


        """simple docstring"""



        _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_torch
class 							SCREAMING_SNAKE_CASE (					UpperCAmelCase_						,    UpperCAmelCase_						,    unittest.TestCase			):
  """simple docstring"""







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



  def 	a (	self :       List[Any]       ,       __lowerCAmelCase :       Tuple       ,       __lowerCAmelCase :       Optional[Any]       ,       __lowerCAmelCase :       Optional[int]=False       ):


        """simple docstring"""



        _lowerCAmelCase		 = super()._prepare_for_class(__a       ,       __a       ,       return_labels=__a       )

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



  def 	a (	self :       Dict       ):


        """simple docstring"""



        _lowerCAmelCase		 = AlbertModelTester(self       )
        _lowerCAmelCase		 = ConfigTester(self       ,       config_class=__a       ,       hidden_size=37       )



  def 	a (	self :       List[Any]       ):


        """simple docstring"""



        self.config_tester.run_common_tests()



  def 	a (	self :       Union[str, Any]       ):


        """simple docstring"""



        _lowerCAmelCase		 = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__a       )



  def 	a (	self :       Any       ):


        """simple docstring"""



        _lowerCAmelCase		 = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_pretraining(*__a       )



  def 	a (	self :       Optional[int]       ):


        """simple docstring"""



        _lowerCAmelCase		 = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*__a       )



  def 	a (	self :       Any       ):


        """simple docstring"""



        _lowerCAmelCase		 = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*__a       )



  def 	a (	self :       Dict       ):


        """simple docstring"""



        _lowerCAmelCase		 = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*__a       )



  def 	a (	self :       int       ):


        """simple docstring"""



        _lowerCAmelCase		 = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*__a       )



  def 	a (	self :       Tuple       ):


        """simple docstring"""



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



  @slow
  def 	a (	self :       Optional[int]       ):


        """simple docstring"""



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





@require_torch
class 							SCREAMING_SNAKE_CASE (					unittest.TestCase			):
  """simple docstring"""







  @slow
  def 	a (	self :       str       ):


        """simple docstring"""



        _lowerCAmelCase		 = AlbertModel.from_pretrained('albert-base-v2'       )
        _lowerCAmelCase		 = torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]       )
        _lowerCAmelCase		 = torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]       )
        with torch.no_grad():
              _lowerCAmelCase		 = model(__a       ,       attention_mask=__a       )[0]
        _lowerCAmelCase		 = torch.Size((1, 11, 768)       )
        self.assertEqual(output.shape       ,       __a       )
        _lowerCAmelCase		 = torch.tensor(
            [[[-0.6_5_1_3, 1.5_0_3_5, -0.2_7_6_6], [-0.6_5_1_5, 1.5_0_4_6, -0.2_7_8_0], [-0.6_5_1_2, 1.5_0_4_9, -0.2_7_8_4]]]       )

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










from ..utils import DummyObject, requires_backends





class  lowerCamelCase__	(    metaclass=UpperCAmelCase_):
     """simple docstring"""



     _A      =      ['transformers', 'torch', 'note_seq']







     def __init__(self					,      *__a					,      **__a     ):






           '''simple docstring'''



           requires_backends(self					,      ["transformers", "torch", "note_seq"]     )







     @classmethod
     def     _a   (cls					,      *__a					,      **__a     ):






           '''simple docstring'''



           requires_backends(cls					,      ["transformers", "torch", "note_seq"]     )







     @classmethod
     def     _a   (cls					,      *__a					,      **__a     ):






           '''simple docstring'''



           requires_backends(cls					,      ["transformers", "torch", "note_seq"]     )