





'''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


lowerCAmelCase__      :   str      	=			logging.get_logger(__name__)

if is_tf_available():
			import tensorflow as tf


@dataclass
class      SCREAMING_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 		lowerCamelCase_   (   self       :      Tuple		):







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

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

											__UpperCAmelCase	:							Tuple     =     tf.distribute.TPUStrategy(UpperCAmelCase_		)

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

							return strategy
					@property
					def 		lowerCamelCase_   (   self       :      Dict		):







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







							"""simple docstring"""
							return False  # TF Logging is handled by Keras not the Trainer
					@property
					def 		lowerCamelCase_   (   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."		)
							__UpperCAmelCase	:							Optional[int]     =     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       :      List[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."		)
							__UpperCAmelCase	:							Optional[int]     =     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       :      List[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."		,	UpperCAmelCase_		,	)
							return self._setup_strategy.num_replicas_in_sync











'''simple docstring'''

from typing import TYPE_CHECKING

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


lowerCAmelCase__      :   Any      	=			{
    "configuration_open_llama": ["OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "OpenLlamaConfig"],
}

try:
			if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			lowerCAmelCase__      :   Optional[int]      	=			["LlamaTokenizer"]

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			lowerCAmelCase__      :   int      	=			["LlamaTokenizerFast"]

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			lowerCAmelCase__      :   int      	=			[
			    "OpenLlamaForCausalLM",
			    "OpenLlamaModel",
			    "OpenLlamaPreTrainedModel",
			    "OpenLlamaForSequenceClassification",
			]


if TYPE_CHECKING:
			from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig

			try:
						if not is_sentencepiece_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from transformers import LlamaTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from transformers import LlamaTokenizerFast

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_open_llama import (
						    OpenLlamaForCausalLM,
						    OpenLlamaForSequenceClassification,
						    OpenLlamaModel,
						    OpenLlamaPreTrainedModel,
						)


else:
			import sys

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




