




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


_SCREAMING_SNAKE_CASE							:       str						=			logging.get_logger(__name__)




@dataclass
class 			_snake_case		(     lowercase_							):
			lowerCAmelCase_					:				List[str]							=   [
			    "no_inference",
			    "no_cuda",
			    "no_tpu",
			    "no_speed",
			    "no_memory",
			    "no_env_print",
			    "no_multi_process",
			]




			def __init__( self    ,							**a__							)    ->    Tuple:

										'''simple docstring'''




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

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




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

										'''simple docstring'''




										requires_backends(self    ,							["tf"]							)
										snake_case_      =				None
										if self.tpu:
																	try:
																								if self.tpu_name:
																															snake_case_      =				tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name							)
																								else:
																															snake_case_      =				tf.distribute.cluster_resolver.TPUClusterResolver()
																	except ValueError:
																								snake_case_      =				None
										return tpu




			@cached_property
			def        lowerCAmelCase__    ( 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							)

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

										return strategy




			@property
			def        lowerCAmelCase__    ( self							)    ->    bool:

										'''simple docstring'''




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




			@property
			def        lowerCAmelCase__    ( self							)    ->    "tf.distribute.Strategy":

										'''simple docstring'''




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




			@property
			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




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




			@property
			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




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




			@property
			def        lowerCAmelCase__    ( self							)    ->    bool:

										'''simple docstring'''




										return self.n_gpu > 0










'''simple docstring'''





from ..utils import DummyObject, requires_backends




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Dict							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    str:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Dict							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Optional[Any]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    str:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[int]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Optional[Any]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				List[str]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[int]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				int							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Any:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Optional[Any]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Any:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    int:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Dict							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[int]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				List[str]							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				int							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    int:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Any							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Tuple:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    str:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				str							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    List[str]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




class 			_snake_case		(     metaclass=lowercase_							):
			lowerCAmelCase_					:				Tuple							=   ["flax"]




			def __init__( self    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(self    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    int:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							*a__    ,							**a__							)    ->    Optional[Any]:

										'''simple docstring'''




										requires_backends(cls    ,							["flax"]							)




