

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


_lowerCamelCase    :       Tuple        =							logging.get_logger(__name__)





@dataclass
class  __UpperCAmelCase					(	lowerCamelCase__						):
   UpperCamelCase       					=					[
       """no_inference""",
       """no_cuda""",
       """no_tpu""",
       """no_speed""",
       """no_memory""",
       """no_env_print""",
       """no_multi_process""",
   ]



   def __init__(							self							:					Optional[int],		**__A							:					int						):
     for deprecated_arg in self.deprecated_args:
       if deprecated_arg in kwargs:
         UpperCAmelCase	:							Union[str, Any]						=			deprecated_arg[3:]
         setattr(self,		__A,		not kwargs.pop(__A						)						)
         logger.warning(
             F'''{deprecated_arg} is depreciated. Please use --no_{positive_arg} or'''
             F''' {positive_arg}={kwargs[positive_arg]}'''						)

     UpperCAmelCase	:							int						=			kwargs.pop('''torchscript''',		self.torchscript						)
     UpperCAmelCase	:							Union[str, Any]						=			kwargs.pop('''torch_xla_tpu_print_metrics''',		self.torch_xla_tpu_print_metrics						)
     UpperCAmelCase	:							str						=			kwargs.pop('''fp16_opt_level''',		self.fpaa_opt_level						)
     super().__init__(**__A						)

   UpperCamelCase       					=					field(default=lowerCamelCase__      ,  metadata={"""help""": """Trace the models using torchscript"""}						)
   UpperCamelCase       					=					field(default=lowerCamelCase__      ,  metadata={"""help""": """Print Xla/PyTorch tpu metrics"""}						)
   UpperCamelCase       					=					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 	__magic_name__   (							self							:					Any						):
     requires_backends(self,		['''torch''']						)
     logger.info('''PyTorch: setting up devices'''						)
     if not self.cuda:
       UpperCAmelCase	:							Tuple						=			torch.device('''cpu'''						)
       UpperCAmelCase	:							int						=			0
     elif is_torch_tpu_available():
       UpperCAmelCase	:							int						=			xm.xla_device()
       UpperCAmelCase	:							List[str]						=			0
     else:
       UpperCAmelCase	:							Tuple						=			torch.device('''cuda''' if torch.cuda.is_available() else '''cpu'''						)
       UpperCAmelCase	:							List[str]						=			torch.cuda.device_count()
     return device, n_gpu



   @property
   def 	__magic_name__   (							self							:					Union[str, Any]						):
     return is_torch_tpu_available() and self.tpu



   @property
   def 	__magic_name__   (							self							:					List[Any]						):
     requires_backends(self,		['''torch''']						)
     # TODO(PVP): currently only single GPU is supported
     return torch.cuda.current_device()



   @property
   def 	__magic_name__   (							self							:					Optional[int]						):
     requires_backends(self,		['''torch''']						)
     return self._setup_devices[0]



   @property
   def 	__magic_name__   (							self							:					Optional[int]						):
     requires_backends(self,		['''torch''']						)
     return self._setup_devices[1]





   @property
   def 	__magic_name__   (							self							:					Dict						):
     return self.n_gpu > 0








from typing import TYPE_CHECKING

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


_lowerCamelCase    :       str        =							{"configuration_xlnet": ["XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLNetConfig"]}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _lowerCamelCase    :       List[Any]        =							["XLNetTokenizer"]

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _lowerCamelCase    :       Optional[Any]        =							["XLNetTokenizerFast"]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _lowerCamelCase    :       Dict        =							[
         "XLNET_PRETRAINED_MODEL_ARCHIVE_LIST",
         "XLNetForMultipleChoice",
         "XLNetForQuestionAnswering",
         "XLNetForQuestionAnsweringSimple",
         "XLNetForSequenceClassification",
         "XLNetForTokenClassification",
         "XLNetLMHeadModel",
         "XLNetModel",
         "XLNetPreTrainedModel",
         "load_tf_weights_in_xlnet",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _lowerCamelCase    :       Union[str, Any]        =							[
         "TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST",
         "TFXLNetForMultipleChoice",
         "TFXLNetForQuestionAnsweringSimple",
         "TFXLNetForSequenceClassification",
         "TFXLNetForTokenClassification",
         "TFXLNetLMHeadModel",
         "TFXLNetMainLayer",
         "TFXLNetModel",
         "TFXLNetPreTrainedModel",
     ]


if TYPE_CHECKING:
     from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig

     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_xlnet import XLNetTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_xlnet_fast import XLNetTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_xlnet import (
              XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
              XLNetForMultipleChoice,
              XLNetForQuestionAnswering,
              XLNetForQuestionAnsweringSimple,
              XLNetForSequenceClassification,
              XLNetForTokenClassification,
              XLNetLMHeadModel,
              XLNetModel,
              XLNetPreTrainedModel,
              load_tf_weights_in_xlnet,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_xlnet import (
              TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFXLNetForMultipleChoice,
              TFXLNetForQuestionAnsweringSimple,
              TFXLNetForSequenceClassification,
              TFXLNetForTokenClassification,
              TFXLNetLMHeadModel,
              TFXLNetMainLayer,
              TFXLNetModel,
              TFXLNetPreTrainedModel,
          )

else:
     import sys

     _lowerCamelCase    :       Optional[Any]        =							_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





