
"""simple docstring"""




import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


snake_case    =		logging.getLogger(__name__)

require_version('pytorch_lightning>=1.0.4')

snake_case    =		{
    'base': AutoModel,
    'sequence-classification': AutoModelForSequenceClassification,
    'question-answering': AutoModelForQuestionAnswering,
    'pretraining': AutoModelForPreTraining,
    'token-classification': AutoModelForTokenClassification,
    'language-modeling': AutoModelWithLMHead,
    'summarization': AutoModelForSeqaSeqLM,
    'translation': AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
snake_case    =		{
    'linear': get_linear_schedule_with_warmup,
    'cosine': get_cosine_schedule_with_warmup,
    'cosine_w_restarts': get_cosine_with_hard_restarts_schedule_with_warmup,
    'polynomial': get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
snake_case    =		sorted(arg_to_scheduler.keys())
snake_case    =		'{' + ', '.join(arg_to_scheduler_choices) + '}'




class      UpperCamelCase	(       pl.LightningModule      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	lowercase__=None		,	lowercase__="base"		,	lowercase__=None		,	lowercase__=None		,	lowercase__=None		,	**lowercase__		,	)    ->    List[Any]:
									"""simple docstring"""







									super().__init__()
									# TODO: move to self.save_hyperparameters()
									# self.save_hyperparameters()
									# can also expand arguments into trainer signature for easier reading

									self.save_hyperparameters(lowercase__			)
									SCREAMING_SNAKE_CASE				=	0
									SCREAMING_SNAKE_CASE				=	Path(self.hparams.output_dir			)
									SCREAMING_SNAKE_CASE				=	self.hparams.cache_dir if self.hparams.cache_dir else None
									if config is None:
														SCREAMING_SNAKE_CASE				=	AutoConfig.from_pretrained(
														    self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path		,	**({'num_labels': num_labels} if num_labels is not None else {})		,	cache_dir=lowercase__		,	**lowercase__		,	)
									else:
														SCREAMING_SNAKE_CASE				=	config

									SCREAMING_SNAKE_CASE				=	('encoder_layerdrop', 'decoder_layerdrop', 'dropout', 'attention_dropout')
									for p in extra_model_params:
														if getattr(self.hparams		,	lowercase__		,	lowercase__			):
																			assert hasattr(self.config		,	lowercase__			), f'''model config doesn\'t have a `{p}` attribute'''
																			setattr(self.config		,	lowercase__		,	getattr(self.hparams		,	lowercase__			)			)

									if tokenizer is None:
														SCREAMING_SNAKE_CASE				=	AutoTokenizer.from_pretrained(
														    self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path		,	cache_dir=lowercase__		,	)
									else:
														SCREAMING_SNAKE_CASE				=	tokenizer
									SCREAMING_SNAKE_CASE				=	MODEL_MODES[mode]
									if model is None:
														SCREAMING_SNAKE_CASE				=	self.model_type.from_pretrained(
														    self.hparams.model_name_or_path		,	from_tf=bool('.ckpt' in self.hparams.model_name_or_path			)		,	config=self.config		,	cache_dir=lowercase__		,	)
									else:
														SCREAMING_SNAKE_CASE				=	model


				def 							A					(				self		,	*lowercase__		,	**lowercase__			)    ->    List[Any]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.model_type.from_pretrained(*lowercase__		,	**lowercase__			)


				def 							A					(				self			)    ->    List[str]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	arg_to_scheduler[self.hparams.lr_scheduler]
									SCREAMING_SNAKE_CASE				=	get_schedule_func(
									    self.opt		,	num_warmup_steps=self.hparams.warmup_steps		,	num_training_steps=self.total_steps()			)
									SCREAMING_SNAKE_CASE				=	{'scheduler': scheduler, 'interval': 'step', 'frequency': 1}
									return scheduler


				def 							A					(				self			)    ->    List[str]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.model
									SCREAMING_SNAKE_CASE				=	['bias', 'LayerNorm.weight']
									SCREAMING_SNAKE_CASE				=	[
									    {
									        'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay			)],
									        'weight_decay': self.hparams.weight_decay,
									    },
									    {
									        'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay			)],
									        'weight_decay': 0.0,
									    },
									]
									if self.hparams.adafactor:
														SCREAMING_SNAKE_CASE				=	Adafactor(
														    lowercase__		,	lr=self.hparams.learning_rate		,	scale_parameter=lowercase__		,	relative_step=lowercase__			)

									else:
														SCREAMING_SNAKE_CASE				=	AdamW(
														    lowercase__		,	lr=self.hparams.learning_rate		,	eps=self.hparams.adam_epsilon			)
									SCREAMING_SNAKE_CASE				=	optimizer

									SCREAMING_SNAKE_CASE				=	self.get_lr_scheduler()

									return [optimizer], [scheduler]


				def 							A					(				self		,	lowercase__		,	lowercase__			)    ->    str:
									"""simple docstring"""







									return self.validation_step(lowercase__		,	lowercase__			)


				def 							A					(				self		,	lowercase__			)    ->    List[Any]:
									"""simple docstring"""







									return self.validation_end(lowercase__			)


				def 							A					(				self			)    ->    int:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	max(1		,	self.hparams.gpus			)  # TODO: consider num_tpu_cores
									SCREAMING_SNAKE_CASE				=	self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
									return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs


				def 							A					(				self		,	lowercase__			)    ->    Union[str, Any]:
									"""simple docstring"""







									if mode == "test":
														SCREAMING_SNAKE_CASE				=	len(self.test_dataloader().dataset			)
									else:
														SCREAMING_SNAKE_CASE				=	self.get_dataloader('train'		,	self.hparams.train_batch_size		,	shuffle=lowercase__			)
														SCREAMING_SNAKE_CASE				=	len(self.train_dataloader().dataset			)


				def 							A					(				self		,	lowercase__		,	lowercase__		,	lowercase__ = False			)    ->    List[str]:
									"""simple docstring"""







									raise NotImplementedError('You must implement this for your task'			)


				def 							A					(				self			)    ->    Dict:
									"""simple docstring"""







									return self.train_loader


				def 							A					(				self			)    ->    Union[str, Any]:
									"""simple docstring"""







									return self.get_dataloader('dev'		,	self.hparams.eval_batch_size		,	shuffle=lowercase__			)


				def 							A					(				self			)    ->    Optional[Any]:
									"""simple docstring"""







									return self.get_dataloader('test'		,	self.hparams.eval_batch_size		,	shuffle=lowercase__			)


				def 							A					(				self		,	lowercase__			)    ->    Optional[int]:
									"""simple docstring"""







									return os.path.join(
									    self.hparams.data_dir		,	'cached_{}_{}_{}'.format(
									        lowercase__		,	list(filter(lowercase__		,	self.hparams.model_name_or_path.split('/'			)			)			).pop()		,	str(self.hparams.max_seq_length			)		,	)		,	)


				@pl.utilities.rank_zero_only
				def 							A					(				self		,	lowercase__			)    ->    None:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.output_dir.joinpath('best_tfmr'			)
									SCREAMING_SNAKE_CASE				=	self.step_count
									self.model.save_pretrained(lowercase__			)
									self.tokenizer.save_pretrained(lowercase__			)




				@staticmethod
				def 							A					(				lowercase__		,	lowercase__			)    ->    Tuple:
									"""simple docstring"""







									parser.add_argument(
									    '--model_name_or_path'		,	default=lowercase__		,	type=lowercase__		,	required=lowercase__		,	help='Path to pretrained model or model identifier from huggingface.co/models'		,	)
									parser.add_argument(
									    '--config_name'		,	default=''		,	type=lowercase__		,	help='Pretrained config name or path if not the same as model_name'			)
									parser.add_argument(
									    '--tokenizer_name'		,	default=lowercase__		,	type=lowercase__		,	help='Pretrained tokenizer name or path if not the same as model_name'		,	)
									parser.add_argument(
									    '--cache_dir'		,	default=''		,	type=lowercase__		,	help='Where do you want to store the pre-trained models downloaded from huggingface.co'		,	)
									parser.add_argument(
									    '--encoder_layerdrop'		,	type=lowercase__		,	help='Encoder layer dropout probability (Optional). Goes into model.config'		,	)
									parser.add_argument(
									    '--decoder_layerdrop'		,	type=lowercase__		,	help='Decoder layer dropout probability (Optional). Goes into model.config'		,	)
									parser.add_argument(
									    '--dropout'		,	type=lowercase__		,	help='Dropout probability (Optional). Goes into model.config'		,	)
									parser.add_argument(
									    '--attention_dropout'		,	type=lowercase__		,	help='Attention dropout probability (Optional). Goes into model.config'		,	)
									parser.add_argument('--learning_rate'		,	default=5E-5		,	type=lowercase__		,	help='The initial learning rate for Adam.'			)
									parser.add_argument(
									    '--lr_scheduler'		,	default='linear'		,	choices=lowercase__		,	metavar=lowercase__		,	type=lowercase__		,	help='Learning rate scheduler'		,	)
									parser.add_argument('--weight_decay'		,	default=0.0		,	type=lowercase__		,	help='Weight decay if we apply some.'			)
									parser.add_argument('--adam_epsilon'		,	default=1E-8		,	type=lowercase__		,	help='Epsilon for Adam optimizer.'			)
									parser.add_argument('--warmup_steps'		,	default=0		,	type=lowercase__		,	help='Linear warmup over warmup_steps.'			)
									parser.add_argument('--num_workers'		,	default=4		,	type=lowercase__		,	help='kwarg passed to DataLoader'			)
									parser.add_argument('--num_train_epochs'		,	dest='max_epochs'		,	default=3		,	type=lowercase__			)
									parser.add_argument('--train_batch_size'		,	default=32		,	type=lowercase__			)
									parser.add_argument('--eval_batch_size'		,	default=32		,	type=lowercase__			)
									parser.add_argument('--adafactor'		,	action='store_true'			)






class      UpperCamelCase	(       pl.Callback      ):

				"""simple docstring"""



				def 							A					(				self		,	lowercase__		,	lowercase__			)    ->    Dict:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	trainer.lr_schedulers[0]['scheduler']
									SCREAMING_SNAKE_CASE				=	{f'''lr_group_{i}''': lr for i, lr in enumerate(lr_scheduler.get_lr()			)}
									pl_module.logger.log_metrics(lowercase__			)


				def 							A					(				self		,	lowercase__		,	lowercase__			)    ->    List[str]:
									"""simple docstring"""







									rank_zero_info('***** Validation results *****'			)
									SCREAMING_SNAKE_CASE				=	trainer.callback_metrics
									# Log results
									for key in sorted(lowercase__			):
														if key not in ["log", "progress_bar"]:
																			rank_zero_info('{} = {}\n'.format(lowercase__		,	str(metrics[key]			)			)			)




				def 							A					(				self		,	lowercase__		,	lowercase__			)    ->    Tuple:
									"""simple docstring"""







									rank_zero_info('***** Test results *****'			)
									SCREAMING_SNAKE_CASE				=	trainer.callback_metrics
									# Log and save results to file
									SCREAMING_SNAKE_CASE				=	os.path.join(pl_module.hparams.output_dir		,	'test_results.txt'			)
									with open(lowercase__		,	'w'			) as writer:
														for key in sorted(lowercase__			):
																			if key not in ["log", "progress_bar"]:
																								rank_zero_info('{} = {}\n'.format(lowercase__		,	str(metrics[key]			)			)			)
																								writer.write('{} = {}\n'.format(lowercase__		,	str(metrics[key]			)			)			)






def   UpperCamelCase_  (		SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			):
					#  To allow all pl args uncomment the following line
					#  parser = pl.Trainer.add_argparse_args(parser)
					parser.add_argument(
					    '--output_dir',     default=SCREAMING_SNAKE_CASE_,     type=SCREAMING_SNAKE_CASE_,     required=SCREAMING_SNAKE_CASE_,     help='The output directory where the model predictions and checkpoints will be written.',     )
					parser.add_argument(
					    '--fp16',     action='store_true',     help='Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit',     )

					parser.add_argument(
					    '--fp16_opt_level',     type=SCREAMING_SNAKE_CASE_,     default='O2',     help=(
					        'For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\'].'
					        'See details at https://nvidia.github.io/apex/amp.html'
					    ),     )
					parser.add_argument('--n_tpu_cores',     dest='tpu_cores',     type=SCREAMING_SNAKE_CASE_			)
					parser.add_argument('--max_grad_norm',     dest='gradient_clip_val',     default=1.0,     type=SCREAMING_SNAKE_CASE_,     help='Max gradient norm'			)
					parser.add_argument('--do_train',     action='store_true',     help='Whether to run training.'			)
					parser.add_argument('--do_predict',     action='store_true',     help='Whether to run predictions on the test set.'			)
					parser.add_argument(
					    '--gradient_accumulation_steps',     dest='accumulate_grad_batches',     type=SCREAMING_SNAKE_CASE_,     default=1,     help='Number of updates steps to accumulate before performing a backward/update pass.',     )
					parser.add_argument('--seed',     type=SCREAMING_SNAKE_CASE_,     default=4_2,     help='random seed for initialization'			)
					parser.add_argument(
					    '--data_dir',     default=SCREAMING_SNAKE_CASE_,     type=SCREAMING_SNAKE_CASE_,     required=SCREAMING_SNAKE_CASE_,     help='The input data dir. Should contain the training files for the CoNLL-2003 NER task.',     )



def   UpperCamelCase_  (		SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_=None,     SCREAMING_SNAKE_CASE_=True,     SCREAMING_SNAKE_CASE_=[],     SCREAMING_SNAKE_CASE_=None,     SCREAMING_SNAKE_CASE_=None,     **SCREAMING_SNAKE_CASE_,     ):
					pl.seed_everything(args.seed			)

					# init model
					SCREAMING_SNAKE_CASE				=	Path(model.hparams.output_dir			)
					odir.mkdir(exist_ok=SCREAMING_SNAKE_CASE_			)

					# add custom checkpoints
					if checkpoint_callback is None:
										SCREAMING_SNAKE_CASE				=	pl.callbacks.ModelCheckpoint(
										    filepath=args.output_dir,     prefix='checkpoint',     monitor='val_loss',     mode='min',     save_top_k=1			)
					if early_stopping_callback:
										extra_callbacks.append(SCREAMING_SNAKE_CASE_			)
					if logging_callback is None:
										SCREAMING_SNAKE_CASE				=	LoggingCallback()

					SCREAMING_SNAKE_CASE				=	{}

					# TODO: remove with PyTorch 1.6 since pl uses native amp
					if args.fpaa:
										SCREAMING_SNAKE_CASE				=	1_6
										SCREAMING_SNAKE_CASE				=	args.fpaa_opt_level

					if args.gpus > 1:
										SCREAMING_SNAKE_CASE				=	'ddp'

					SCREAMING_SNAKE_CASE				=	args.accumulate_grad_batches
					SCREAMING_SNAKE_CASE				=	extra_train_kwargs.get('accelerator',     SCREAMING_SNAKE_CASE_			)
					SCREAMING_SNAKE_CASE				=	extra_train_kwargs.get('profiler',     SCREAMING_SNAKE_CASE_			)

					SCREAMING_SNAKE_CASE				=	pl.Trainer.from_argparse_args(
					    SCREAMING_SNAKE_CASE_,     weights_summary=SCREAMING_SNAKE_CASE_,     callbacks=[logging_callback] + extra_callbacks,     logger=SCREAMING_SNAKE_CASE_,     checkpoint_callback=SCREAMING_SNAKE_CASE_,     **SCREAMING_SNAKE_CASE_,     )

					if args.do_train:
										trainer.fit(SCREAMING_SNAKE_CASE_			)

					return trainer






'''simple docstring'''


from typing import List

from packaging import version
from sklearn.metrics import fa_score

import datasets
from datasets.config import PY_VERSION


if PY_VERSION < version.parse('3.8'):
				import importlib_metadata
else:
				import importlib.metadata as importlib_metadata


# TODO(Patrick/Anton)
_snake_case      :      Optional[int]   							=		'\\n'

_snake_case      :      Optional[Any]   							=		'\\n    XTREME-S is a benchmark to evaluate universal cross-lingual speech representations in many languages.\n    XTREME-S covers four task families: speech recognition, classification, speech-to-text translation and retrieval.\n'

_snake_case      :      Union[str, Any]   							=		'\nCompute XTREME-S evaluation metric associated to each XTREME-S dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    bleu_kwargs: optional dict of keywords to be passed when computing \'bleu\'.\n        Keywords include Dict can be one of \'smooth_method\', \'smooth_value\', \'force\', \'lowercase\',\n        \'tokenize\', \'use_effective_order\'.\n    wer_kwargs: optional dict of keywords to be passed when computing \'wer\' and \'cer\'.\n        Keywords include \'concatenate_texts\'.\nReturns: depending on the XTREME-S task, one or several of:\n    "accuracy": Accuracy - for \'fleurs-lang_id\', \'minds14\'\n    "f1": F1 score - for \'minds14\'\n    "wer": Word error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "cer": Character error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "bleu": BLEU score according to the `sacrebleu` metric - for \'covost2\'\nExamples:\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'mls\')  # \'mls\', \'voxpopuli\', \'fleurs-asr\' or \'babel\'\n    >>> references = ["it is sunny here", "paper and pen are essentials"]\n    >>> predictions = ["it\'s sunny", "paper pen are essential"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'wer\': 0.56, \'cer\': 0.27}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'covost2\')\n    >>> references = ["bonjour paris", "il est necessaire de faire du sport de temps en temp"]\n    >>> predictions = ["bonjour paris", "il est important de faire du sport souvent"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'bleu\': 31.65}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'fleurs-lang_id\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'accuracy\': 0.6}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'minds14\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'f1\': 0.58, \'accuracy\': 0.6}\n'

_snake_case      :      Dict   							=		['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
_snake_case      :      List[str]   							=		''

try:
				from jiwer import transforms as tr

				_snake_case      :      Optional[Any]   							=		True
except ImportError:
				_snake_case      :      Any   							=		False

if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):

				class 			A    (		tr.AbstractTransform    ):







											def __init__(  self       :  Any							,			lowerCAmelCase_       :  str = " "					)			->							Dict:


																		"""simple docstring"""


																		_a	     =				sentence_delimiter







											def    __lowerCAmelCase			(  self       :  Union[str, Any]							,			lowerCAmelCase_       :  str					)			->							Tuple:


																		"""simple docstring"""


																		return list(lowerCAmelCase_					)







											def    __lowerCAmelCase			(  self       :  Optional[int]							,			lowerCAmelCase_       :  List[str]					)			->							List[str]:


																		"""simple docstring"""


																		_a	     =				[]
																		for sent_idx, sentence in enumerate(lowerCAmelCase_					):
																									chars.extend(self.process_string(lowerCAmelCase_					)					)
																									if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(lowerCAmelCase_					) - 1:
																																chars.append(self.sentence_delimiter					)
																		return chars



				_snake_case      :      List[Any]   							=		tr.Compose(
				    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
				)
elif _jiwer_available:
				_snake_case      :      Dict   							=		tr.Compose(
				    [
				        tr.RemoveMultipleSpaces(),
				        tr.Strip(),
				        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
				        tr.ReduceToListOfListOfChars(),
				    ]
				)
else:
				_snake_case      :      Dict   							=		None
def 		snake_case_    (UpperCamelCase       :  Optional[Any] ,						UpperCamelCase       :  List[str]      ):





							'''simple docstring'''


							return float((preds == labels).mean()      )
def 		snake_case_    (UpperCamelCase       :  Optional[int] ,						UpperCamelCase       :  Optional[int]      ):





							'''simple docstring'''


							return {
							    "f1": float(fa_score(y_true=UpperCamelCase ,						y_pred=UpperCamelCase ,						average='''macro'''      )      ),
							    "accuracy": simple_accuracy(UpperCamelCase ,						UpperCamelCase      ),
							}
def 		snake_case_    (UpperCamelCase       :  Optional[int] ,						UpperCamelCase       :  Any ,						UpperCamelCase       :  Optional[Any]="exp" ,						UpperCamelCase       :  Optional[int]=None ,						UpperCamelCase       :  Tuple=False ,						UpperCamelCase       :  Dict=False ,						UpperCamelCase       :  List[str]=None ,						UpperCamelCase       :  Tuple=False ,						):





							'''simple docstring'''


							_a	     =				[[label] for label in labels]
							_a	     =				list(UpperCamelCase      )
							try:
														import sacrebleu as scb
							except ImportError:
														raise ValueError(
														    '''sacrebleu has to be installed in order to apply the bleu metric for covost2.'''
														    '''You can install it via `pip install sacrebleu`.'''      )

							if version.parse(scb.__version__      ) < version.parse('''1.4.12'''      ):
														raise ImportWarning(
														    '''To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n'''
														    '''You can install it with `pip install "sacrebleu>=1.4.12"`.'''      )

							_a	     =				len(labels[0]      )
							if any(len(UpperCamelCase      ) != references_per_prediction for refs in labels      ):
														raise ValueError('''Sacrebleu requires the same number of references for each prediction'''      )
							_a	     =				[[refs[i] for refs in labels] for i in range(UpperCamelCase      )]
							_a	     =				scb.corpus_bleu(
							    UpperCamelCase ,						UpperCamelCase ,						smooth_method=UpperCamelCase ,						smooth_value=UpperCamelCase ,						force=UpperCamelCase ,						lowercase=UpperCamelCase ,						use_effective_order=UpperCamelCase ,						**({'''tokenize''': tokenize} if tokenize else {}) ,						)
							return {"bleu": output.score}
def 		snake_case_    (UpperCamelCase       :  Optional[Any] ,						UpperCamelCase       :  Dict ,						UpperCamelCase       :  str ,						UpperCamelCase       :  List[Any]      ):





							'''simple docstring'''


							try:
														from jiwer import compute_measures
							except ImportError:
														raise ValueError(
														    f'jiwer has to be installed in order to apply the wer metric for {config_name}.'
														    '''You can install it via `pip install jiwer`.'''      )

							if concatenate_texts:
														_a	     =				compute_measures(UpperCamelCase ,						UpperCamelCase      )['''wer''']

														_a	     =				compute_measures(UpperCamelCase ,						UpperCamelCase ,						truth_transform=UpperCamelCase ,						hypothesis_transform=UpperCamelCase      )['''wer''']
														return {"wer": wer, "cer": cer}
							else:

														def compute_score(UpperCamelCase       :  Tuple ,						UpperCamelCase       :  Optional[int] ,						UpperCamelCase       :  Dict="wer"      ):
																					_a	     =				0
																					_a	     =				0
																					for prediction, reference in zip(UpperCamelCase ,						UpperCamelCase      ):
																												if score_type == "wer":
																																			_a	     =				compute_measures(UpperCamelCase ,						UpperCamelCase      )
																												elif score_type == "cer":
																																			_a	     =				compute_measures(
																																			    UpperCamelCase ,						UpperCamelCase ,						truth_transform=UpperCamelCase ,						hypothesis_transform=UpperCamelCase      )
																												incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
																												total += measures["substitutions"] + measures["deletions"] + measures["hits"]
																					return incorrect / total

														return {"wer": compute_score(UpperCamelCase ,						UpperCamelCase ,						'''wer'''      ), "cer": compute_score(UpperCamelCase ,						UpperCamelCase ,						'''cer'''      )}

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION     ,_KWARGS_DESCRIPTION    )
class 			A    (		datasets.Metric    ):







							def    __lowerCAmelCase			(  self       :  Tuple					)			->							Dict:


														"""simple docstring"""


														if self.config_name not in _CONFIG_NAMES:
																					raise KeyError(F'You should supply a configuration name selected in {_CONFIG_NAMES}'					)

														_a	     =				'''int64''' if self.config_name in ['''fleurs-lang_id''', '''minds14'''] else '''string'''

														return datasets.MetricInfo(
														    description=_DESCRIPTION							,			citation=_CITATION							,			inputs_description=_KWARGS_DESCRIPTION							,			features=datasets.Features(
														        {'''predictions''': datasets.Value(lowerCAmelCase_					), '''references''': datasets.Value(lowerCAmelCase_					)}					)							,			codebase_urls=[]							,			reference_urls=[]							,			format='''numpy'''							,			)







							def    __lowerCAmelCase			(  self       :  Optional[int]							,			lowerCAmelCase_       :  Union[str, Any]							,			lowerCAmelCase_       :  Optional[Any]							,			lowerCAmelCase_       :  List[Any]=None							,			lowerCAmelCase_       :  int=None					)			->							Tuple:


														"""simple docstring"""


														_a	     =				bleu_kwargs if bleu_kwargs is not None else {}
														_a	     =				wer_kwargs if wer_kwargs is not None else {}

														if self.config_name == "fleurs-lang_id":
																					return {"accuracy": simple_accuracy(lowerCAmelCase_							,			lowerCAmelCase_					)}
														elif self.config_name == "minds14":
																					return fa_and_simple_accuracy(lowerCAmelCase_							,			lowerCAmelCase_					)
														elif self.config_name == "covost2":
																					_a	     =				bleu_kwargs.pop('''smooth_method'''							,			'''exp'''					)
																					_a	     =				bleu_kwargs.pop('''smooth_value'''							,			lowerCAmelCase_					)
																					_a	     =				bleu_kwargs.pop('''force'''							,			lowerCAmelCase_					)
																					_a	     =				bleu_kwargs.pop('''lowercase'''							,			lowerCAmelCase_					)
																					_a	     =				bleu_kwargs.pop('''tokenize'''							,			lowerCAmelCase_					)
																					_a	     =				bleu_kwargs.pop('''use_effective_order'''							,			lowerCAmelCase_					)
																					return bleu(
																					    preds=lowerCAmelCase_							,			labels=lowerCAmelCase_							,			smooth_method=lowerCAmelCase_							,			smooth_value=lowerCAmelCase_							,			force=lowerCAmelCase_							,			lowercase=lowerCAmelCase_							,			tokenize=lowerCAmelCase_							,			use_effective_order=lowerCAmelCase_							,			)
														elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
																					_a	     =				wer_kwargs.pop('''concatenate_texts'''							,			lowerCAmelCase_					)
																					return wer_and_cer(lowerCAmelCase_							,			lowerCAmelCase_							,			lowerCAmelCase_							,			self.config_name					)
														else:
																					raise KeyError(F'You should supply a configuration name selected in {_CONFIG_NAMES}'					)

