

'''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


A_       						=							logging.get_logger(__name__)





@dataclass
class 							_snake_case (       _a						):
   _A       :     Tuple       =					[
       '''no_inference''',
       '''no_cuda''',
       '''no_tpu''',
       '''no_speed''',
       '''no_memory''',
       '''no_env_print''',
       '''no_multi_process''',
   ]
   def __init__( self			:      Any     ,**SCREAMING_SNAKE_CASE__			:      List[str]							):
     for deprecated_arg in self.deprecated_args:
       if deprecated_arg in kwargs:
         SCREAMING_SNAKE_CASE:Any						      =					deprecated_arg[3:]
         SCREAMING_SNAKE_CASE:Union[str, Any]						      =					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]}'''							)
     SCREAMING_SNAKE_CASE:Tuple						      =					kwargs.pop("tpu_name"     ,self.tpu_name							)
     SCREAMING_SNAKE_CASE:Dict						      =					kwargs.pop("device_idx"     ,self.device_idx							)
     SCREAMING_SNAKE_CASE:Optional[int]						      =					kwargs.pop("eager_mode"     ,self.eager_mode							)
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					kwargs.pop("use_xla"     ,self.use_xla							)
     super().__init__(**SCREAMING_SNAKE_CASE__							)

   _A       :     str       =					field(
       default=_a	,  metadata={'''help''': '''Name of TPU'''}	,  )
   _A       :     int       =					field(
       default=0	,  metadata={'''help''': '''CPU / GPU device index. Defaults to 0.'''}	,  )
   _A       :     bool       =					field(default=_a	,  metadata={'''help''': '''Benchmark models in eager model.'''}						)
   _A       :     bool       =					field(
       default=_a	,  metadata={
           '''help''': '''Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`.'''
       }	,  )
   @cached_property
   def     __UpperCamelCase						( self			:      Any							):
     requires_backends(self     ,["tf"]							)
     SCREAMING_SNAKE_CASE:str						      =					None
     if self.tpu:
       try:
         if self.tpu_name:
           SCREAMING_SNAKE_CASE:Optional[Any]						      =					tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name							)
         else:
           SCREAMING_SNAKE_CASE:str						      =					tf.distribute.cluster_resolver.TPUClusterResolver()
       except ValueError:
         SCREAMING_SNAKE_CASE:List[str]						      =					None
     return tpu
   @cached_property
   def     __UpperCamelCase						( self			:      List[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							)

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

     return strategy
   @property
   def     __UpperCamelCase						( self			:      Union[str, Any]							):
     requires_backends(self     ,["tf"]							)
     return self._setup_tpu is not None
   @property
   def     __UpperCamelCase						( self			:      Optional[int]							):
     requires_backends(self     ,["tf"]							)
     return self._setup_strategy
   @property
   def     __UpperCamelCase						( self			:      Tuple							):
     requires_backends(self     ,["tf"]							)
     return tf.config.list_physical_devices("GPU"							)
   @property
   def     __UpperCamelCase						( self			:      Any							):
     requires_backends(self     ,["tf"]							)
     if self.cuda:
       return len(self.gpu_list							)
     return 0







   @property
   def     __UpperCamelCase						( self			:      Tuple							):
     return self.n_gpu > 0









'''simple docstring'''

from ....utils import logging


A_       						=							logging.get_logger(__name__)





class 							_snake_case (       _a						):
   def __init__( self			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]=None     ,SCREAMING_SNAKE_CASE__			:      Optional[int]=2_048							):
     SCREAMING_SNAKE_CASE:int						      =					config.__dict__
     SCREAMING_SNAKE_CASE:List[str]						      =					modal_hidden_size
     if num_labels:
       SCREAMING_SNAKE_CASE:str						      =					num_labels






