




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











"""simple docstring"""






from typing import TYPE_CHECKING

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


_lowercase					:					str 		=		{
    "configuration_openai": ["OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP", "OpenAIGPTConfig"],
    "tokenization_openai": ["OpenAIGPTTokenizer"],
}

try:
		if not is_tokenizers_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase					:					List[Any] 		=		["OpenAIGPTTokenizerFast"]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase					:					Union[str, Any] 		=		[
		    "OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "OpenAIGPTDoubleHeadsModel",
		    "OpenAIGPTForSequenceClassification",
		    "OpenAIGPTLMHeadModel",
		    "OpenAIGPTModel",
		    "OpenAIGPTPreTrainedModel",
		    "load_tf_weights_in_openai_gpt",
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase					:					Optional[Any] 		=		[
		    "TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "TFOpenAIGPTDoubleHeadsModel",
		    "TFOpenAIGPTForSequenceClassification",
		    "TFOpenAIGPTLMHeadModel",
		    "TFOpenAIGPTMainLayer",
		    "TFOpenAIGPTModel",
		    "TFOpenAIGPTPreTrainedModel",
		]


if TYPE_CHECKING:
		from .configuration_openai import OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenAIGPTConfig
		from .tokenization_openai import OpenAIGPTTokenizer

		try:
				if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_openai_fast import OpenAIGPTTokenizerFast

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_openai import (
				    OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    OpenAIGPTDoubleHeadsModel,
				    OpenAIGPTForSequenceClassification,
				    OpenAIGPTLMHeadModel,
				    OpenAIGPTModel,
				    OpenAIGPTPreTrainedModel,
				    load_tf_weights_in_openai_gpt,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_openai import (
				    TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFOpenAIGPTDoubleHeadsModel,
				    TFOpenAIGPTForSequenceClassification,
				    TFOpenAIGPTLMHeadModel,
				    TFOpenAIGPTMainLayer,
				    TFOpenAIGPTModel,
				    TFOpenAIGPTPreTrainedModel,
				)

else:
		import sys

		_lowercase					:					Dict 		=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




