




'''simple docstring'''

import logging
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union

import librosa
import torch
from datasets import DatasetDict, load_dataset
from packaging import version
from torch import nn

from transformers import (
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaForPreTraining,
    is_apex_available,
    trainer_utils,
)
from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices


if is_apex_available():
							from apex import amp

if version.parse(version.parse(torch.__version__).base_version) >= version.parse('1.6'):
							a  :				Dict									=  True
							from torch.cuda.amp import autocast


a  :				List[str]									=  logging.getLogger(__name__)






@dataclass
class 						a				:
				snake_case_      =		field(
				    metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}     )
				snake_case_      =		field(
				    default=_lowerCamelCase   ,     metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}   ,     )
				snake_case_      =		field(
				    default=_lowerCamelCase   ,     metadata={"help": "Whether to freeze the feature extractor layers of the model."}     )
				snake_case_      =		field(
				    default=_lowerCamelCase   ,     metadata={"help": "Whether to log verbose messages or not."}   ,     )
				snake_case_      =		field(
				    default=2.0   ,     metadata={"help": "Maximum temperature for gumbel softmax."}     )
				snake_case_      =		field(
				    default=0.5   ,     metadata={"help": "Minimum temperature for gumbel softmax."}     )
				snake_case_      =		field(
				    default=0.999_995   ,     metadata={"help": "Decay of gumbel temperature during training."}     )







