


import warnings
from dataclasses import dataclass, field
from typing import Optional, Tuple

from .training_args import TrainingArguments
from .utils import cached_property, is_tf_available, logging, requires_backends


UpperCamelCase			:					Optional[int]         =							logging.get_logger(__name__)

if is_tf_available():
					import tensorflow as tf

@dataclass
class      __snake_case				(   A_):
					SCREAMING_SNAKE_CASE_		:       List[str]								=			'tf'
					SCREAMING_SNAKE_CASE_		:       Optional[str]								=			field(
					    default=A_	,      metadata={"help": "Name of TPU"}	,      )

					SCREAMING_SNAKE_CASE_		:       Optional[str]								=			field(
					    default=A_	,      metadata={"help": "Zone of TPU"}	,      )

					SCREAMING_SNAKE_CASE_		:       Optional[str]								=			field(
					    default=A_	,      metadata={"help": "Name of Cloud TPU-enabled project"}	,      )

					SCREAMING_SNAKE_CASE_		:       float								=			field(
					    default=1.0	,      metadata={"help": "Power for the Polynomial decay LR scheduler."}	,      )

					SCREAMING_SNAKE_CASE_		:       bool								=			field(default=A_	,      metadata={"help": "Whether to activate the XLA compilation or not"})
					@cached_property
					def 	a			(						self       :						int  )							->					Any:



											'''simple docstring'''





											requires_backends(self	,      ['tf']  )
											logger.info('Tensorflow: setting up strategy'  )

											__magic_name__					=      tf.config.list_physical_devices('GPU'  )

											# Set to float16 at first
											if self.fpaa:
																	tf.keras.mixed_precision.set_global_policy('mixed_float16'  )

											if self.no_cuda:
																	__magic_name__					=      tf.distribute.OneDeviceStrategy(device='/cpu:0'  )
											else:
																	try:
																							if self.tpu_name:
																													__magic_name__					=      tf.distribute.cluster_resolver.TPUClusterResolver(
																													    self.tpu_name	,      zone=self.tpu_zone	,      project=self.gcp_project  )
																							else:
																													__magic_name__					=      tf.distribute.cluster_resolver.TPUClusterResolver()
																	except ValueError:
																							if self.tpu_name:
																													raise RuntimeError(F'''Couldn\'t connect to TPU {self.tpu_name}!'''  )
																							else:
																													__magic_name__					=      None

																	if tpu:
																							# Set to bfloat16 in case of TPU
																							if self.fpaa:
																													tf.keras.mixed_precision.set_global_policy('mixed_bfloat16'  )

																							tf.config.experimental_connect_to_cluster(_lowerCAmelCase  )
																							tf.tpu.experimental.initialize_tpu_system(_lowerCAmelCase  )

																							__magic_name__					=      tf.distribute.TPUStrategy(_lowerCAmelCase  )

																	elif len(_lowerCAmelCase  ) == 0:
																							__magic_name__					=      tf.distribute.OneDeviceStrategy(device='/cpu:0'  )
																	elif len(_lowerCAmelCase  ) == 1:
																							__magic_name__					=      tf.distribute.OneDeviceStrategy(device='/gpu:0'  )
																	elif len(_lowerCAmelCase  ) > 1:
																							# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
																							__magic_name__					=      tf.distribute.MirroredStrategy()
																	else:
																							raise ValueError('Cannot find the proper strategy, please check your environment properties.'  )

											return strategy
					@property
					def 	a			(						self       :						Dict  )							->					str:



											'''simple docstring'''





											requires_backends(self	,      ['tf']  )
											return self._setup_strategy
					@property
					def 	a			(						self       :						Any  )							->					Dict:



											'''simple docstring'''





											requires_backends(self	,      ['tf']  )
											return self._setup_strategy.num_replicas_in_sync
					@property
					def 	a			(						self       :						str  )							->					List[Any]:



											'''simple docstring'''





											return False  # TF Logging is handled by Keras not the Trainer
					@property
					def 	a			(						self       :						Union[str, Any]  )							->					List[str]:



											'''simple docstring'''





											if self.per_gpu_train_batch_size:
																	logger.warning(
																	    'Using deprecated `--per_gpu_train_batch_size` argument which will be removed in a future '
																	    'version. Using `--per_device_train_batch_size` is preferred.'  )
											__magic_name__					=      self.per_gpu_train_batch_size or self.per_device_train_batch_size
											return per_device_batch_size * self.n_replicas
					@property
					def 	a			(						self       :						List[str]  )							->					Union[str, Any]:



											'''simple docstring'''





											if self.per_gpu_eval_batch_size:
																	logger.warning(
																	    'Using deprecated `--per_gpu_eval_batch_size` argument which will be removed in a future '
																	    'version. Using `--per_device_eval_batch_size` is preferred.'  )
											__magic_name__					=      self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
											return per_device_batch_size * self.n_replicas







					@property
					def 	a			(						self       :						Optional[Any]  )							->					str:



											'''simple docstring'''





											requires_backends(self	,      ['tf']  )
											warnings.warn(
											    'The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead.'	,      _lowerCAmelCase	,      )
											return self._setup_strategy.num_replicas_in_sync






from typing import TYPE_CHECKING

from ...utils import _LazyModule


_lowercase				:					List[Any]     					={"""tokenization_bert_japanese""": ["""BertJapaneseTokenizer""", """CharacterTokenizer""", """MecabTokenizer"""]}


if TYPE_CHECKING:
	from .tokenization_bert_japanese import BertJapaneseTokenizer, CharacterTokenizer, MecabTokenizer

else:
	import sys

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

