






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

if is_tf_available():
     import tensorflow as tf




@dataclass
class  lowercase_     (_UpperCAmelCase  ):
      A__						:		Union[str, Any]							      =					'''tf'''
      A__						:		Optional[str]							      =					field(
          default=_UpperCAmelCase,     metadata={'''help''': '''Name of TPU'''},     )

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

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

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

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






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







        '''simple docstring'''


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

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

            _a					      =						tf.distribute.TPUStrategy(a_						)

          elif len(a_						) == 0:
            _a					      =						tf.distribute.OneDeviceStrategy(device="/cpu:0"						)
          elif len(a_						) == 1:
            _a					      =						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`
            _a					      =						tf.distribute.MirroredStrategy()
          else:
            raise ValueError("Cannot find the proper strategy, please check your environment properties."						)

        return strategy






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







        '''simple docstring'''


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






      @property
      def       lowerCamelCase__     (     self						)						->int:







        '''simple docstring'''


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






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







        '''simple docstring'''


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






      @property
      def       lowerCamelCase__     (     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."						)
        _a					      =						self.per_gpu_train_batch_size or self.per_device_train_batch_size
        return per_device_batch_size * self.n_replicas






      @property
      def       lowerCamelCase__     (     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."						)
        _a					      =						self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
        return per_device_batch_size * self.n_replicas






      @property
      def       lowerCamelCase__     (     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."  ,  a_  ,  )
        return self._setup_strategy.num_replicas_in_sync










"""simple docstring"""




from typing import TYPE_CHECKING

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


UpperCamelCase											=     {"""configuration_pegasus""": ["""PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PegasusConfig"""]}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase											=     ["""PegasusTokenizer"""]

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase											=     ["""PegasusTokenizerFast"""]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase											=     [
         """PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """PegasusForCausalLM""",
         """PegasusForConditionalGeneration""",
         """PegasusModel""",
         """PegasusPreTrainedModel""",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase											=     [
         """TFPegasusForConditionalGeneration""",
         """TFPegasusModel""",
         """TFPegasusPreTrainedModel""",
     ]

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase											=     [
         """FlaxPegasusForConditionalGeneration""",
         """FlaxPegasusModel""",
         """FlaxPegasusPreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_pegasus import PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusConfig

     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_pegasus import PegasusTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_pegasus_fast import PegasusTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_pegasus import (
              PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
              PegasusForCausalLM,
              PegasusForConditionalGeneration,
              PegasusModel,
              PegasusPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_pegasus import TFPegasusForConditionalGeneration, TFPegasusModel, TFPegasusPreTrainedModel

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_pegasus import (
              FlaxPegasusForConditionalGeneration,
              FlaxPegasusModel,
              FlaxPegasusPreTrainedModel,
          )

else:
     import sys

     UpperCamelCase											=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