def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase	)		->					List[Any]:

					'''simple docstring'''

					logging.basicConfig(
					    format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''',      datefmt='''%m/%d/%Y %H:%M:%S''',      handlers=[logging.StreamHandler(sys.stdout	)],      )
					snake_case_									=				logging.WARNING
					if model_args.verbose_logging:
										snake_case_									=				logging.DEBUG
					elif trainer_utils.is_main_process(training_args.local_rank	):
										snake_case_									=				logging.INFO
					logger.setLevel(__UpperCAmelCase	)






@dataclass
class 						a				:
				snake_case_      =		field(
				    default=_lowerCamelCase   ,     metadata={"help": "The name of the dataset to use (via the datasets library)."}     )
				snake_case_      =		field(
				    default=_lowerCamelCase   ,     metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}     )
				snake_case_      =		field(
				    default="train"   ,     metadata={
				        "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
				    }   ,     )
				snake_case_      =		field(
				    default="validation"   ,     metadata={
				        "help": (
				            "The name of the validation data set split to use (via the datasets library). Defaults to 'validation'"
				        )
				    }   ,     )
				snake_case_      =		field(
				    default="file"   ,     metadata={"help": "Column in the dataset that contains speech file path. Defaults to 'file'"}   ,     )
				snake_case_      =		field(
				    default=_lowerCamelCase   ,     metadata={"help": "Overwrite the cached preprocessed datasets or not."}     )
				snake_case_      =		field(
				    default=1   ,     metadata={
				        "help": "The percentage of the train set used as validation set in case there's no validation split"
				    }   ,     )
				snake_case_      =		field(
				    default=_lowerCamelCase   ,     metadata={"help": "The number of processes to use for the preprocessing."}   ,     )
				snake_case_      =		field(
				    default=20.0   ,     metadata={"help": "Filter audio files that are longer than `max_duration_in_seconds` seconds"}     )







@dataclass
class 						a				:
				snake_case_      =		42
				snake_case_      =		42
				snake_case_      =		"longest"
				snake_case_      =		None
				snake_case_      =		None


				def __call__(		self    :					str       ,				lowercase_    :					List[Dict[str, Union[List[int], torch.Tensor]]]					):
									# reformat list to dict and set to pytorch format
									snake_case_									=				self.feature_extractor.pad(
									    lowercase_       ,				max_length=self.max_length       ,				padding=self.padding       ,				pad_to_multiple_of=self.pad_to_multiple_of       ,				return_tensors='''pt'''       ,				)
									snake_case_									=				self.model._get_feat_extract_output_lengths(batch['''input_values'''].shape[-1]					)

									snake_case_									=				batch['''input_values'''].shape[0]

									# make sure that no loss is computed on padded inputs
									if batch["attention_mask"] is not None:
														# compute real output lengths according to convolution formula
														snake_case_									=				self.model._get_feat_extract_output_lengths(batch['''attention_mask'''].sum(-1					)					).to(
														    torch.long					)

														snake_case_									=				torch.zeros(
														    (batch_size, mask_indices_seq_length)       ,				dtype=torch.long       ,				device=batch['''input_values'''].device					)

														# these two operations makes sure that all values
														# before the output lengths indices are attended to
														snake_case_									=				1
														snake_case_									=				attention_mask.flip([-1]					).cumsum(-1					).flip([-1]					).bool()

									# sample randomly masked indices
									snake_case_									=				_compute_mask_indices(
									    (batch_size, mask_indices_seq_length)       ,				self.model.config.mask_time_prob       ,				self.model.config.mask_time_length       ,				attention_mask=lowercase_       ,				min_masks=2       ,				)

									return batch







class 						a				(   _lowerCamelCase     ):


				def __init__(		self    :					Dict       ,				*lowercase_    :					Optional[Any]       ,				lowercase_    :					Tuple=1       ,				lowercase_    :					Dict=0       ,				lowercase_    :					Dict=1.0       ,				**lowercase_    :					Optional[Any]					):
									super().__init__(*lowercase_       ,				**lowercase_					)
									snake_case_									=				0
									snake_case_									=				max_gumbel_temp
									snake_case_									=				min_gumbel_temp
									snake_case_									=				gumbel_temp_decay


				def   A_ (		self    :					Optional[Any]       ,				lowercase_    :					nn.Module       ,				lowercase_    :					Dict[str, Union[torch.Tensor, Any]]					):
									model.train()
									snake_case_									=				self._prepare_inputs(lowercase_					)

									if self.use_amp:
														with autocast():
																			snake_case_									=				self.compute_loss(lowercase_       ,				lowercase_					)
									else:
														snake_case_									=				self.compute_loss(lowercase_       ,				lowercase_					)

									if self.args.n_gpu > 1 or self.deepspeed:
														if model.module.config.ctc_loss_reduction == "mean":
																			snake_case_									=				loss.mean()
														elif model.module.config.ctc_loss_reduction == "sum":
																			snake_case_									=				loss.sum() / (inputs['''mask_time_indices''']).sum()
														else:
																			raise ValueError(F"{model.config.ctc_loss_reduction} is not valid. Choose one of ['mean', 'sum']"					)

									if self.args.gradient_accumulation_steps > 1:
														snake_case_									=				loss / self.args.gradient_accumulation_steps

									if self.use_amp:
														self.scaler.scale(lowercase_					).backward()
									elif self.use_apex:
														with amp.scale_loss(lowercase_       ,				self.optimizer					) as scaled_loss:
																			scaled_loss.backward()
									elif self.deepspeed:
														self.deepspeed.backward(lowercase_					)
									else:
														loss.backward()

									self.num_update_step += 1
									# make sure gumbel softmax temperature is decayed
									if self.args.n_gpu > 1 or self.deepspeed:
														model.module.set_gumbel_temperature(
														    max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step       ,				self.min_gumbel_temp					)					)
									else:
														model.set_gumbel_temperature(
														    max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step       ,				self.min_gumbel_temp					)					)

									return loss.detach()







def 		__magic_name__    (	)		->					Dict:

					'''simple docstring'''

					snake_case_									=				HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)	)

					snake_case_			,snake_case_			,snake_case_									=				parser.parse_args_into_dataclasses()
					configure_logger(__UpperCAmelCase,      __UpperCAmelCase	)

					# Downloading and loading a dataset from the hub.
					snake_case_									=				load_dataset(data_args.dataset_name,      data_args.dataset_config_name,      cache_dir=model_args.cache_dir	)

					if "validation" not in datasets.keys():
										# make sure only "validation" and "train" keys remain"
										snake_case_									=				DatasetDict()
										snake_case_									=				load_dataset(
										    data_args.dataset_name,      data_args.dataset_config_name,      split=F"{data_args.train_split_name}[:{data_args.validation_split_percentage}%]",      cache_dir=model_args.cache_dir,      )
										snake_case_									=				load_dataset(
										    data_args.dataset_name,      data_args.dataset_config_name,      split=F"{data_args.train_split_name}[{data_args.validation_split_percentage}%:]",      cache_dir=model_args.cache_dir,      )
					else:
										# make sure only "validation" and "train" keys remain"
										snake_case_									=				DatasetDict()
										snake_case_									=				load_dataset(
										    data_args.dataset_name,      data_args.dataset_config_name,      split='''validation''',      cache_dir=model_args.cache_dir,      )
										snake_case_									=				load_dataset(
										    data_args.dataset_name,      data_args.dataset_config_name,      split=F"{data_args.train_split_name}",      cache_dir=model_args.cache_dir,      )

					# only normalized-inputs-training is supported
					snake_case_									=				WavaVecaFeatureExtractor.from_pretrained(
					    model_args.model_name_or_path,      cache_dir=model_args.cache_dir,      do_normalize=__UpperCAmelCase	)

					def prepare_dataset(__UpperCAmelCase	):
										# check that all files have the correct sampling rate
										snake_case_			,snake_case_									=				librosa.load(batch[data_args.speech_file_column],      sr=feature_extractor.sampling_rate	)
										return batch

					# load audio files into numpy arrays
					snake_case_									=				datasets.map(
					    __UpperCAmelCase,      num_proc=data_args.preprocessing_num_workers,      remove_columns=datasets['''train'''].column_names	)

					# filter audio files that are too long
					snake_case_									=				vectorized_datasets.filter(
					    lambda __UpperCAmelCase	: len(data['''speech''']	) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate	)	)

					def normalize(__UpperCAmelCase	):
										return feature_extractor(batch['''speech'''],      sampling_rate=feature_extractor.sampling_rate	)

					# normalize and transform to `BatchFeatures`
					snake_case_									=				vectorized_datasets.map(
					    __UpperCAmelCase,      batched=__UpperCAmelCase,      num_proc=data_args.preprocessing_num_workers,      load_from_cache_file=not data_args.overwrite_cache,      remove_columns=vectorized_datasets['''train'''].column_names,      )

					# pretraining is only supported for "newer" stable layer norm architecture
					# apply_spec_augment has to be True, mask_feature_prob has to be 0.0
					snake_case_									=				WavaVecaConfig.from_pretrained(
					    model_args.model_name_or_path,      cache_dir=model_args.cache_dir,      gradient_checkpointing=training_args.gradient_checkpointing,      )

					if not config.do_stable_layer_norm or config.feat_extract_norm != "layer":
										raise ValueError(
										    '''PreTraining is only supported for ``config.do_stable_layer_norm=True`` and'''
										    ''' ``config.feat_extract_norm=\'layer\''''	)

					snake_case_									=				WavaVecaForPreTraining(__UpperCAmelCase	)

					snake_case_									=				DataCollatorForWavaVecaPretraining(model=__UpperCAmelCase,      feature_extractor=__UpperCAmelCase	)

					snake_case_									=				WavaVecaPreTrainer(
					    model=__UpperCAmelCase,      data_collator=__UpperCAmelCase,      args=__UpperCAmelCase,      train_dataset=vectorized_datasets['''train'''],      eval_dataset=vectorized_datasets['''validation'''],      tokenizer=__UpperCAmelCase,      max_gumbel_temp=model_args.max_gumbel_temperature,      min_gumbel_temp=model_args.min_gumbel_temperature,      gumbel_temp_decay=model_args.gumbel_temperature_decay,      )
					trainer.train()


