




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


a_ 		=  logging.get_logger(__name__)

if is_tf_available():
 import tensorflow as tf

@dataclass
class 			_lowerCamelCase    (      _SCREAMING_SNAKE_CASE ):

      """simple docstring"""

      lowerCAmelCase__      :			List[str]     =       "tf"
      lowerCAmelCase__      :			Optional[str]     =       field(
          default=_SCREAMING_SNAKE_CASE				,      metadata={"help": "Name of TPU"}				,      )

      lowerCAmelCase__      :			Optional[str]     =       field(
          default=_SCREAMING_SNAKE_CASE				,      metadata={"help": "Zone of TPU"}				,      )

      lowerCAmelCase__      :			Optional[str]     =       field(
          default=_SCREAMING_SNAKE_CASE				,      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=_SCREAMING_SNAKE_CASE				,      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(snake_case					)
                  tf.tpu.experimental.initialize_tpu_system(snake_case					)

                  __UpperCamelCase			=    tf.distribute.TPUStrategy(snake_case					)

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

          return strategy







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







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







      @property
      def    snake_case						(  self       :			Tuple					):
          return False  # TF Logging is handled by Keras not the Trainer







      @property
      def    snake_case						(  self       :			List[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       :			str					):
          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       :			List[Any]					):
          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_tf_available, is_torch_available


_SCREAMING_SNAKE_CASE     :   Optional[Any]							 =      {
    'configuration_flaubert': ['FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FlaubertConfig', 'FlaubertOnnxConfig'],
    'tokenization_flaubert': ['FlaubertTokenizer'],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE     :   Tuple							 =      [
					    'FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'FlaubertForMultipleChoice',
					    'FlaubertForQuestionAnswering',
					    'FlaubertForQuestionAnsweringSimple',
					    'FlaubertForSequenceClassification',
					    'FlaubertForTokenClassification',
					    'FlaubertModel',
					    'FlaubertWithLMHeadModel',
					    'FlaubertPreTrainedModel',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE     :   Dict							 =      [
					    'TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFFlaubertForMultipleChoice',
					    'TFFlaubertForQuestionAnsweringSimple',
					    'TFFlaubertForSequenceClassification',
					    'TFFlaubertForTokenClassification',
					    'TFFlaubertModel',
					    'TFFlaubertPreTrainedModel',
					    'TFFlaubertWithLMHeadModel',
					]


if TYPE_CHECKING:
					from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
					from .tokenization_flaubert import FlaubertTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flaubert import (
										    FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    FlaubertForMultipleChoice,
										    FlaubertForQuestionAnswering,
										    FlaubertForQuestionAnsweringSimple,
										    FlaubertForSequenceClassification,
										    FlaubertForTokenClassification,
										    FlaubertModel,
										    FlaubertPreTrainedModel,
										    FlaubertWithLMHeadModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_flaubert import (
										    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFFlaubertForMultipleChoice,
										    TFFlaubertForQuestionAnsweringSimple,
										    TFFlaubertForSequenceClassification,
										    TFFlaubertForTokenClassification,
										    TFFlaubertModel,
										    TFFlaubertPreTrainedModel,
										    TFFlaubertWithLMHeadModel,
										)

else:
					import sys

					_SCREAMING_SNAKE_CASE     :   List[Any]							 =      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)