"""simple docstring"""






from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
						import tensorflow as tf


lowerCAmelCase__  :  List[str]						     =	logging.get_logger(__name__)
@dataclass
class 				snake_case       ( lowerCAmelCase_				):




					"""simple docstring"""

					snake_case__				    = [
					    'no_inference',
					    'no_cuda',
					    'no_tpu',
					    'no_speed',
					    'no_memory',
					    'no_env_print',
					    'no_multi_process',
					]







					def __init__(				self   :	List[str]    ,**lowerCamelCase__   :	str			):
									for deprecated_arg in self.deprecated_args:
													if deprecated_arg in kwargs:
																	UpperCAmelCase__             =							deprecated_arg[3:]
																	UpperCAmelCase__             =							not kwargs.pop(__lowerCAmelCase			)
																	logger.warning(
																	    f'''{deprecated_arg} is depreciated. Please use --no-{positive_arg} or'''
																	    f''' {positive_arg}={kwargs[positive_arg]}'''			)
									UpperCAmelCase__             =							kwargs.pop('tpu_name'    ,self.tpu_name			)
									UpperCAmelCase__             =							kwargs.pop('device_idx'    ,self.device_idx			)
									UpperCAmelCase__             =							kwargs.pop('eager_mode'    ,self.eager_mode			)
									UpperCAmelCase__             =							kwargs.pop('use_xla'    ,self.use_xla			)
									super().__init__(**__lowerCAmelCase			)

					snake_case__				    = field(
					    default=lowerCAmelCase_      ,    metadata={"help": "Name of TPU"}      ,    )
					snake_case__				    = field(
					    default=0      ,    metadata={"help": "CPU / GPU device index. Defaults to 0."}      ,    )
					snake_case__				    = field(default=lowerCAmelCase_      ,    metadata={"help": "Benchmark models in eager model."}				)
					snake_case__				    = field(
					    default=lowerCAmelCase_      ,    metadata={
					        "help": "Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`."
					    }      ,    )







					@cached_property
					def 		__lowerCAmelCase						(				self   :	Any			):
									requires_backends(self    ,['tf']			)
									UpperCAmelCase__             =							None
									if self.tpu:
													try:
																	if self.tpu_name:
																					UpperCAmelCase__             =							tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name			)
																	else:
																					UpperCAmelCase__             =							tf.distribute.cluster_resolver.TPUClusterResolver()
													except ValueError:
																	UpperCAmelCase__             =							None
									return tpu







					@cached_property
					def 		__lowerCAmelCase						(				self   :	str			):
									requires_backends(self    ,['tf']			)
									if self.is_tpu:
													tf.config.experimental_connect_to_cluster(self._setup_tpu			)
													tf.tpu.experimental.initialize_tpu_system(self._setup_tpu			)

													UpperCAmelCase__             =							tf.distribute.TPUStrategy(self._setup_tpu			)
									else:
													# currently no multi gpu is allowed
													if self.is_gpu:
																	# TODO: Currently only single GPU is supported
																	tf.config.set_visible_devices(self.gpu_list[self.device_idx]    ,'GPU'			)
																	UpperCAmelCase__             =							tf.distribute.OneDeviceStrategy(device=f'''/gpu:{self.device_idx}'''			)
													else:
																	tf.config.set_visible_devices([]    ,'GPU'			)  # disable GPU
																	UpperCAmelCase__             =							tf.distribute.OneDeviceStrategy(device=f'''/cpu:{self.device_idx}'''			)

									return strategy







					@property
					def 		__lowerCAmelCase						(				self   :	Union[str, Any]			):
									requires_backends(self    ,['tf']			)
									return self._setup_tpu is not None







					@property
					def 		__lowerCAmelCase						(				self   :	List[Any]			):
									requires_backends(self    ,['tf']			)
									return self._setup_strategy







					@property
					def 		__lowerCAmelCase						(				self   :	Optional[Any]			):
									requires_backends(self    ,['tf']			)
									return tf.config.list_physical_devices('GPU'			)







					@property
					def 		__lowerCAmelCase						(				self   :	Any			):
									requires_backends(self    ,['tf']			)
									if self.cuda:
													return len(self.gpu_list			)
									return 0







					@property
					def 		__lowerCAmelCase						(				self   :	Any			):
									return self.n_gpu > 0




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


    def __init__(    self		:     Optional[int]      , __lowerCAmelCase		:     int      , __lowerCAmelCase		:     Union[str, Any]=13      , __lowerCAmelCase		:     str=7      , __lowerCAmelCase		:     Optional[int]=True      , __lowerCAmelCase		:     int=True      , __lowerCAmelCase		:     List[Any]=True      , __lowerCAmelCase		:     int=True      , __lowerCAmelCase		:     List[Any]=99      , __lowerCAmelCase		:     Optional[int]=16      , __lowerCAmelCase		:     Dict=36      , __lowerCAmelCase		:     Optional[Any]=6      , __lowerCAmelCase		:     List[str]=6      , __lowerCAmelCase		:     Union[str, Any]=6      , __lowerCAmelCase		:     str=37      , __lowerCAmelCase		:     Optional[int]="gelu"      , __lowerCAmelCase		:     Union[str, Any]=0.1      , __lowerCAmelCase		:     Dict=0.1      , __lowerCAmelCase		:     List[str]=512      , __lowerCAmelCase		:     Optional[Any]=16      , __lowerCAmelCase		:     int=2      , __lowerCAmelCase		:     List[str]=0.02      , __lowerCAmelCase		:     Optional[int]=3      , __lowerCAmelCase		:     List[str]=4      , __lowerCAmelCase		:     Any=None      , ):
      _UpperCAmelCase         =					parent
      _UpperCAmelCase         =					batch_size
      _UpperCAmelCase         =					seq_length
      _UpperCAmelCase         =					is_training
      _UpperCAmelCase         =					use_input_mask
      _UpperCAmelCase         =					use_token_type_ids
      _UpperCAmelCase         =					use_labels
      _UpperCAmelCase         =					vocab_size
      _UpperCAmelCase         =					embedding_size
      _UpperCAmelCase         =					hidden_size
      _UpperCAmelCase         =					num_hidden_layers
      _UpperCAmelCase         =					num_hidden_groups
      _UpperCAmelCase         =					num_attention_heads
      _UpperCAmelCase         =					intermediate_size
      _UpperCAmelCase         =					hidden_act
      _UpperCAmelCase         =					hidden_dropout_prob
      _UpperCAmelCase         =					attention_probs_dropout_prob
      _UpperCAmelCase         =					max_position_embeddings
      _UpperCAmelCase         =					type_vocab_size
      _UpperCAmelCase         =					type_sequence_label_size
      _UpperCAmelCase         =					initializer_range
      _UpperCAmelCase         =					num_labels
      _UpperCAmelCase         =					num_choices
      _UpperCAmelCase         =					scope


    def    lowerCAmelCase_     (    self		:     Union[str, Any]    ):
      _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         =					self.get_config()

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


    def    lowerCAmelCase_     (    self		:     Union[str, Any]    ):
      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    lowerCAmelCase_     (    self		:     List[Any]      , __lowerCAmelCase		:     Tuple      , __lowerCAmelCase		:     Tuple      , __lowerCAmelCase		:     Optional[Any]      , __lowerCAmelCase		:     Union[str, Any]      , __lowerCAmelCase		:     List[str]      , __lowerCAmelCase		:     str      , __lowerCAmelCase		:     Any    ):
      _UpperCAmelCase         =					AlbertModel(config=__lowerCAmelCase    )
      model.to(__lowerCAmelCase    )
      model.eval()
      _UpperCAmelCase         =					model(__lowerCAmelCase      , attention_mask=__lowerCAmelCase      , token_type_ids=__lowerCAmelCase    )
      _UpperCAmelCase         =					model(__lowerCAmelCase      , token_type_ids=__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    lowerCAmelCase_     (    self		:     Any      , __lowerCAmelCase		:     List[str]      , __lowerCAmelCase		:     Any      , __lowerCAmelCase		:     List[Any]      , __lowerCAmelCase		:     Optional[Any]      , __lowerCAmelCase		:     str      , __lowerCAmelCase		:     Union[str, Any]      , __lowerCAmelCase		:     int    ):
      _UpperCAmelCase         =					AlbertForPreTraining(config=__lowerCAmelCase    )
      model.to(__lowerCAmelCase    )
      model.eval()
      _UpperCAmelCase         =					model(
          __lowerCAmelCase      , attention_mask=__lowerCAmelCase      , token_type_ids=__lowerCAmelCase      , labels=__lowerCAmelCase      , sentence_order_label=__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, config.num_labels)    )


    def    lowerCAmelCase_     (    self		:     List[str]      , __lowerCAmelCase		:     str      , __lowerCAmelCase		:     int      , __lowerCAmelCase		:     int      , __lowerCAmelCase		:     Tuple      , __lowerCAmelCase		:     List[Any]      , __lowerCAmelCase		:     int      , __lowerCAmelCase		:     Tuple    ):
      _UpperCAmelCase         =					AlbertForMaskedLM(config=__lowerCAmelCase    )
      model.to(__lowerCAmelCase    )
      model.eval()
      _UpperCAmelCase         =					model(__lowerCAmelCase      , attention_mask=__lowerCAmelCase      , token_type_ids=__lowerCAmelCase      , labels=__lowerCAmelCase    )
      self.parent.assertEqual(result.logits.shape      , (self.batch_size, self.seq_length, self.vocab_size)    )


    def    lowerCAmelCase_     (    self		:     str      , __lowerCAmelCase		:     str      , __lowerCAmelCase		:     List[Any]      , __lowerCAmelCase		:     Union[str, Any]      , __lowerCAmelCase		:     Any      , __lowerCAmelCase		:     Union[str, Any]      , __lowerCAmelCase		:     Dict      , __lowerCAmelCase		:     Tuple    ):
      _UpperCAmelCase         =					AlbertForQuestionAnswering(config=__lowerCAmelCase    )
      model.to(__lowerCAmelCase    )
      model.eval()
      _UpperCAmelCase         =					model(
          __lowerCAmelCase      , attention_mask=__lowerCAmelCase      , token_type_ids=__lowerCAmelCase      , start_positions=__lowerCAmelCase      , end_positions=__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    lowerCAmelCase_     (    self		:     str      , __lowerCAmelCase		:     List[Any]      , __lowerCAmelCase		:     Union[str, Any]      , __lowerCAmelCase		:     Any      , __lowerCAmelCase		:     List[Any]      , __lowerCAmelCase		:     List[str]      , __lowerCAmelCase		:     Tuple      , __lowerCAmelCase		:     Any    ):
      _UpperCAmelCase         =					self.num_labels
      _UpperCAmelCase         =					AlbertForSequenceClassification(__lowerCAmelCase    )
      model.to(__lowerCAmelCase    )
      model.eval()
      _UpperCAmelCase         =					model(__lowerCAmelCase      , attention_mask=__lowerCAmelCase      , token_type_ids=__lowerCAmelCase      , labels=__lowerCAmelCase    )
      self.parent.assertEqual(result.logits.shape      , (self.batch_size, self.num_labels)    )


    def    lowerCAmelCase_     (    self		:     Optional[int]      , __lowerCAmelCase		:     Optional[Any]      , __lowerCAmelCase		:     Optional[int]      , __lowerCAmelCase		:     Union[str, Any]      , __lowerCAmelCase		:     List[Any]      , __lowerCAmelCase		:     List[str]      , __lowerCAmelCase		:     Tuple      , __lowerCAmelCase		:     Optional[Any]    ):
      _UpperCAmelCase         =					self.num_labels
      _UpperCAmelCase         =					AlbertForTokenClassification(config=__lowerCAmelCase    )
      model.to(__lowerCAmelCase    )
      model.eval()
      _UpperCAmelCase         =					model(__lowerCAmelCase      , attention_mask=__lowerCAmelCase      , token_type_ids=__lowerCAmelCase      , labels=__lowerCAmelCase    )
      self.parent.assertEqual(result.logits.shape      , (self.batch_size, self.seq_length, self.num_labels)    )


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


    def    lowerCAmelCase_     (    self		:     List[str]    ):
      _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_torch
class 				a (						lowerCAmelCase_		,							lowerCAmelCase_		,							unittest.TestCase      ):
    _snake_case   :     str   							=							(
        (
            AlbertModel,
            AlbertForPreTraining,
            AlbertForMaskedLM,
            AlbertForMultipleChoice,
            AlbertForSequenceClassification,
            AlbertForTokenClassification,
            AlbertForQuestionAnswering,
        )
        if is_torch_available()
        else ()
    )
    _snake_case   :     Tuple   							=							(
        {
            'feature-extraction': AlbertModel,
            'fill-mask': AlbertForMaskedLM,
            'question-answering': AlbertForQuestionAnswering,
            'text-classification': AlbertForSequenceClassification,
            'token-classification': AlbertForTokenClassification,
            'zero-shot': AlbertForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    _snake_case   :     Dict   							=							True


    def    lowerCAmelCase_     (    self		:     str      , __lowerCAmelCase		:     int      , __lowerCAmelCase		:     List[Any]      , __lowerCAmelCase		:     List[Any]=False    ):
      _UpperCAmelCase         =					super()._prepare_for_class(__lowerCAmelCase      , __lowerCAmelCase      , return_labels=__lowerCAmelCase    )

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


    def    lowerCAmelCase_     (    self		:     Optional[Any]    ):
      _UpperCAmelCase         =					AlbertModelTester(self    )
      _UpperCAmelCase         =					ConfigTester(self      , config_class=__lowerCAmelCase      , hidden_size=37    )


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


    def    lowerCAmelCase_     (    self		:     int    ):
      _UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__lowerCAmelCase    )


    def    lowerCAmelCase_     (    self		:     Union[str, Any]    ):
      _UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_pretraining(*__lowerCAmelCase    )


    def    lowerCAmelCase_     (    self		:     Optional[Any]    ):
      _UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*__lowerCAmelCase    )


    def    lowerCAmelCase_     (    self		:     Dict    ):
      _UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*__lowerCAmelCase    )


    def    lowerCAmelCase_     (    self		:     str    ):
      _UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*__lowerCAmelCase    )


    def    lowerCAmelCase_     (    self		:     List[Any]    ):
      _UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*__lowerCAmelCase    )


    def    lowerCAmelCase_     (    self		:     Optional[int]    ):
      _UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
        _UpperCAmelCase         =					type
        self.model_tester.create_and_check_model(*__lowerCAmelCase    )


    @slow
    def    lowerCAmelCase_     (    self		:     Dict    ):
      for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        _UpperCAmelCase         =					AlbertModel.from_pretrained(__lowerCAmelCase    )
        self.assertIsNotNone(__lowerCAmelCase    )



@require_torch
class 				a (						unittest.TestCase      ):


    @slow
    def    lowerCAmelCase_     (    self		:     Tuple    ):
      _UpperCAmelCase         =					AlbertModel.from_pretrained("""albert-base-v2"""    )
      _UpperCAmelCase         =					torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]    )
      _UpperCAmelCase         =					torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]    )
      with torch.no_grad():
        _UpperCAmelCase         =					model(__lowerCAmelCase      , attention_mask=__lowerCAmelCase    )[0]
      _UpperCAmelCase         =					torch.Size((1, 11, 768)    )
      self.assertEqual(output.shape      , __lowerCAmelCase    )
      _UpperCAmelCase         =					torch.tensor(
          [[[-0.6_513, 1.5_035, -0.2_766], [-0.6_515, 1.5_046, -0.2_780], [-0.6_512, 1.5_049, -0.2_784]]]    )

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