


from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_torch_available, is_torch_tpu_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_torch_available():
   import torch

if is_torch_tpu_available(check_device=False):
   import torch_xla.core.xla_model as xm


UpperCAmelCase_				:			Any   =	logging.get_logger(__name__)
@dataclass
class 			SCREAMING_SNAKE_CASE__  (    lowercase__      ):
      snake_case__    :					Optional[Any]					       =						[
          '''no_inference''',
          '''no_cuda''',
          '''no_tpu''',
          '''no_speed''',
          '''no_memory''',
          '''no_env_print''',
          '''no_multi_process''',
      ]
      def __init__(	self    :	Tuple					,							**SCREAMING_SNAKE_CASE__    :	List[Any]					)		->      Optional[Any]:
             for deprecated_arg in self.deprecated_args:
                    if deprecated_arg in kwargs:
                           a_ :		Union[str, Any]							=  deprecated_arg[3:]
                           setattr(self					,							SCREAMING_SNAKE_CASE__					,							not kwargs.pop(SCREAMING_SNAKE_CASE__					)					)
                           logger.warning(
                               F"""{deprecated_arg} is depreciated. Please use --no_{positive_arg} or"""
                               F""" {positive_arg}={kwargs[positive_arg]}"""					)

             a_ :		Any							=  kwargs.pop('torchscript'					,							self.torchscript					)
             a_ :		Dict							=  kwargs.pop('torch_xla_tpu_print_metrics'					,							self.torch_xla_tpu_print_metrics					)
             a_ :		Optional[Any]							=  kwargs.pop('fp16_opt_level'					,							self.fpaa_opt_level					)
             super().__init__(**SCREAMING_SNAKE_CASE__					)

      snake_case__    :					bool					       =						field(default=lowercase__						,   metadata={'''help''': '''Trace the models using torchscript'''}      )
      snake_case__    :					bool					       =						field(default=lowercase__						,   metadata={'''help''': '''Print Xla/PyTorch tpu metrics'''}      )
      snake_case__    :					str					       =						field(
          default='''O1'''						,   metadata={
              '''help''': (
                  '''For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\']. '''
                  '''See details at https://nvidia.github.io/apex/amp.html'''
              )
          }						,   )
      @cached_property
      def 	SCREAMING_SNAKE_CASE							(	self    :	List[str]					)		->      Tuple["torch.device", int]:
             requires_backends(self					,							['torch']					)
             logger.info('PyTorch: setting up devices'					)
             if not self.cuda:
                    a_ :		List[Any]							=  torch.device('cpu'					)
                    a_ :		Union[str, Any]							=  0
             elif is_torch_tpu_available():
                    a_ :		Dict							=  xm.xla_device()
                    a_ :		Union[str, Any]							=  0
             else:
                    a_ :		List[Any]							=  torch.device('cuda' if torch.cuda.is_available() else 'cpu'					)
                    a_ :		List[Any]							=  torch.cuda.device_count()
             return device, n_gpu
      @property
      def 	SCREAMING_SNAKE_CASE							(	self    :	Any					)		->      List[Any]:
             return is_torch_tpu_available() and self.tpu
      @property
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[int]					)		->      int:
             requires_backends(self					,							['torch']					)
             # TODO(PVP): currently only single GPU is supported
             return torch.cuda.current_device()
      @property
      def 	SCREAMING_SNAKE_CASE							(	self    :	List[Any]					)		->      "torch.device":
             requires_backends(self					,							['torch']					)
             return self._setup_devices[0]
      @property
      def 	SCREAMING_SNAKE_CASE							(	self    :	Tuple					)		->      List[str]:
             requires_backends(self					,							['torch']					)
             return self._setup_devices[1]

      @property
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[Any]					)		->      Optional[Any]:
             return self.n_gpu > 0



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase_				:			Any   =	{
    'configuration_mobilebert': [
        'MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'MobileBertConfig',
        'MobileBertOnnxConfig',
    ],
    'tokenization_mobilebert': ['MobileBertTokenizer'],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_				:			Union[str, Any]   =	['MobileBertTokenizerFast']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_				:			List[str]   =	[
       'MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'MobileBertForMaskedLM',
       'MobileBertForMultipleChoice',
       'MobileBertForNextSentencePrediction',
       'MobileBertForPreTraining',
       'MobileBertForQuestionAnswering',
       'MobileBertForSequenceClassification',
       'MobileBertForTokenClassification',
       'MobileBertLayer',
       'MobileBertModel',
       'MobileBertPreTrainedModel',
       'load_tf_weights_in_mobilebert',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_				:			Tuple   =	[
       'TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFMobileBertForMaskedLM',
       'TFMobileBertForMultipleChoice',
       'TFMobileBertForNextSentencePrediction',
       'TFMobileBertForPreTraining',
       'TFMobileBertForQuestionAnswering',
       'TFMobileBertForSequenceClassification',
       'TFMobileBertForTokenClassification',
       'TFMobileBertMainLayer',
       'TFMobileBertModel',
       'TFMobileBertPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_mobilebert import (
       MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
       MobileBertConfig,
       MobileBertOnnxConfig,
   )
   from .tokenization_mobilebert import MobileBertTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_mobilebert_fast import MobileBertTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_mobilebert import (
          MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          MobileBertForMaskedLM,
          MobileBertForMultipleChoice,
          MobileBertForNextSentencePrediction,
          MobileBertForPreTraining,
          MobileBertForQuestionAnswering,
          MobileBertForSequenceClassification,
          MobileBertForTokenClassification,
          MobileBertLayer,
          MobileBertModel,
          MobileBertPreTrainedModel,
          load_tf_weights_in_mobilebert,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_mobilebert import (
          TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFMobileBertForMaskedLM,
          TFMobileBertForMultipleChoice,
          TFMobileBertForNextSentencePrediction,
          TFMobileBertForPreTraining,
          TFMobileBertForQuestionAnswering,
          TFMobileBertForSequenceClassification,
          TFMobileBertForTokenClassification,
          TFMobileBertMainLayer,
          TFMobileBertModel,
          TFMobileBertPreTrainedModel,
      )

else:
   import sys

   UpperCAmelCase_				:			Tuple   =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


