


'''simple docstring'''






import dataclasses
import json
import warnings
from dataclasses import dataclass, field
from time import time
from typing import List

from ..utils import logging


a_   :      Optional[int]				    =      logging.get_logger(__name__)






def 		_A			(lowerCAmelCase__=None			,  lowerCAmelCase__=None						)				->					Tuple:




     '''simple docstring'''



     return field(default_factory=lambda: default			,  metadata=__SCREAMING_SNAKE_CASE						)






@dataclass
class 	a       :
 _lowerCAmelCase	   =		list_field(
     default=[]					,			metadata={
         """help""": (
             """Model checkpoints to be provided to the AutoModel classes. Leave blank to benchmark the base version"""
             """ of all available models"""
         )
     }					,			)

 _lowerCAmelCase	   =		list_field(
     default=[8]					,			metadata={"""help""": """List of batch sizes for which memory and time performance will be evaluated"""}    )

 _lowerCAmelCase	   =		list_field(
     default=[8, 3_2, 1_2_8, 5_1_2]					,			metadata={"""help""": """List of sequence lengths for which memory and time performance will be evaluated"""}					,			)

 _lowerCAmelCase	   =		field(
     default=__UpperCamelCase					,			metadata={"""help""": """Whether to benchmark inference of model. Inference can be disabled via --no-inference."""}					,			)
 _lowerCAmelCase	   =		field(
     default=__UpperCamelCase					,			metadata={"""help""": """Whether to run on available cuda devices. Cuda can be disabled via --no-cuda."""}					,			)
 _lowerCAmelCase	   =		field(
     default=__UpperCamelCase					,			metadata={"""help""": """Whether to run on available tpu devices. TPU can be disabled via --no-tpu."""}    )
 _lowerCAmelCase	   =		field(default=__UpperCamelCase					,			metadata={"""help""": """Use FP16 to accelerate inference."""}    )
 _lowerCAmelCase	   =		field(default=__UpperCamelCase					,			metadata={"""help""": """Benchmark training of model"""}    )
 _lowerCAmelCase	   =		field(default=__UpperCamelCase					,			metadata={"""help""": """Verbose memory tracing"""}    )
 _lowerCAmelCase	   =		field(
     default=__UpperCamelCase					,			metadata={"""help""": """Whether to perform speed measurements. Speed measurements can be disabled via --no-speed."""}					,			)
 _lowerCAmelCase	   =		field(
     default=__UpperCamelCase					,			metadata={
         """help""": """Whether to perform memory measurements. Memory measurements can be disabled via --no-memory"""
     }					,			)
 _lowerCAmelCase	   =		field(default=__UpperCamelCase					,			metadata={"""help""": """Trace memory line by line"""}    )
 _lowerCAmelCase	   =		field(default=__UpperCamelCase					,			metadata={"""help""": """Save result to a CSV file"""}    )
 _lowerCAmelCase	   =		field(default=__UpperCamelCase					,			metadata={"""help""": """Save all print statements in a log file"""}    )
 _lowerCAmelCase	   =		field(default=__UpperCamelCase					,			metadata={"""help""": """Whether to print environment information"""}    )
 _lowerCAmelCase	   =		field(
     default=__UpperCamelCase					,			metadata={
         """help""": (
             """Whether to use multiprocessing for memory and speed measurement. It is highly recommended to use"""
             """ multiprocessing for accurate CPU and GPU memory measurements. This option should only be disabled"""
             """ for debugging / testing and on TPU."""
         )
     }					,			)
 _lowerCAmelCase	   =		field(
     default=f'''inference_time_{round(time()    )}.csv'''					,			metadata={"""help""": """CSV filename used if saving time results to csv."""}					,			)
 _lowerCAmelCase	   =		field(
     default=f'''inference_memory_{round(time()    )}.csv'''					,			metadata={"""help""": """CSV filename used if saving memory results to csv."""}					,			)
 _lowerCAmelCase	   =		field(
     default=f'''train_time_{round(time()    )}.csv'''					,			metadata={"""help""": """CSV filename used if saving time results to csv for training."""}					,			)
 _lowerCAmelCase	   =		field(
     default=f'''train_memory_{round(time()    )}.csv'''					,			metadata={"""help""": """CSV filename used if saving memory results to csv for training."""}					,			)
 _lowerCAmelCase	   =		field(
     default=f'''env_info_{round(time()    )}.csv'''					,			metadata={"""help""": """CSV filename used if saving environment information."""}					,			)
 _lowerCAmelCase	   =		field(
     default=f'''log_{round(time()    )}.csv'''					,			metadata={"""help""": """Log filename used if print statements are saved in log."""}					,			)
 _lowerCAmelCase	   =		field(default=3					,			metadata={"""help""": """Times an experiment will be run."""}    )
 _lowerCAmelCase	   =		field(
     default=__UpperCamelCase					,			metadata={
         """help""": (
             """Instead of loading the model as defined in `config.architectures` if exists, just load the pretrain"""
             """ model weights."""
         )
     }					,			)
 def 							__UpperCAmelCase						(	self  )   ->							Tuple:
      warnings.warn(
          f'The class {self.__class__} is deprecated. Hugging Face Benchmarking utils'
          ' are deprecated in general and it is advised to use external Benchmarking libraries '
          ' to benchmark Transformer models.' ,			_lowerCAmelCase ,			)
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      return json.dumps(dataclasses.asdict(self  ) ,			indent=2  )
 @property
 def 							__UpperCAmelCase						(	self  )   ->							str:
      if len(self.models  ) <= 0:
           raise ValueError(
               'Please make sure you provide at least one model name / model identifier, *e.g.* `--models'
               ' bert-base-cased` or `args.models = [\'bert-base-cased\'].'  )
      return self.models




 @property
 def 							__UpperCAmelCase						(	self  )   ->							Union[str, Any]:
      if not self.multi_process:
           return False
      elif self.is_tpu:
           logger.info('Multiprocessing is currently not possible on TPU.'  )
           return False
      else:
           return True