if __name__ == "__main__":
							main()



"""simple docstring"""





from collections import namedtuple

_a		       =							namedtuple('from_to', 'from_ to')

_a		       =							{
    'cubicmeter': from_to(1, 1),
    'litre': from_to(0.001, 1_000),
    'kilolitre': from_to(1, 1),
    'gallon': from_to(0.0_0454, 264.172),
    'cubicyard': from_to(0.7_6455, 1.3_0795),
    'cubicfoot': from_to(0.028, 35.3147),
    'cup': from_to(0.0_0023_6588, 4226.75),
}







def 	__a     (		__lowerCamelCase,		__lowerCamelCase,		__lowerCamelCase  ):
   if from_type not in METRIC_CONVERSION:
      raise ValueError(
          f"""Invalid 'from_type' value: {from_type!r}  Supported values are:\n"""
          + ", ".join(__lowerCamelCase  )  )
   if to_type not in METRIC_CONVERSION:
      raise ValueError(
          f"""Invalid 'to_type' value: {to_type!r}.  Supported values are:\n"""
          + ", ".join(__lowerCamelCase  )  )
   return value * METRIC_CONVERSION[from_type].from_ * METRIC_CONVERSION[to_type].to


if __name__ == "__main__":
    import doctest

    doctest.testmod()


