





'''simple docstring'''




import doctest
import glob
import importlib
import inspect
import os
import re
from contextlib import contextmanager
from functools import wraps
from unittest.mock import patch

import numpy as np
import pytest
from absl.testing import parameterized

import datasets
from datasets import load_metric

from .utils import for_all_test_methods, local, slow


# mark all tests as integration
a__					:			List[str]          =     pytest.mark.integration


a__					:			Optional[Any]          =     {"comet"}
a__					:			int          =     importlib.util.find_spec('''fairseq''') is not None

a__					:			Union[str, Any]          =     {"code_eval"}
a__					:			Dict          =     os.name == "nt"

a__					:			Dict          =     {"bertscore", "frugalscore", "perplexity"}
a__					:			Any          =     importlib.util.find_spec('''transformers''') is not None




def 						__lowerCamelCase			(	UpperCAmelCase_							)   ->List[Any]:




	@wraps(_UpperCamelCase							)
	def wrapper(self					,				UpperCAmelCase_							):
		if not _has_fairseq and metric_name in REQUIRE_FAIRSEQ:
			self.skipTest('\"test requires Fairseq\"'							)
		else:
			test_case(self					,				_UpperCamelCase							)

	return wrapper




def 						__lowerCamelCase			(	UpperCAmelCase_							)   ->Tuple:




	@wraps(_UpperCamelCase							)
	def wrapper(self					,				UpperCAmelCase_							):
		if not _has_transformers and metric_name in REQUIRE_TRANSFORMERS:
			self.skipTest('\"test requires transformers\"'							)
		else:
			test_case(self					,				_UpperCamelCase							)

	return wrapper




def 						__lowerCamelCase			(	UpperCAmelCase_							)   ->Union[str, Any]:




	@wraps(_UpperCamelCase							)
	def wrapper(self					,				UpperCAmelCase_							):
		if _on_windows and metric_name in UNSUPPORTED_ON_WINDOWS:
			self.skipTest('\"test not supported on Windows\"'							)
		else:
			test_case(self					,				_UpperCamelCase							)

	return wrapper




def 						__lowerCamelCase			(	)   ->Dict:
	snake_case__	       =   [metric_dir.split(os.sep							)[-2] for metric_dir in glob.glob('./metrics/*/'							)]
	return [{"testcase_name": x, "metric_name": x} for x in metrics if x != "gleu"]  # gleu is unfinished






@parameterized.named_parameters(get_local_metric_names()							)
@for_all_test_methods(
    lowerCAmelCase__       ,       lowerCAmelCase__       ,       lowerCAmelCase__							)
@local
class 				__snake_case     (					parameterized.TestCase							):
	__lowerCAmelCase       						=  {}
	__lowerCAmelCase       						=  None





	@pytest.mark.filterwarnings('ignore:metric_module_factory is deprecated:FutureWarning'		)
	@pytest.mark.filterwarnings('ignore:load_metric is deprecated:FutureWarning'		)
	def   _snake_case   (		self      ,       UpperCamelCase_		)      ->		List[Any]:
		snake_case__	       =   '[...]'
		snake_case__	       =   importlib.import_module(
		    datasets.load.metric_module_factory(os.path.join('metrics'      ,       __a		)		).module_path		)
		snake_case__	       =   datasets.load.import_main_class(metric_module.__name__      ,       dataset=__a		)
		# check parameters
		snake_case__	       =   inspect.signature(metric._compute		).parameters
		self.assertTrue(all(p.kind != p.VAR_KEYWORD for p in parameters.values()		)		)  # no **kwargs
		# run doctest
		with self.patch_intensive_calls(__a      ,       metric_module.__name__		):
			with self.use_local_metrics():
				try:
					snake_case__	       =   doctest.testmod(__a      ,       verbose=__a      ,       raise_on_error=__a		)
				except doctest.UnexpectedException as e:
					raise e.exc_info[1]  # raise the exception that doctest caught
		self.assertEqual(results.failed      ,       0		)
		self.assertGreater(results.attempted      ,       1		)





	@slow
	def   _snake_case   (		self      ,       UpperCamelCase_		)      ->		Dict:
		snake_case__	       =   '[...]'
		snake_case__	       =   importlib.import_module(
		    datasets.load.metric_module_factory(os.path.join('metrics'      ,       __a		)		).module_path		)
		# run doctest
		with self.use_local_metrics():
			snake_case__	       =   doctest.testmod(__a      ,       verbose=__a      ,       raise_on_error=__a		)
		self.assertEqual(results.failed      ,       0		)
		self.assertGreater(results.attempted      ,       1		)





	@contextmanager
	def   _snake_case   (		self      ,       UpperCamelCase_      ,       UpperCamelCase_		)      ->		Union[str, Any]:
		if metric_name in self.INTENSIVE_CALLS_PATCHER:
			with self.INTENSIVE_CALLS_PATCHER[metric_name](__a		):
				yield
		else:
			yield





	@contextmanager
	def   _snake_case   (		self		)      ->		Tuple:
		def load_local_metric(UpperCamelCase_      ,       *UpperCamelCase_      ,       **UpperCamelCase_		):
			return load_metric(os.path.join('metrics'      ,       __a		)      ,       *__a      ,       **__a		)

		with patch('datasets.load_metric'		) as mock_load_metric:
			snake_case__	       =   load_local_metric
			yield





	@classmethod
	def   _snake_case   (		cls      ,       UpperCamelCase_		)      ->		List[Any]:
		def wrapper(UpperCamelCase_		):
			snake_case__	       =   contextmanager(__a		)
			snake_case__	       =   patcher
			return patcher

		return wrapper





