


"""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		,     snake_case__		,     snake_case__=13		,     snake_case__=7		,     snake_case__=True		,     snake_case__=True		,     snake_case__=True		,     snake_case__=True		,     snake_case__=99		,     snake_case__=16		,     snake_case__=36		,     snake_case__=6		,     snake_case__=6		,     snake_case__=6		,     snake_case__=37		,     snake_case__="gelu"		,     snake_case__=0.1		,     snake_case__=0.1		,     snake_case__=512		,     snake_case__=16		,     snake_case__=2		,     snake_case__=0.02		,     snake_case__=3		,     snake_case__=4		,     snake_case__=None		,     ):






         """simple docstring"""





         lowerCAmelCase     :     Union[str, Any]								=							parent
         lowerCAmelCase     :     Optional[Any]								=							batch_size
         lowerCAmelCase     :     str								=							seq_length
         lowerCAmelCase     :     Union[str, Any]								=							is_training
         lowerCAmelCase     :     Optional[int]								=							use_input_mask
         lowerCAmelCase     :     List[str]								=							use_token_type_ids
         lowerCAmelCase     :     Optional[int]								=							use_labels
         lowerCAmelCase     :     Optional[Any]								=							vocab_size
         lowerCAmelCase     :     Dict								=							embedding_size
         lowerCAmelCase     :     Dict								=							hidden_size
         lowerCAmelCase     :     Dict								=							num_hidden_layers
         lowerCAmelCase     :     Dict								=							num_hidden_groups
         lowerCAmelCase     :     Any								=							num_attention_heads
         lowerCAmelCase     :     List[str]								=							intermediate_size
         lowerCAmelCase     :     str								=							hidden_act
         lowerCAmelCase     :     int								=							hidden_dropout_prob
         lowerCAmelCase     :     Optional[Any]								=							attention_probs_dropout_prob
         lowerCAmelCase     :     Tuple								=							max_position_embeddings
         lowerCAmelCase     :     str								=							type_vocab_size
         lowerCAmelCase     :     Any								=							type_sequence_label_size
         lowerCAmelCase     :     Optional[Any]								=							initializer_range
         lowerCAmelCase     :     List[Any]								=							num_labels
         lowerCAmelCase     :     Any								=							num_choices
         lowerCAmelCase     :     str								=							scope

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     str								=							ids_tensor([self.batch_size, self.seq_length]		,     self.vocab_size						)

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

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

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

         lowerCAmelCase     :     int								=							self.get_config()

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

       def        lowercase__							(						self						):






         """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        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__						):






         """simple docstring"""





         lowerCAmelCase     :     int								=							AlbertModel(config=snake_case__						)
         model.to(snake_case__						)
         model.eval()
         lowerCAmelCase     :     Union[str, Any]								=							model(snake_case__		,     attention_mask=snake_case__		,     token_type_ids=snake_case__						)
         lowerCAmelCase     :     str								=							model(snake_case__		,     token_type_ids=snake_case__						)
         lowerCAmelCase     :     str								=							model(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        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__						):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							AlbertForPreTraining(config=snake_case__						)
         model.to(snake_case__						)
         model.eval()
         lowerCAmelCase     :     Optional[Any]								=							model(
             snake_case__		,     attention_mask=snake_case__		,     token_type_ids=snake_case__		,     labels=snake_case__		,     sentence_order_label=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, config.num_labels)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__						):






         """simple docstring"""





         lowerCAmelCase     :     Optional[Any]								=							AlbertForMaskedLM(config=snake_case__						)
         model.to(snake_case__						)
         model.eval()
         lowerCAmelCase     :     Dict								=							model(snake_case__		,     attention_mask=snake_case__		,     token_type_ids=snake_case__		,     labels=snake_case__						)
         self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.vocab_size)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__						):






         """simple docstring"""





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






         """simple docstring"""





         lowerCAmelCase     :     List[str]								=							self.num_labels
         lowerCAmelCase     :     Optional[Any]								=							AlbertForSequenceClassification(snake_case__						)
         model.to(snake_case__						)
         model.eval()
         lowerCAmelCase     :     str								=							model(snake_case__		,     attention_mask=snake_case__		,     token_type_ids=snake_case__		,     labels=snake_case__						)
         self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_labels)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__						):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							self.num_labels
         lowerCAmelCase     :     Optional[int]								=							AlbertForTokenClassification(config=snake_case__						)
         model.to(snake_case__						)
         model.eval()
         lowerCAmelCase     :     int								=							model(snake_case__		,     attention_mask=snake_case__		,     token_type_ids=snake_case__		,     labels=snake_case__						)
         self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.num_labels)						)

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__		,     snake_case__						):






         """simple docstring"""





         lowerCAmelCase     :     int								=							self.num_choices
         lowerCAmelCase     :     Tuple								=							AlbertForMultipleChoice(config=snake_case__						)
         model.to(snake_case__						)
         model.eval()
         lowerCAmelCase     :     Any								=							input_ids.unsqueeze(1						).expand(-1		,     self.num_choices		,     -1						).contiguous()
         lowerCAmelCase     :     Union[str, Any]								=							token_type_ids.unsqueeze(1						).expand(-1		,     self.num_choices		,     -1						).contiguous()
         lowerCAmelCase     :     Dict								=							input_mask.unsqueeze(1						).expand(-1		,     self.num_choices		,     -1						).contiguous()
         lowerCAmelCase     :     List[str]								=							model(
             snake_case__		,     attention_mask=snake_case__		,     token_type_ids=snake_case__		,     labels=snake_case__		,     )
         self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_choices)						)







       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Any								=							self.prepare_config_and_inputs()
         (
             (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  (
             lowerCAmelCase
         )						,  
         )     :     List[Any]								=							config_and_inputs
         lowerCAmelCase     :     List[Any]								=							{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
         return config, inputs_dict


@require_torch
class       SCREAMING_SNAKE_CASE__				(		lowercase   ,    lowercase   ,    unittest.TestCase				):
       """simple docstring"""


       a  :				str   =(
           (
               AlbertModel,
               AlbertForPreTraining,
               AlbertForMaskedLM,
               AlbertForMultipleChoice,
               AlbertForSequenceClassification,
               AlbertForTokenClassification,
               AlbertForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       a  :				List[Any]   =(
           {
               "feature-extraction": AlbertModel,
               "fill-mask": AlbertForMaskedLM,
               "question-answering": AlbertForQuestionAnswering,
               "text-classification": AlbertForSequenceClassification,
               "token-classification": AlbertForTokenClassification,
               "zero-shot": AlbertForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       a  :				Optional[int]   =True

       def        lowercase__							(						self		,     snake_case__		,     snake_case__		,     snake_case__=False						):






         """simple docstring"""





         lowerCAmelCase     :     Tuple								=							super()._prepare_for_class(snake_case__		,     snake_case__		,     return_labels=snake_case__						)

         if return_labels:
           if model_class in get_values(snake_case__						):
             lowerCAmelCase     :     int								=							torch.zeros(
                 (self.model_tester.batch_size, self.model_tester.seq_length)		,     dtype=torch.long		,     device=snake_case__						)
             lowerCAmelCase     :     List[str]								=							torch.zeros(
                 self.model_tester.batch_size		,     dtype=torch.long		,     device=snake_case__						)
         return inputs_dict

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[str]								=							AlbertModelTester(self						)
         lowerCAmelCase     :     List[str]								=							ConfigTester(self		,     config_class=snake_case__		,     hidden_size=37						)

       def        lowercase__							(						self						):






         """simple docstring"""





         self.config_tester.run_common_tests()

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Dict								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     str								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_pretraining(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[str]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Optional[int]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Union[str, Any]								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     str								=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*snake_case__						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Optional[int]								=							self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
           lowerCAmelCase     :     Optional[int]								=							type
           self.model_tester.create_and_check_model(*snake_case__						)







       @slow
       def        lowercase__							(						self						):






         """simple docstring"""





         for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           lowerCAmelCase     :     Any								=							AlbertModel.from_pretrained(snake_case__						)
           self.assertIsNotNone(snake_case__						)


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


       @slow
       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							AlbertModel.from_pretrained("albert-base-v2"						)
         lowerCAmelCase     :     Optional[Any]								=							torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]						)
         lowerCAmelCase     :     Tuple								=							torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]						)
         with torch.no_grad():
           lowerCAmelCase     :     Optional[int]								=							model(snake_case__		,     attention_mask=snake_case__						)[0]
         lowerCAmelCase     :     Tuple								=							torch.Size((1, 11, 768)						)
         self.assertEqual(output.shape		,     snake_case__						)
         lowerCAmelCase     :     int								=							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]		,     snake_case__		,     atol=1e-4						)						)









