



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					:				Optional[Any]   	=logging.get_logger(__name__)

if is_tf_available():
		import tensorflow as tf






@dataclass
class 	_a			(      snake_case_  ):
			_UpperCamelCase:   List[str]	     =		"tf"
			_UpperCamelCase:   Optional[str]	     =		field(
			    default=snake_case_     , metadata={"help": "Name of TPU"}     , )

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

			_UpperCamelCase:   Optional[str]	     =		field(
			    default=snake_case_     , metadata={"help": "Name of Cloud TPU-enabled project"}     , )

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

			_UpperCamelCase:   bool	     =		field(default=snake_case_     , metadata={"help": "Whether to activate the XLA compilation or not"}  )






			@cached_property
			def 							_snake_case   (    self )	->					Tuple["tf.distribute.Strategy", int]:
									requires_backends(self    ,  ["""tf"""] )
									logger.info("""Tensorflow: setting up strategy""" )

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

																					lowerCAmelCase	:   int					     =					tf.distribute.TPUStrategy(lowercase_ )

															elif len(lowercase_ ) == 0:
																					lowerCAmelCase	:   Dict					     =					tf.distribute.OneDeviceStrategy(device="""/cpu:0""" )
															elif len(lowercase_ ) == 1:
																					lowerCAmelCase	:   Tuple					     =					tf.distribute.OneDeviceStrategy(device="""/gpu:0""" )
															elif len(lowercase_ ) > 1:
																					# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
																					lowerCAmelCase	:   Optional[Any]					     =					tf.distribute.MirroredStrategy()
															else:
																					raise ValueError("""Cannot find the proper strategy, please check your environment properties.""" )

									return strategy






			@property
			def 							_snake_case   (    self )	->					"tf.distribute.Strategy":
									requires_backends(self    ,  ["""tf"""] )
									return self._setup_strategy






			@property
			def 							_snake_case   (    self )	->					int:
									requires_backends(self    ,  ["""tf"""] )
									return self._setup_strategy.num_replicas_in_sync






			@property
			def 							_snake_case   (    self )	->					Any:
									return False  # TF Logging is handled by Keras not the Trainer






			@property
			def 							_snake_case   (    self )	->					int:
									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.""" )
									lowerCAmelCase	:   List[Any]					     =					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 )	->					int:
									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.""" )
									lowerCAmelCase	:   List[str]					     =					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 )	->					int:
									requires_backends(self    ,  ["""tf"""] )
									warnings.warn(
									    """The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead."""    ,  lowercase_    ,  )
									return self._setup_strategy.num_replicas_in_sync






from typing import TYPE_CHECKING

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


lowerCAmelCase					:				Optional[int]   	={
    'configuration_speech_to_text_2': ['SPEECH_TO_TEXT_2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Speech2Text2Config'],
    'processing_speech_to_text_2': ['Speech2Text2Processor'],
    'tokenization_speech_to_text_2': ['Speech2Text2Tokenizer'],
}


try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCAmelCase					:				int   	=[
		    'SPEECH_TO_TEXT_2_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'Speech2Text2ForCausalLM',
		    'Speech2Text2PreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_speech_to_text_a import SPEECH_TO_TEXT_2_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextaConfig
		from .processing_speech_to_text_a import SpeechaTextaProcessor
		from .tokenization_speech_to_text_a import SpeechaTextaTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_speech_to_text_a import (
				    SPEECH_TO_TEXT_2_PRETRAINED_MODEL_ARCHIVE_LIST,
				    SpeechaTextaForCausalLM,
				    SpeechaTextaPreTrainedModel,
				)

else:
		import sys

		lowerCAmelCase					:				Union[str, Any]   	=_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

