




'''simple docstring'''







import numpy as np  # noqa: E402

from ...configuration_utils import ConfigMixin, register_to_config
from ...schedulers.scheduling_utils import SchedulerMixin


try:
    import librosa  # noqa: E402

    lowerCAmelCase_    	=							True
    lowerCAmelCase_    	=							''''''
except Exception as e:
    lowerCAmelCase_    	=							False
    lowerCAmelCase_    	=							(
        f'''Cannot import librosa because {e}. Make sure to correctly install librosa to be able to install it.'''
    )


from PIL import Image  # noqa: E402

class   _snake_case( A__					,   A__			):
 __snake_case:       Optional[Any]									=				'''mel_config.json'''






 @register_to_config
 def __init__(self					:     Any						,		a					:     int = 2_56						,		a					:     int = 2_56						,		a					:     int = 2_20_50						,		a					:     int = 20_48						,		a					:     int = 5_12						,		a					:     int = 80						,		a					:     int = 32						,		)					->      Union[str, Any]:






    """simple docstring"""


    A__         =    hop_length
    A__         =    sample_rate
    A__         =    n_fft
    A__         =    top_db
    A__         =    n_iter
    self.set_resolution(a						,		a						)
    A__         =    None

    if not _librosa_can_be_imported:
       raise ValueError(_import_error						)






 def 	_UpperCamelCase   (self					:     Tuple						,		a					:     int						,		a					:     int						)					->      List[Any]:






    """simple docstring"""


    A__         =    x_res
    A__         =    y_res
    A__         =    self.y_res
    A__         =    self.x_res * self.hop_length - 1






 def 	_UpperCamelCase   (self					:     str						,		a					:     str = None						,		a					:     np.ndarray = None						)					->      List[str]:






    """simple docstring"""


    if audio_file is not None:
       A__         =    librosa.load(a						,		mono=a						,		sr=self.sr						)
    else:
       A__         =    raw_audio

    # Pad with silence if necessary.
    if len(self.audio						) < self.x_res * self.hop_length:
       A__         =    np.concatenate([self.audio, np.zeros((self.x_res * self.hop_length - len(self.audio						),)						)]						)






 def 	_UpperCamelCase   (self					:     List[Any]						)					->      Tuple:






    """simple docstring"""


    return len(self.audio						) // self.slice_size






 def 	_UpperCamelCase   (self					:     int						,		a					:     int = 0						)					->      str:






    """simple docstring"""


    return self.audio[self.slice_size * slice : self.slice_size * (slice + 1)]






 def 	_UpperCamelCase   (self					:     Tuple						)					->      Tuple:






    """simple docstring"""


    return self.sr






 def 	_UpperCamelCase   (self					:     Union[str, Any]						,		a					:     int						)					->      List[Any]:






    """simple docstring"""


    A__         =    librosa.feature.melspectrogram(
        y=self.get_audio_slice(a						)						,		sr=self.sr						,		n_fft=self.n_fft						,		hop_length=self.hop_length						,		n_mels=self.n_mels						)
    A__         =    librosa.power_to_db(a						,		ref=np.max						,		top_db=self.top_db						)
    A__         =    (((log_S + self.top_db) * 2_55 / self.top_db).clip(0						,		2_55						) + 0.5).astype(np.uinta						)
    A__         =    Image.fromarray(a						)
    return image






 def 	_UpperCamelCase   (self					:     List[Any]						,		a					:     Image.Image						)					->      Tuple:






    """simple docstring"""


    A__         =    np.frombuffer(image.tobytes()						,		dtype="uint8"						).reshape((image.height, image.width)						)
    A__         =    bytedata.astype("float"						) * self.top_db / 2_55 - self.top_db
    A__         =    librosa.db_to_power(a						)
    A__         =    librosa.feature.inverse.mel_to_audio(
        a						,		sr=self.sr						,		n_fft=self.n_fft						,		hop_length=self.hop_length						,		n_iter=self.n_iter						)
    return audio








'''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_    	=							logging.get_logger(__name__)

if is_tf_available():
    import tensorflow as tf

@dataclass
class   _snake_case( UpperCAmelCase			):
 __snake_case:       Optional[Any]									=				'''tf'''
 __snake_case:       Optional[str]									=				field(
     default=UpperCAmelCase					,   metadata={'''help''': '''Name of TPU'''}					,   )

 __snake_case:       Optional[str]									=				field(
     default=UpperCAmelCase					,   metadata={'''help''': '''Zone of TPU'''}					,   )

 __snake_case:       Optional[str]									=				field(
     default=UpperCAmelCase					,   metadata={'''help''': '''Name of Cloud TPU-enabled project'''}					,   )

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

 __snake_case:       bool									=				field(default=UpperCAmelCase					,   metadata={'''help''': '''Whether to activate the XLA compilation or not'''}			)






 @cached_property
 def 	_UpperCamelCase   (self					:     Tuple						)					->      Tuple["tf.distribute.Strategy", int]:






    """simple docstring"""


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

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

          A__         =    tf.distribute.TPUStrategy(a						)

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

    return strategy






 @property
 def 	_UpperCamelCase   (self					:     List[Any]						)					->      "tf.distribute.Strategy":






    """simple docstring"""


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






 @property
 def 	_UpperCamelCase   (self					:     Tuple						)					->      int:






    """simple docstring"""


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






 @property
 def 	_UpperCamelCase   (self					:     Optional[Any]						)					->      int:






    """simple docstring"""


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






 @property
 def 	_UpperCamelCase   (self					:     Union[str, Any]						)					->      int:






    """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.'						)
    A__         =    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					:     Optional[int]						)					->      int:






    """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.'						)
    A__         =    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					:     Optional[Any]						)					->      int:






    """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.'						,		a						,		)
    return self._setup_strategy.num_replicas_in_sync