@LocalMetricTest.register_intensive_calls_patcher('bleurt'							)
def 						__lowerCamelCase			(	UpperCAmelCase_							)   ->Optional[int]:
	import tensorflow.compat.va as tf
	from bleurt.score import Predictor

	tf.flags.DEFINE_string('sv'					,				''					,				''							)  # handle pytest cli flags






	class 				__snake_case     (					lowerCAmelCase__							):





		def   _snake_case   (		self      ,       UpperCamelCase_		)      ->		List[Any]:
			assert len(input_dict['input_ids']		) == 2
			return np.array([1.0_3, 1.0_4]		)

    # mock predict_fn which is supposed to do a forward pass with a bleurt model
	with patch('bleurt.score._create_predictor'							) as mock_create_predictor:
		snake_case__	       =   MockedPredictor()
		yield




@LocalMetricTest.register_intensive_calls_patcher('bertscore'							)
def 						__lowerCamelCase			(	UpperCAmelCase_							)   ->Optional[int]:
	import torch

	def bert_cos_score_idf(UpperCAmelCase_					,				UpperCAmelCase_					,				*UpperCAmelCase_					,				**UpperCAmelCase_							):
		return torch.tensor([[1.0, 1.0, 1.0]] * len(_UpperCamelCase							)							)

	# mock get_model which is supposed to do download a bert model
	# mock bert_cos_score_idf which is supposed to do a forward pass with a bert model
	with patch('bert_score.scorer.get_model'							), patch(
	    'bert_score.scorer.bert_cos_score_idf'							) as mock_bert_cos_score_idf:
		snake_case__	       =   bert_cos_score_idf
		yield




@LocalMetricTest.register_intensive_calls_patcher('comet'							)
def 						__lowerCamelCase			(	UpperCAmelCase_							)   ->List[Any]:




	def load_from_checkpoint(UpperCAmelCase_							):






		class 				__snake_case     :





			def   _snake_case   (		self      ,       UpperCamelCase_      ,       *UpperCamelCase_      ,       **UpperCamelCase_		)      ->		Dict:
				assert len(__a		) == 2
				snake_case__	       =   [0.1_9, 0.9_2]
				return scores, sum(__a		) / len(__a		)





		return Model()

	# mock load_from_checkpoint which is supposed to do download a bert model
	# mock load_from_checkpoint which is supposed to do download a bert model
	with patch('comet.download_model'							) as mock_download_model:
		snake_case__	       =   None
		with patch('comet.load_from_checkpoint'							) as mock_load_from_checkpoint:
			snake_case__	       =   load_from_checkpoint
			yield







def 						__lowerCamelCase			(	)   ->Union[str, Any]:
	snake_case__	       =   load_metric(os.path.join('metrics'					,				'seqeval'							)							)
	snake_case__	       =   'ERROR'
	snake_case__	       =   f'''Scheme should be one of [IOB1, IOB2, IOE1, IOE2, IOBES, BILOU], got {wrong_scheme}'''
	with pytest.raises(_UpperCamelCase					,				match=re.escape(_UpperCamelCase							)							):
		metric.compute(predictions=[]					,				references=[]					,				scheme=_UpperCamelCase							)