"""simple docstring"""







from typing import TYPE_CHECKING

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


lowerCAmelCase__      				=   {
    '''configuration_pix2struct''': [
        '''PIX2STRUCT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Pix2StructConfig''',
        '''Pix2StructTextConfig''',
        '''Pix2StructVisionConfig''',
    ],
    '''processing_pix2struct''': ['''Pix2StructProcessor'''],
}

try:
     if not is_vision_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase__      				=   ['''Pix2StructImageProcessor''']


try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase__      				=   [
         '''PIX2STRUCT_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''Pix2StructPreTrainedModel''',
         '''Pix2StructForConditionalGeneration''',
         '''Pix2StructVisionModel''',
         '''Pix2StructTextModel''',
     ]

if TYPE_CHECKING:
     from .configuration_pixastruct import (
         PIX2STRUCT_PRETRAINED_CONFIG_ARCHIVE_MAP,
         PixaStructConfig,
         PixaStructTextConfig,
         PixaStructVisionConfig,
     )
     from .processing_pixastruct import PixaStructProcessor

     try:
          if not is_vision_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .image_processing_pixastruct import PixaStructImageProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_pixastruct import (
              PIX2STRUCT_PRETRAINED_MODEL_ARCHIVE_LIST,
              PixaStructForConditionalGeneration,
              PixaStructPreTrainedModel,
              PixaStructTextModel,
              PixaStructVisionModel,
          )

else:
     import sys

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





