
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


lowercase_											=	logging.get_logger(__name__)

if is_tf_available():
 import tensorflow as tf





@dataclass
class   __UpperCamelCase				(    _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 				UpperCAmelCase__    (							self    :    Any				):







       """simple docstring"""




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

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

           __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						tf.distribute.TPUStrategy(_lowerCamelCase				)

         elif len(_lowerCamelCase				) == 0:
           __SCREAMING_SNAKE_CASE     :					List[str]			=						tf.distribute.OneDeviceStrategy(device='''/cpu:0'''				)
         elif len(_lowerCamelCase				) == 1:
           __SCREAMING_SNAKE_CASE     :					Optional[int]			=						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`
           __SCREAMING_SNAKE_CASE     :					int			=						tf.distribute.MirroredStrategy()
         else:
           raise ValueError('''Cannot find the proper strategy, please check your environment properties.'''				)

       return strategy



     @property
     def 				UpperCAmelCase__    (							self    :    Tuple				):







       """simple docstring"""




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



     @property
     def 				UpperCAmelCase__    (							self    :    str				):







       """simple docstring"""




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



     @property
     def 				UpperCAmelCase__    (							self    :    Dict				):







       """simple docstring"""




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



     @property
     def 				UpperCAmelCase__    (							self    :    Dict				):







       """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.'''				)
       __SCREAMING_SNAKE_CASE     :					int			=						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    :    str				):







       """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.'''				)
       __SCREAMING_SNAKE_CASE     :					Optional[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    :    Any				):







       """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 Optional

from ..utils.logging import get_logger
from .audio_classificiation import AudioClassification
from .automatic_speech_recognition import AutomaticSpeechRecognition
from .base import TaskTemplate
from .image_classification import ImageClassification
from .language_modeling import LanguageModeling
from .question_answering import QuestionAnsweringExtractive
from .summarization import Summarization
from .text_classification import TextClassification


lowercase_											=	[
    """AutomaticSpeechRecognition""",
    """AudioClassification""",
    """ImageClassification""",
    """LanguageModeling""",
    """QuestionAnsweringExtractive""",
    """Summarization""",
    """TaskTemplate""",
    """TextClassification""",
]

lowercase_											=	get_logger(__name__)


lowercase_											=	{
    AutomaticSpeechRecognition.task: AutomaticSpeechRecognition,
    AudioClassification.task: AudioClassification,
    ImageClassification.task: ImageClassification,
    LanguageModeling.task: LanguageModeling,
    QuestionAnsweringExtractive.task: QuestionAnsweringExtractive,
    Summarization.task: Summarization,
    TextClassification.task: TextClassification,
}


def     a__			(    snake_case    ):





  """simple docstring"""
  __SCREAMING_SNAKE_CASE     :					str			=						task_template_dict.get('''task'''    )
  if task_name is None:
    logger.warning(F'''Couldn\'t find template for task \'{task_name}\'. Available templates: {list(snake_case    )}'''    )
    return None
  __SCREAMING_SNAKE_CASE     :					Any			=						NAMEaTEMPLATE.get(snake_case    )
  return template.from_dict(snake_case    )
