'''simple docstring'''


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


snake_case__	:     str      =    logging.get_logger(__name__)

if is_tf_available():
 import tensorflow as tf






@dataclass
class 	__SCREAMING_SNAKE_CASE		(			lowerCamelCase_			):







  '''simple docstring'''






  lowerCamelCase_						:List[Any]		       =						'''tf'''
  lowerCamelCase_						:Optional[str]		       =						field(
      default=lowerCamelCase_		,      metadata={'''help''': '''Name of TPU'''}		,      )

  lowerCamelCase_						:Optional[str]		       =						field(
      default=lowerCamelCase_		,      metadata={'''help''': '''Zone of TPU'''}		,      )

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

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

  lowerCamelCase_						:bool		       =						field(default=lowerCamelCase_		,      metadata={'''help''': '''Whether to activate the XLA compilation or not'''}			)


  @cached_property
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

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

       UpperCAmelCase_				:  List[str]  = 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:
            UpperCAmelCase_				:  Tuple  = tf.distribute.OneDeviceStrategy(device='/cpu:0'		)
       else:
            try:
                 if self.tpu_name:
                      UpperCAmelCase_				:  List[Any]  = tf.distribute.cluster_resolver.TPUClusterResolver(
                          self.tpu_name ,						zone=self.tpu_zone ,						project=self.gcp_project		)
                 else:
                      UpperCAmelCase_				:  Any  = tf.distribute.cluster_resolver.TPUClusterResolver()
            except ValueError:
                 if self.tpu_name:
                      raise RuntimeError(F'''Couldn\'t connect to TPU {self.tpu_name}!'''		)
                 else:
                      UpperCAmelCase_				:  str  = 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(snake_case_		)
                 tf.tpu.experimental.initialize_tpu_system(snake_case_		)

                 UpperCAmelCase_				:  str  = tf.distribute.TPUStrategy(snake_case_		)

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

       return strategy


  @property
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

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


  @property
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

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


  @property
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       return False  # TF Logging is handled by Keras not the Trainer


  @property
  def _UpperCamelCase	(					self		):




       '''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.'		)
       UpperCAmelCase_				:  Union[str, Any]  = self.per_gpu_train_batch_size or self.per_device_train_batch_size
       return per_device_batch_size * self.n_replicas


  @property
  def _UpperCamelCase	(					self		):




       '''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.'		)
       UpperCAmelCase_				:  Union[str, Any]  = self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
       return per_device_batch_size * self.n_replicas






  @property
  def _UpperCamelCase	(					self		):




       '''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.' ,						snake_case_ ,						)
       return self._setup_strategy.num_replicas_in_sync








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


lowerCamelCase__        =						{"""configuration_regnet""": ["""REGNET_PRETRAINED_CONFIG_ARCHIVE_MAP""", """RegNetConfig"""]}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase__        =						[
					    """REGNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """RegNetForImageClassification""",
					    """RegNetModel""",
					    """RegNetPreTrainedModel""",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase__        =						[
					    """TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """TFRegNetForImageClassification""",
					    """TFRegNetModel""",
					    """TFRegNetPreTrainedModel""",
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase__        =						[
					    """FlaxRegNetForImageClassification""",
					    """FlaxRegNetModel""",
					    """FlaxRegNetPreTrainedModel""",
					]


if TYPE_CHECKING:
					from .configuration_regnet import REGNET_PRETRAINED_CONFIG_ARCHIVE_MAP, RegNetConfig

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_regnet import (
										    REGNET_PRETRAINED_MODEL_ARCHIVE_LIST,
										    RegNetForImageClassification,
										    RegNetModel,
										    RegNetPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_regnet import (
										    TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFRegNetForImageClassification,
										    TFRegNetModel,
										    TFRegNetPreTrainedModel,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_regnet import (
										    FlaxRegNetForImageClassification,
										    FlaxRegNetModel,
										    FlaxRegNetPreTrainedModel,
										)


else:
					import sys

					lowerCamelCase__        =						_LazyModule(__name__, globals()["""__file__"""], _import_structure)