



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__   			=   logging.get_logger(__name__)


@dataclass
class   __lowerCAmelCase  (		UpperCAmelCase_   ):
					"""simple docstring"""






					A__					:		List[Any]      							=     [
					    "no_inference",
					    "no_cuda",
					    "no_tpu",
					    "no_speed",
					    "no_memory",
					    "no_env_print",
					    "no_multi_process",
					]



					def __init__(  self       :							Union[str, Any]					,       **_snake_case       :							List[str]       ):






								"""simple docstring"""


								for deprecated_arg in self.deprecated_args:
											if deprecated_arg in kwargs:
														A__	  =     deprecated_arg[3:]
														A__	  =     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__	  =     kwargs.pop('tpu_name'					,       self.tpu_name       )
								A__	  =     kwargs.pop('device_idx'					,       self.device_idx       )
								A__	  =     kwargs.pop('eager_mode'					,       self.eager_mode       )
								A__	  =     kwargs.pop('use_xla'					,       self.use_xla       )
								super().__init__(**_snake_case       )

					A__					:		str      							=     field(
					    default=UpperCAmelCase_				,  metadata={"help": "Name of TPU"}				,  )
					A__					:		int      							=     field(
					    default=0				,  metadata={"help": "CPU / GPU device index. Defaults to 0."}				,  )
					A__					:		bool      							=     field(default=UpperCAmelCase_				,  metadata={"help": "Benchmark models in eager model."}   )
					A__					:		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      _a				(  self       :							Dict       ):






								"""simple docstring"""


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



					@cached_property
					def      _a				(  self       :							str       ):






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

								return strategy



					@property
					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


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



					@property
					def      _a				(  self       :							Tuple       ):






								"""simple docstring"""


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



					@property
					def      _a				(  self       :							Any       ):






								"""simple docstring"""


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



					@property
					def      _a				(  self       :							Dict       ):






								"""simple docstring"""


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



					@property
					def      _a				(  self       :							List[Any]       ):






								"""simple docstring"""


								return self.n_gpu > 0












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available


SCREAMING_SNAKE_CASE__   :      Optional[int]				=		{"""tokenization_herbert""": ["""HerbertTokenizer"""]}

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


if TYPE_CHECKING:
					from .tokenization_herbert import HerbertTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_herbert_fast import HerbertTokenizerFast

else:
					import sys

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






