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


_UpperCamelCase				:		Tuple       			=		logging.get_logger(__name__)

if is_tf_available():
     import tensorflow as tf

@dataclass
class   _lowercase(     _lowerCamelCase				):



   """simple docstring"""





   __lowerCamelCase    =  '''tf'''
   __lowerCamelCase    =  field(
       default=_lowerCamelCase   ,metadata={'''help''': '''Name of TPU'''}   ,)

   __lowerCamelCase    =  field(
       default=_lowerCamelCase   ,metadata={'''help''': '''Zone of TPU'''}   ,)

   __lowerCamelCase    =  field(
       default=_lowerCamelCase   ,metadata={'''help''': '''Name of Cloud TPU-enabled project'''}   ,)

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

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





   @cached_property
   def 			snake_case	(							self:    int	):
    requires_backends(self			,['tf']	)
    logger.info('Tensorflow: setting up strategy'	)

    __UpperCAmelCase         =					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         =					tf.distribute.OneDeviceStrategy(device='/cpu:0'	)
    else:
     try:
      if self.tpu_name:
       __UpperCAmelCase         =					tf.distribute.cluster_resolver.TPUClusterResolver(
           self.tpu_name			,zone=self.tpu_zone			,project=self.gcp_project	)
      else:
       __UpperCAmelCase         =					tf.distribute.cluster_resolver.TPUClusterResolver()
     except ValueError:
      if self.tpu_name:
       raise RuntimeError(f"""Couldn't connect to TPU {self.tpu_name}!"""	)
      else:
       __UpperCAmelCase         =					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(a	)
      tf.tpu.experimental.initialize_tpu_system(a	)

      __UpperCAmelCase         =					tf.distribute.TPUStrategy(a	)

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

    return strategy





   @property
   def 			snake_case	(							self:    Union[str, Any]	):
    requires_backends(self			,['tf']	)
    return self._setup_strategy





   @property
   def 			snake_case	(							self:    List[Any]	):
    requires_backends(self			,['tf']	)
    return self._setup_strategy.num_replicas_in_sync





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





   @property
   def 			snake_case	(							self:    Optional[Any]	):
    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         =					self.per_gpu_train_batch_size or self.per_device_train_batch_size
    return per_device_batch_size * self.n_replicas





   @property
   def 			snake_case	(							self:    Dict	):
    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         =					self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
    return per_device_batch_size * self.n_replicas





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




'''simple docstring'''




from typing import TYPE_CHECKING

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


_UpperCamelCase				:		int       			=		{
    'configuration_align': [
        'ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'AlignConfig',
        'AlignTextConfig',
        'AlignVisionConfig',
    ],
    'processing_align': ['AlignProcessor'],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCamelCase				:		Optional[Any]       			=		[
         'ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST',
         'AlignModel',
         'AlignPreTrainedModel',
         'AlignTextModel',
         'AlignVisionModel',
     ]

if TYPE_CHECKING:
     from .configuration_align import (
         ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP,
         AlignConfig,
         AlignTextConfig,
         AlignVisionConfig,
     )
     from .processing_align import AlignProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_align import (
              ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST,
              AlignModel,
              AlignPreTrainedModel,
              AlignTextModel,
              AlignVisionModel,
          )

else:
     import sys

     _UpperCamelCase				:		str       			=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



