

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

if is_tf_available():
    import tensorflow as tf

@dataclass
class 						__snake_case						(							snake_case__     ):
       """simple docstring"""







       __SCREAMING_SNAKE_CASE													=       "tf"
       __SCREAMING_SNAKE_CASE													=       field(
           default=snake_case__ ,  metadata={"help": "Name of TPU"} ,  )

       __SCREAMING_SNAKE_CASE													=       field(
           default=snake_case__ ,  metadata={"help": "Zone of TPU"} ,  )

       __SCREAMING_SNAKE_CASE													=       field(
           default=snake_case__ ,  metadata={"help": "Name of Cloud TPU-enabled project"} ,  )

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

       __SCREAMING_SNAKE_CASE													=       field(default=snake_case__ ,  metadata={"help": "Whether to activate the XLA compilation or not"}     )


       @cached_property
       def  a		(		self      )			->       Tuple["tf.distribute.Strategy", int]:






              """simple docstring"""


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

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

                            __snake_case					  =       tf.distribute.TPUStrategy(_UpperCamelCase      )

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

              return strategy


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






              """simple docstring"""


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


       @property
       def  a		(		self      )			->       int:






              """simple docstring"""


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


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






              """simple docstring"""


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


       @property
       def  a		(		self      )			->       int:






              """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."""      )
              __snake_case					  =       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      )			->       int:






              """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."""      )
              __snake_case					  =       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      )			->       int:






              """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."""			,   _UpperCamelCase			,   )
              return self._setup_strategy.num_replicas_in_sync




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


UpperCamelCase__		   =    {
    '''configuration_splinter''': ['''SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SplinterConfig'''],
    '''tokenization_splinter''': ['''SplinterTokenizer'''],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase__		   =    ['''SplinterTokenizerFast''']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase__		   =    [
        '''SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''SplinterForQuestionAnswering''',
        '''SplinterForPreTraining''',
        '''SplinterLayer''',
        '''SplinterModel''',
        '''SplinterPreTrainedModel''',
    ]


if TYPE_CHECKING:
    from .configuration_splinter import SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP, SplinterConfig
    from .tokenization_splinter import SplinterTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_splinter_fast import SplinterTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_splinter import (
            SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST,
            SplinterForPreTraining,
            SplinterForQuestionAnswering,
            SplinterLayer,
            SplinterModel,
            SplinterPreTrainedModel,
        )


else:
    import sys

    UpperCamelCase__		   =    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