'''simple docstring'''






import unittest

from transformers import DebertaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

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


if is_torch_available():
 import torch

 from transformers import (
     DebertaForMaskedLM,
     DebertaForQuestionAnswering,
     DebertaForSequenceClassification,
     DebertaForTokenClassification,
     DebertaModel,
 )
 from transformers.models.deberta.modeling_deberta import DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST




class 	a       (       _SCREAMING_SNAKE_CASE    ):
 def __init__(	self ,			__magic_name__ ,			__magic_name__=13 ,			__magic_name__=7 ,			__magic_name__=True ,			__magic_name__=True ,			__magic_name__=True ,			__magic_name__=True ,			__magic_name__=99 ,			__magic_name__=32 ,			__magic_name__=5 ,			__magic_name__=4 ,			__magic_name__=37 ,			__magic_name__="gelu" ,			__magic_name__=0.1 ,			__magic_name__=0.1 ,			__magic_name__=5_12 ,			__magic_name__=16 ,			__magic_name__=2 ,			__magic_name__=0.0_2 ,			__magic_name__=False ,			__magic_name__=True ,			__magic_name__="None" ,			__magic_name__=3 ,			__magic_name__=4 ,			__magic_name__=None ,			)   ->							Any:
      _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      =							hidden_size
      _a      =							num_hidden_layers
      _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      =							relative_attention
      _a      =							position_biased_input
      _a      =							pos_att_type
      _a      =							scope
 def 							__UpperCAmelCase						(	self  )   ->							List[str]:
      _a      =							ids_tensor([self.batch_size, self.seq_length] ,			self.vocab_size  )

      _a      =							None
      if self.use_input_mask:
           _a      =							ids_tensor([self.batch_size, self.seq_length] ,			vocab_size=2  )

      _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 							__UpperCAmelCase						(	self  )   ->							Union[str, Any]:
      return DebertaConfig(
          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 ,			relative_attention=self.relative_attention ,			position_biased_input=self.position_biased_input ,			pos_att_type=self.pos_att_type ,			)
 def 							__UpperCAmelCase						(	self  )   ->							Optional[Any]:
      _a      =							self.get_config()
      _a      =							3_00
      return config
 def 							__UpperCAmelCase						(	self ,			__magic_name__  )   ->							Dict:
      self.parent.assertListEqual(list(result.loss.size()  ) ,			[]  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Dict:
      _a      =							DebertaModel(config=__magic_name__  )
      model.to(__magic_name__  )
      model.eval()
      _a      =							model(__magic_name__ ,			attention_mask=__magic_name__ ,			token_type_ids=__magic_name__  )[0]
      _a      =							model(__magic_name__ ,			token_type_ids=__magic_name__  )[0]
      _a      =							model(__magic_name__  )[0]

      self.parent.assertListEqual(list(sequence_output.size()  ) ,			[self.batch_size, self.seq_length, self.hidden_size]  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Dict:
      _a      =							DebertaForMaskedLM(config=__magic_name__  )
      model.to(__magic_name__  )
      model.eval()
      _a      =							model(__magic_name__ ,			attention_mask=__magic_name__ ,			token_type_ids=__magic_name__ ,			labels=__magic_name__  )

      self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.seq_length, self.vocab_size)  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Optional[int]:
      _a      =							self.num_labels
      _a      =							DebertaForSequenceClassification(__magic_name__  )
      model.to(__magic_name__  )
      model.eval()
      _a      =							model(__magic_name__ ,			attention_mask=__magic_name__ ,			token_type_ids=__magic_name__ ,			labels=__magic_name__  )
      self.parent.assertListEqual(list(result.logits.size()  ) ,			[self.batch_size, self.num_labels]  )
      self.check_loss_output(__magic_name__  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Dict:
      _a      =							self.num_labels
      _a      =							DebertaForTokenClassification(config=__magic_name__  )
      model.to(__magic_name__  )
      model.eval()
      _a      =							model(__magic_name__ ,			attention_mask=__magic_name__ ,			token_type_ids=__magic_name__ ,			labels=__magic_name__  )
      self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.seq_length, self.num_labels)  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Optional[int]:
      _a      =							DebertaForQuestionAnswering(config=__magic_name__  )
      model.to(__magic_name__  )
      model.eval()
      _a      =							model(
          __magic_name__ ,			attention_mask=__magic_name__ ,			token_type_ids=__magic_name__ ,			start_positions=__magic_name__ ,			end_positions=__magic_name__ ,			)
      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 							__UpperCAmelCase						(	self  )   ->							Any:
      _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       (       _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					,			unittest.TestCase    ):
 _lowerCAmelCase	   =		(
     (
         DebertaModel,
         DebertaForMaskedLM,
         DebertaForSequenceClassification,
         DebertaForTokenClassification,
         DebertaForQuestionAnswering,
     )
     if is_torch_available()
     else ()
 )
 _lowerCAmelCase	   =		(
     {
         """feature-extraction""": DebertaModel,
         """fill-mask""": DebertaForMaskedLM,
         """question-answering""": DebertaForQuestionAnswering,
         """text-classification""": DebertaForSequenceClassification,
         """token-classification""": DebertaForTokenClassification,
         """zero-shot""": DebertaForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )

 _lowerCAmelCase	   =		True
 _lowerCAmelCase	   =		False
 _lowerCAmelCase	   =		False
 _lowerCAmelCase	   =		False
 _lowerCAmelCase	   =		False
 def 							__UpperCAmelCase						(	self  )   ->							List[str]:
      _a      =							DebertaModelTester(self  )
      _a      =							ConfigTester(self ,			config_class=__magic_name__ ,			hidden_size=37  )
 def 							__UpperCAmelCase						(	self  )   ->							Tuple:
      self.config_tester.run_common_tests()
 def 							__UpperCAmelCase						(	self  )   ->							Any:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_deberta_model(*__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							str:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_deberta_for_sequence_classification(*__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_deberta_for_masked_lm(*__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							Optional[int]:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_deberta_for_question_answering(*__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							Any:
      _a      =							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_deberta_for_token_classification(*__magic_name__  )




 @slow
 def 							__UpperCAmelCase						(	self  )   ->							Optional[Any]:
      for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a      =							DebertaModel.from_pretrained(__magic_name__  )
           self.assertIsNotNone(__magic_name__  )





@require_torch
@require_sentencepiece
@require_tokenizers
class 	a       (       unittest.TestCase    ):
 @unittest.skip(reason='Model not available yet'  )
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      pass




 @slow
 def 							__UpperCAmelCase						(	self  )   ->							int:
      _a      =							DebertaModel.from_pretrained('microsoft/deberta-base'  )

      _a      =							torch.tensor([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]]  )
      _a      =							torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
      with torch.no_grad():
           _a      =							model(__magic_name__ ,			attention_mask=__magic_name__  )[0]
      # compare the actual values for a slice.
      _a      =							torch.tensor(
          [[[-0.5_9_8_6, -0.8_0_5_5, -0.8_4_6_2], [1.4_4_8_4, -0.9_3_4_8, -0.8_0_5_9], [0.3_1_2_3, 0.0_0_3_2, -1.4_1_3_1]]]  )
      self.assertTrue(torch.allclose(output[:, 1:4, 1:4] ,			__magic_name__ ,			atol=1e-4  ) ,			f'{output[:, 1:4, 1:4]}'  )

