





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


SCREAMING_SNAKE_CASE__							:      int         =    logging.get_logger(__name__)







@dataclass
class 	__lowerCAmelCase      (       _UpperCamelCase	):
   _UpperCamelCase			:    Union[str, Any]  		=					[
       """no_inference""",
       """no_cuda""",
       """no_tpu""",
       """no_speed""",
       """no_memory""",
       """no_env_print""",
       """no_multi_process""",
   ]





   def __init__(			self       ,      **snake_case   )					->	Tuple:
      """simple docstring"""





      for deprecated_arg in self.deprecated_args:
         if deprecated_arg in kwargs:
            a__						:    Tuple   		=	deprecated_arg[3:]
            a__						:    int   		=	not kwargs.pop(snake_case   )
            logger.warning(
                F"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
                F""" {positive_arg}={kwargs[positive_arg]}"""   )
      a__						:    Optional[int]   		=	kwargs.pop("tpu_name"       ,      self.tpu_name   )
      a__						:    Optional[int]   		=	kwargs.pop("device_idx"       ,      self.device_idx   )
      a__						:    str   		=	kwargs.pop("eager_mode"       ,      self.eager_mode   )
      a__						:    Optional[Any]   		=	kwargs.pop("use_xla"       ,      self.use_xla   )
      super().__init__(**snake_case   )

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





   @cached_property
   def 						_snake_case			(			self   )					->	Tuple["tf.distribute.cluster_resolver.TPUClusterResolver"]:
      """simple docstring"""





      requires_backends(self       ,      ["tf"]   )
      a__						:    int   		=	None
      if self.tpu:
         try:
            if self.tpu_name:
               a__						:    Optional[Any]   		=	tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name   )
            else:
               a__						:    Union[str, Any]   		=	tf.distribute.cluster_resolver.TPUClusterResolver()
         except ValueError:
            a__						:    Dict   		=	None
      return tpu





   @cached_property
   def 						_snake_case			(			self   )					->	Tuple["tf.distribute.Strategy", "tf.distribute.cluster_resolver.TPUClusterResolver"]:
      """simple docstring"""





      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   )

         a__						:    Dict   		=	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"   )
            a__						:    int   		=	tf.distribute.OneDeviceStrategy(device=F"""/gpu:{self.device_idx}"""   )
         else:
            tf.config.set_visible_devices([]       ,      "GPU"   )  # disable GPU
            a__						:    Optional[Any]   		=	tf.distribute.OneDeviceStrategy(device=F"""/cpu:{self.device_idx}"""   )

      return strategy





   @property
   def 						_snake_case			(			self   )					->	bool:
      """simple docstring"""





      requires_backends(self       ,      ["tf"]   )
      return self._setup_tpu is not None





   @property
   def 						_snake_case			(			self   )					->	"tf.distribute.Strategy":
      """simple docstring"""





      requires_backends(self       ,      ["tf"]   )
      return self._setup_strategy





   @property
   def 						_snake_case			(			self   )					->	Optional[int]:
      """simple docstring"""





      requires_backends(self       ,      ["tf"]   )
      return tf.config.list_physical_devices("GPU"   )





   @property
   def 						_snake_case			(			self   )					->	int:
      """simple docstring"""





      requires_backends(self       ,      ["tf"]   )
      if self.cuda:
         return len(self.gpu_list   )
      return 0





   @property
   def 						_snake_case			(			self   )					->	bool:
      """simple docstring"""





      return self.n_gpu > 0








from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


SCREAMING_SNAKE_CASE__							:      Union[str, Any]         =    {
    """configuration_autoformer""": [
        """AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """AutoformerConfig""",
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__							:      Tuple         =    [
      """AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """AutoformerForPrediction""",
      """AutoformerModel""",
      """AutoformerPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_autoformer import (
      AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
      AutoformerConfig,
  )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_autoformer import (
        AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        AutoformerForPrediction,
        AutoformerModel,
        AutoformerPreTrainedModel,
    )

else:
  import sys

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