"""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	:  List[Any]            =     True
	from torch.cuda.amp import autocast


A	:  Any            =     logging.getLogger(__name__)
@dataclass
class     _UpperCamelCase    :
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =field(
							    metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}						)
							__UpperCAmelCase		:       Optional[str]							 =field(
							    default=lowerCAmelCase__			,metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}			,)
							__UpperCAmelCase		:       Optional[bool]							 =field(
							    default=lowerCAmelCase__			,metadata={"""help""": """Whether to freeze the feature extractor layers of the model."""}						)
							__UpperCAmelCase		:       Optional[bool]							 =field(
							    default=lowerCAmelCase__			,metadata={"""help""": """Whether to log verbose messages or not."""}			,)
							__UpperCAmelCase		:       Optional[float]							 =field(
							    default=2.0			,metadata={"""help""": """Maximum temperature for gumbel softmax."""}						)
							__UpperCAmelCase		:       Optional[float]							 =field(
							    default=0.5			,metadata={"""help""": """Minimum temperature for gumbel softmax."""}						)
							__UpperCAmelCase		:       Optional[float]							 =field(
							    default=0.999_995			,metadata={"""help""": """Decay of gumbel temperature during training."""}						)


def _lowerCamelCase      (						_UpperCamelCase       ,					_UpperCamelCase ):

			'''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 )]       ,					)
			__lowerCAmelCase							       =     logging.WARNING
			if model_args.verbose_logging:
						__lowerCAmelCase							       =     logging.DEBUG
			elif trainer_utils.is_main_process(training_args.local_rank ):
						__lowerCAmelCase							       =     logging.INFO
			logger.setLevel(_UpperCamelCase )
@dataclass
class     _UpperCamelCase    :
							'''simple docstring'''







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







							__UpperCAmelCase		:       WavaVecaForPreTraining
							__UpperCAmelCase		:       WavaVecaFeatureExtractor
							__UpperCAmelCase		:       Union[bool, str]							 ="longest"
							__UpperCAmelCase		:       Optional[int]							 =None
							__UpperCAmelCase		:       Optional[int]							 =None

							def __call__(	self       ,  __a      ):
										# reformat list to dict and set to pytorch format
										__lowerCAmelCase							       =     self.feature_extractor.pad(
										    __a       ,  max_length=self.max_length       ,  padding=self.padding       ,  pad_to_multiple_of=self.pad_to_multiple_of       ,  return_tensors="pt"       ,  )
										__lowerCAmelCase							       =     self.model._get_feat_extract_output_lengths(batch["input_values"].shape[-1]      )

										__lowerCAmelCase							       =     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
													__lowerCAmelCase							       =     self.model._get_feat_extract_output_lengths(batch["attention_mask"].sum(-1      )      ).to(
													    torch.long      )

													__lowerCAmelCase							       =     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
													__lowerCAmelCase							       =     1
													__lowerCAmelCase							       =     attention_mask.flip([-1]      ).cumsum(-1      ).flip([-1]      ).bool()

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

										return batch
class     _UpperCamelCase    (  lowerCAmelCase__						):
							'''simple docstring'''







							def __init__(	self       ,  *__a       ,  __a=1       ,  __a=0       ,  __a=1.0       ,  **__a      ):
										super().__init__(*__a       ,  **__a      )
										__lowerCAmelCase							       =     0
										__lowerCAmelCase							       =     max_gumbel_temp
										__lowerCAmelCase							       =     min_gumbel_temp
										__lowerCAmelCase							       =     gumbel_temp_decay



							def      snake_case							(	self       ,  __a       ,  __a      ):
										model.train()
										__lowerCAmelCase							       =     self._prepare_inputs(__a      )

										if self.use_amp:
													with autocast():
																__lowerCAmelCase							       =     self.compute_loss(__a       ,  __a      )
										else:
													__lowerCAmelCase							       =     self.compute_loss(__a       ,  __a      )

										if self.args.n_gpu > 1 or self.deepspeed:
													if model.module.config.ctc_loss_reduction == "mean":
																__lowerCAmelCase							       =     loss.mean()
													elif model.module.config.ctc_loss_reduction == "sum":
																__lowerCAmelCase							       =     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:
													__lowerCAmelCase							       =     loss / self.args.gradient_accumulation_steps

										if self.use_amp:
													self.scaler.scale(__a      ).backward()
										elif self.use_apex:
													with amp.scale_loss(__a       ,  self.optimizer      ) as scaled_loss:
																scaled_loss.backward()
										elif self.deepspeed:
													self.deepspeed.backward(__a      )
										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 _lowerCamelCase      (						):

			'''simple docstring'''




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

			__lowerCAmelCase       ,      __lowerCAmelCase       ,      __lowerCAmelCase							       =     parser.parse_args_into_dataclasses()
			configure_logger(_UpperCamelCase       ,					_UpperCamelCase )

			# Downloading and loading a dataset from the hub.
			__lowerCAmelCase							       =     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"
						__lowerCAmelCase							       =     DatasetDict()
						__lowerCAmelCase							       =     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       ,					)
						__lowerCAmelCase							       =     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"
						__lowerCAmelCase							       =     DatasetDict()
						__lowerCAmelCase							       =     load_dataset(
						    data_args.dataset_name       ,					data_args.dataset_config_name       ,					split="validation"       ,					cache_dir=model_args.cache_dir       ,					)
						__lowerCAmelCase							       =     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
			__lowerCAmelCase							       =     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
						__lowerCAmelCase       ,      __lowerCAmelCase							       =     librosa.load(batch[data_args.speech_file_column]       ,					sr=feature_extractor.sampling_rate )
						return batch

			# load audio files into numpy arrays
			__lowerCAmelCase							       =     datasets.map(
			    _UpperCamelCase       ,					num_proc=data_args.preprocessing_num_workers       ,					remove_columns=datasets["train"].column_names )

			# filter audio files that are too long
			__lowerCAmelCase							       =     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`
			__lowerCAmelCase							       =     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
			__lowerCAmelCase							       =     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'" )

			__lowerCAmelCase							       =     WavaVecaForPreTraining(_UpperCamelCase )

			__lowerCAmelCase							       =     DataCollatorForWavaVecaPretraining(model=_UpperCamelCase       ,					feature_extractor=_UpperCamelCase )

			__lowerCAmelCase							       =     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()




