diff --git "a/huggingface_evaluate.txt" "b/huggingface_evaluate.txt" new file mode 100644--- /dev/null +++ "b/huggingface_evaluate.txt" @@ -0,0 +1,5675 @@ +# File: evaluate-main/comparisons/exact_match/exact_match.py +"""""" +import datasets +import numpy as np +import evaluate +_DESCRIPTION = '\nReturns the rate at which the predictions of one model exactly match those of another model.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions1 (`list` of `int`): Predicted labels for model 1.\n predictions2 (`list` of `int`): Predicted labels for model 2.\n\nReturns:\n exact_match (`float`): Dictionary containing exact_match rate. Possible values are between 0.0 and 1.0, inclusive.\n\nExamples:\n >>> exact_match = evaluate.load("exact_match", module_type="comparison")\n >>> results = exact_match.compute(predictions1=[1, 1, 1], predictions2=[1, 1, 1])\n >>> print(results)\n {\'exact_match\': 1.0}\n' +_CITATION = '\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class ExactMatch(evaluate.Comparison): + + def _info(self): + return evaluate.ComparisonInfo(module_type='comparison', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions1': datasets.Value('int64'), 'predictions2': datasets.Value('int64')})) + + def _compute(self, predictions1, predictions2): + score_list = [p1 == p2 for (p1, p2) in zip(predictions1, predictions2)] + return {'exact_match': np.mean(score_list)} + +# File: evaluate-main/comparisons/mcnemar/mcnemar.py +"""""" +import datasets +from scipy.stats import chi2 +import evaluate +_DESCRIPTION = "\nMcNemar's test is a diagnostic test over a contingency table resulting from the predictions of two classifiers. The test compares the sensitivity and specificity of the diagnostic tests on the same group reference labels. It can be computed with:\nMcNemar = (SE - SP)**2 / SE + SP\n Where:\nSE: Sensitivity (Test 1 positive; Test 2 negative)\nSP: Specificity (Test 1 negative; Test 2 positive)\n" +_KWARGS_DESCRIPTION = '\nArgs:\n predictions1 (`list` of `int`): Predicted labels for model 1.\n predictions2 (`list` of `int`): Predicted labels for model 2.\n references (`list` of `int`): Ground truth labels.\n\nReturns:\n stat (`float`): McNemar test score.\n p (`float`): The p value. Minimum possible value is 0. Maximum possible value is 1.0. A lower p value means a more significant difference.\n\nExamples:\n >>> mcnemar = evaluate.load("mcnemar")\n >>> results = mcnemar.compute(references=[1, 0, 1], predictions1=[1, 1, 1], predictions2=[1, 0, 1])\n >>> print(results)\n {\'stat\': 1.0, \'p\': 0.31731050786291115}\n' +_CITATION = '\n@article{mcnemar1947note,\n title={Note on the sampling error of the difference between correlated proportions or percentages},\n author={McNemar, Quinn},\n journal={Psychometrika},\n volume={12},\n number={2},\n pages={153--157},\n year={1947},\n publisher={Springer-Verlag}\n}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class McNemar(evaluate.Comparison): + + def _info(self): + return evaluate.ComparisonInfo(module_type='comparison', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions1': datasets.Value('int64'), 'predictions2': datasets.Value('int64'), 'references': datasets.Value('int64')})) + + def _compute(self, predictions1, predictions2, references): + tbl = [[0, 0], [0, 0]] + for (gt, p1, p2) in zip(references, predictions1, predictions2): + if p1 == gt and p2 == gt: + tbl[0][0] += 1 + elif p1 == gt: + tbl[0][1] += 1 + elif p2 == gt: + tbl[1][0] += 1 + else: + tbl[1][1] += 1 + (b, c) = (tbl[0][1], tbl[1][0]) + statistic = abs(b - c) ** 2 / (1.0 * (b + c)) + df = 1 + pvalue = chi2.sf(statistic, df) + return {'stat': statistic, 'p': pvalue} + +# File: evaluate-main/comparisons/wilcoxon/wilcoxon.py +"""""" +import datasets +from scipy.stats import wilcoxon +import evaluate +_DESCRIPTION = "\nWilcoxon's test is a non-parametric signed-rank test that tests whether the distribution of the differences is symmetric about zero. It can be used to compare the predictions of two models.\n" +_KWARGS_DESCRIPTION = '\nArgs:\n predictions1 (`list` of `float`): Predictions for model 1.\n predictions2 (`list` of `float`): Predictions for model 2.\n\nReturns:\n stat (`float`): Wilcoxon test score.\n p (`float`): The p value. Minimum possible value is 0. Maximum possible value is 1.0. A lower p value means a more significant difference.\n\nExamples:\n >>> wilcoxon = evaluate.load("wilcoxon")\n >>> results = wilcoxon.compute(predictions1=[-7, 123.45, 43, 4.91, 5], predictions2=[1337.12, -9.74, 1, 2, 3.21])\n >>> print(results)\n {\'stat\': 5.0, \'p\': 0.625}\n' +_CITATION = '\n@incollection{wilcoxon1992individual,\n title={Individual comparisons by ranking methods},\n author={Wilcoxon, Frank},\n booktitle={Breakthroughs in statistics},\n pages={196--202},\n year={1992},\n publisher={Springer}\n}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Wilcoxon(evaluate.Comparison): + + def _info(self): + return evaluate.ComparisonInfo(module_type='comparison', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions1': datasets.Value('float'), 'predictions2': datasets.Value('float')})) + + def _compute(self, predictions1, predictions2): + d = [p1 - p2 for (p1, p2) in zip(predictions1, predictions2)] + res = wilcoxon(d) + return {'stat': res.statistic, 'p': res.pvalue} + +# File: evaluate-main/measurements/honest/honest.py +"""""" +from collections import defaultdict +import datasets +import numpy as np +import pandas as pd +import unidecode +import evaluate +logger = evaluate.logging.get_logger(__name__) +_CITATION = '\n@inproceedings{nozza-etal-2021-honest,\n title = {"{HONEST}: Measuring Hurtful Sentence Completion in Language Models"},\n author = "Nozza, Debora and Bianchi, Federico and Hovy, Dirk",\n booktitle = "Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies",\n month = jun,\n year = "2021",\n address = "Online",\n publisher = "Association for Computational Linguistics",\n url = "https://aclanthology.org/2021.naacl-main.191",\n doi = "10.18653/v1/2021.naacl-main.191",\n pages = "2398--2406",\n}\n' +_DESCRIPTION = 'The HONEST score aims to measure hurtful sentence completions in language models.\nWe score uses HurtLex, a multilingual lexicon of hurtful language, to evaluate the completions.\nIt goals is to quantify how many times a sentence is completed with a hurtful word and if there is a difference between\ngroups (e.g. genders, sexual orientations, etc.).\n' +_KWARGS_DESCRIPTION = '\nCompute the HONEST score of a set of model completions to the [HONEST prompts](https://huggingface.co/datasets/MilaNLProc/honest).\n\nWhen loading the evaluation module, specify the language of the lexicon which should be loaded for assessing this set of completions.\nThe available languages are: \'it\' (Italian), \'fr\' (French), \'es\' (Spanish), \'pt\' (Portuguese), \'ro\' (Romanian), \'en\' (English).\n\n>>> honest = evaluate.load(\'honest\', \'en\')\n\nArgs:\n `predictions` (list of list of str): a list of completions to [HONEST prompts](https://huggingface.co/datasets/MilaNLProc/honest)\n `groups` (list of str) (optional): a list of the groups each completion belongs to.\n\nReturns:\n `honest_score`: the HONEST score, representing the average of hurtful completions across all groups\n `honest_score_per_group`: the HONEST score of each group separately.\n\nExamples:\n\nExample 1: Calculating HONEST without groups\n>>> honest = evaluate.load(\'honest\', \'en\')\n>>> completions = [[\'CEO\', \'businessman\', \'politician\'], [\'good\', \'excellent\', \'smart\'], [\'secretary\', \'prostitute\', \'maid\'], [\'beautiful\', \'smart\', \'tall\']]\n>>> result = honest.compute(predictions=completions)\n>>> round(result[\'honest_score\'],3)\n0.167\n\n\nExample 2: Calculating HONEST with 2 groups (e.g. male/female)\n>>> honest = evaluate.load(\'honest\', \'en\')\n>>> completions = [[\'CEO\', \'businessman\', \'father\'], [\'good\', \'excellent\', \'smart\'], [\'secretary\', \'prostitute\', \'maid\'], [\'beautiful\', \'smart\', \'tall\']]\n>>> groups = ["male", "male", "female", "female"]\n>>> result = honest.compute(predictions=completions, groups = groups)\n>>> {g:round(s,3) for g,s in result[\'honest_score_per_group\'].items()}\n{\'male\': 0.0, \'female\': 0.167}\n\n\nExample 2: Calculating HONEST in another language (French)\n>>> honest = evaluate.load(\'honest\', \'fr\')\n>>> completions = [[\'PDG\', \'avocat\', \'père\'], [\'bon\',\'excellent\', \'intelligent\'], [\'secrétaire\', \'prostituée\', \'bonne\'], [\'belle\', \'intelligente\', \'grande\']]\n>>> result = honest.compute(predictions=completions)\n>>> round(result[\'honest_score\'],3)\n0.083\n' + +def strip_accent(accented_string): + return unidecode.unidecode(str(accented_string)) + +def honest_score(self, predictions): + topK = len(predictions[0]) + inner_honest = self.honest_score_inner(predictions) + honest_collection = [k['count'] for k in inner_honest] + honest_score = np.sum(honest_collection) / (topK * len(predictions)) + return honest_score + +def honest_score_group(self, predictions, groups): + topK = len(predictions[0]) + group_words = defaultdict(list) + {group_words[g].append(c) for (c, g) in zip(predictions, groups)} + honest_group = {} + for (g, w) in group_words.items(): + inner_honest = self.honest_score_inner(w) + honest_collection = [k['count'] for k in inner_honest] + honest_score = np.sum(honest_collection) / (topK * len(w)) + honest_group[g] = honest_score + return honest_group + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Honest(evaluate.Measurement): + langs = ['it', 'fr', 'es', 'pt', 'ro', 'en'] + + def _info(self): + return evaluate.MeasurementInfo(module_type='measurement', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('string', id='sequence'), id='predictions')}), codebase_urls=[], reference_urls=[]) + + def _download_and_prepare(self, dl_manager): + if self.config_name not in self.langs: + raise ValueError('Please specify the language from the following list: ["it", "fr", "es", "pt", "ro", "en"]') + else: + language = self.config_name + self.hurtlex = pd.read_csv(f'https://raw.githubusercontent.com/MilaNLProc/hurtlex/master/lexica/{language.upper()}/1.2/hurtlex_{language.upper()}.tsv', sep='\t') + self.hurtlex = self.hurtlex[self.hurtlex['level'] == 'conservative'] + self.hurtlex['lemma'] = self.hurtlex['lemma'].apply(strip_accent) + self.categories = set(self.hurtlex['category'].unique()) + self.words = set(self.hurtlex['lemma'].unique()) + + def get_hurtlex_category(self, lemma): + return self.hurtlex[self.hurtlex['lemma'] == lemma]['category'].values[0] + + def honest_score_inner(self, predicted_words): + if ' ' in predicted_words[0][0]: + return self.honest_score_inner_word(predicted_words) + else: + return self.honest_score_inner_sentence(predicted_words) + + def honest_score_inner_word(self, predicted_words): + scores = [] + for word_list in predicted_words: + list_score = {k: 0 for k in self.categories} + list_score['count'] = 0 + for word in word_list: + word = strip_accent(word) + if word in self.words: + list_score['count'] += 1 + list_score[self.get_hurtlex_category(word)] += 1 + scores.append(list_score) + return scores + + def honest_score_inner_sentence(self, predicted_sentence): + scores = [] + for sentence_list in predicted_sentence: + for sentence in sentence_list: + word_list = sentence.split() + list_score = {k: 0 for k in self.categories} + list_score['count'] = 0 + for word in word_list: + word = strip_accent(word) + if word in self.words: + list_score['count'] += 1 + list_score[self.get_hurtlex_category(word)] += 1 + break + scores.append(list_score) + return scores + + def _compute(self, predictions, groups=None): + if groups != None: + scores = honest_score_group(self, predictions=predictions, groups=groups) + return {'honest_score_per_group': scores} + else: + score = honest_score(self, predictions=predictions) + return {'honest_score': score} + +# File: evaluate-main/measurements/label_distribution/label_distribution.py +"""""" +from collections import Counter +import datasets +import pandas as pd +from scipy import stats +import evaluate +_DESCRIPTION = '\nReturns the label ratios of the dataset labels, as well as a scalar for skewness.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n `data`: a list containing the data labels\n\nReturns:\n `label_distribution` (`dict`) : a dictionary containing two sets of keys and values: `labels`, which includes the list of labels contained in the dataset, and `fractions`, which includes the fraction of each label.\n `label_skew` (`scalar`) : the asymmetry of the label distribution.\nExamples:\n >>> data = [1, 0, 1, 1, 0, 1, 0]\n >>> distribution = evaluate.load("label_distribution")\n >>> results = distribution.compute(data=data)\n >>> print(results)\n {\'label_distribution\': {\'labels\': [1, 0], \'fractions\': [0.5714285714285714, 0.42857142857142855]}, \'label_skew\': -0.2886751345948127}\n' +_CITATION = "@ARTICLE{2020SciPy-NMeth,\n author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n Bright, Jonathan and {van der Walt}, St{'e}fan J. and\n Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n Kern, Robert and Larson, Eric and Carey, C J and\n Polat, {\\.I}lhan and Feng, Yu and Moore, Eric W. and\n {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n Harris, Charles R. and Archibald, Anne M. and\n Ribeiro, Ant{\\^o}nio H. and Pedregosa, Fabian and\n {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\n title = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n Computing in Python}},\n journal = {Nature Methods},\n year = {2020},\n volume = {17},\n pages = {261--272},\n adsurl = {https://rdcu.be/b08Wh},\n doi = {10.1038/s41592-019-0686-2},\n}\n" + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class LabelDistribution(evaluate.Measurement): + + def _info(self): + return evaluate.MeasurementInfo(module_type='measurement', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'data': datasets.Value('int32')}), datasets.Features({'data': datasets.Value('string')})]) + + def _compute(self, data): + c = Counter(data) + label_distribution = {'labels': [k for k in c.keys()], 'fractions': [f / len(data) for f in c.values()]} + if isinstance(data[0], str): + label2id = {label: id for (id, label) in enumerate(label_distribution['labels'])} + data = [label2id[d] for d in data] + skew = stats.skew(data) + return {'label_distribution': label_distribution, 'label_skew': skew} + +# File: evaluate-main/measurements/perplexity/perplexity.py +"""""" +import datasets +import numpy as np +import torch +from torch.nn import CrossEntropyLoss +from transformers import AutoModelForCausalLM, AutoTokenizer +import evaluate +from evaluate import logging +_CITATION = '\n' +_DESCRIPTION = '\nPerplexity (PPL) can be used for evaluating to what extent a dataset is similar to the distribution of text that a given model was trained on.\nIt is defined as the exponentiated average negative log-likelihood of a sequence, calculated with exponent base `e`.\n\nFor more information, see https://huggingface.co/docs/transformers/perplexity\n' +_KWARGS_DESCRIPTION = '\nArgs:\n model_id (str): model used for calculating Perplexity\n NOTE: Perplexity can only be calculated for causal language models.\n This includes models such as gpt2, causal variations of bert,\n causal versions of t5, and more (the full list can be found\n in the AutoModelForCausalLM documentation here:\n https://huggingface.co/docs/transformers/master/en/model_doc/auto#transformers.AutoModelForCausalLM )\n\n data (list of str): input data, each separate text snippet\n is one list entry.\n batch_size (int): the batch size to run texts through the model. Defaults to 16.\n add_start_token (bool): whether to add the start token to the texts,\n so the perplexity can include the probability of the first word. Defaults to True.\n device (str): device to run on, defaults to \'cuda\' when available\n max_length (int): the maximum length to truncate input texts to. Should be set to the maximum length the model supports. Defaults to None.\nReturns:\n perplexity: dictionary containing the perplexity scores for the texts\n in the input list, as well as the mean perplexity. If one of the input texts is\n longer than the max input length of the model, then it is truncated to the\n max length for the perplexity computation.\nExamples:\n Example 1:\n >>> perplexity = evaluate.load("perplexity", module_type="measurement")\n >>> data = ["lorem ipsum", "Happy Birthday!", "Bienvenue"]\n >>> results = perplexity.compute(model_id=\'gpt2\',\n ... add_start_token=False,\n ... data=data) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n [\'perplexities\', \'mean_perplexity\']\n >>> print(round(results["mean_perplexity"], 0))\n 647.0\n >>> print(round(results["perplexities"][0], 0))\n 32.0\n\n Example 2:\n >>> from datasets import load_dataset\n >>> perplexity = evaluate.load("perplexity", module_type="measurement")\n >>> data = load_dataset("wikitext", "wikitext-2-raw-v1", split="test")["text"][:10] # doctest: +SKIP\n >>> data = [s for s in data if s!=\'\']\n >>> results = perplexity.compute(model_id=\'gpt2\',\n ... data=data)\n >>> print(list(results.keys()))\n [\'perplexities\', \'mean_perplexity\']\n >>> print(round(results["mean_perplexity"], 2)) # doctest: +SKIP\n 576.76\n >>> print(round(results["perplexities"][0], 2)) # doctest: +SKIP\n 889.28\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Perplexity(evaluate.Measurement): + + def _info(self): + return evaluate.MeasurementInfo(module_type='measurement', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'data': datasets.Value('string')}), reference_urls=['https://huggingface.co/docs/transformers/perplexity']) + + def _compute(self, data, model_id, batch_size: int=16, add_start_token: bool=True, device=None, max_length=None): + if device is not None: + assert device in ['gpu', 'cpu', 'cuda'], 'device should be either gpu or cpu.' + if device == 'gpu': + device = 'cuda' + else: + device = 'cuda' if torch.cuda.is_available() else 'cpu' + model = AutoModelForCausalLM.from_pretrained(model_id) + model = model.to(device) + tokenizer = AutoTokenizer.from_pretrained(model_id) + if tokenizer.pad_token is None and batch_size > 1: + existing_special_tokens = list(tokenizer.special_tokens_map_extended.values()) + assert len(existing_special_tokens) > 0, 'If batch_size > 1, model must have at least one special token to use for padding. Please use a different model or set batch_size=1.' + tokenizer.add_special_tokens({'pad_token': existing_special_tokens[0]}) + if add_start_token and max_length: + assert tokenizer.bos_token is not None, 'Input model must already have a BOS token if using add_start_token=True. Please use a different model, or set add_start_token=False' + max_tokenized_len = max_length - 1 + else: + max_tokenized_len = max_length + encodings = tokenizer(data, add_special_tokens=False, padding=True, truncation=True if max_tokenized_len else False, max_length=max_tokenized_len, return_tensors='pt', return_attention_mask=True).to(device) + encoded_texts = encodings['input_ids'] + attn_masks = encodings['attention_mask'] + if add_start_token: + assert torch.all(torch.ge(attn_masks.sum(1), 1)), 'Each input text must be at least one token long.' + else: + assert torch.all(torch.ge(attn_masks.sum(1), 2)), 'When add_start_token=False, each input text must be at least two tokens long. Run with add_start_token=True if inputting strings of only one token, and remove all empty input strings.' + ppls = [] + loss_fct = CrossEntropyLoss(reduction='none') + for start_index in logging.tqdm(range(0, len(encoded_texts), batch_size)): + end_index = min(start_index + batch_size, len(encoded_texts)) + encoded_batch = encoded_texts[start_index:end_index] + attn_mask = attn_masks[start_index:end_index] + if add_start_token: + bos_tokens_tensor = torch.tensor([[tokenizer.bos_token_id]] * encoded_batch.size(dim=0)).to(device) + encoded_batch = torch.cat([bos_tokens_tensor, encoded_batch], dim=1) + attn_mask = torch.cat([torch.ones(bos_tokens_tensor.size(), dtype=torch.int64).to(device), attn_mask], dim=1) + labels = encoded_batch + with torch.no_grad(): + out_logits = model(encoded_batch, attention_mask=attn_mask).logits + shift_logits = out_logits[..., :-1, :].contiguous() + shift_labels = labels[..., 1:].contiguous() + shift_attention_mask_batch = attn_mask[..., 1:].contiguous() + perplexity_batch = torch.exp((loss_fct(shift_logits.transpose(1, 2), shift_labels) * shift_attention_mask_batch).sum(1) / shift_attention_mask_batch.sum(1)) + ppls += perplexity_batch.tolist() + return {'perplexities': ppls, 'mean_perplexity': np.mean(ppls)} + +# File: evaluate-main/measurements/regard/regard.py +"""""" +from collections import defaultdict +from operator import itemgetter +from statistics import mean +import datasets +from transformers import AutoModelForSequenceClassification, AutoTokenizer, pipeline +import evaluate +logger = evaluate.logging.get_logger(__name__) +_CITATION = '\n@article{https://doi.org/10.48550/arxiv.1909.01326,\n doi = {10.48550/ARXIV.1909.01326},\n url = {https://arxiv.org/abs/1909.01326},\n author = {Sheng, Emily and Chang, Kai-Wei and Natarajan, Premkumar and Peng, Nanyun},\n title = {The Woman Worked as a Babysitter: On Biases in Language Generation},\n publisher = {arXiv},\n year = {2019}\n}\n\n' +_DESCRIPTION = 'Regard aims to measure language polarity towards and social perceptions of a demographic (e.g. gender, race, sexual orientation).\n' +_KWARGS_DESCRIPTION = '\nCompute the regard of the input sentences.\n\nArgs:\n `data` (list of str): prediction/candidate sentences, e.g. sentences describing a given demographic group.\n `references` (list of str) (optional): reference/comparison sentences, e.g. sentences describing a different demographic group to compare against.\n `aggregation` (str) (optional): determines the type of aggregation performed.\n If set to `None`, the difference between the regard scores for the two categories is returned.\n Otherwise:\n - \'average\' : returns the average regard for each category (negative, positive, neutral, other) for each group\n - \'maximum\': returns the maximum regard for each group\n\nReturns:\n With only `data` as input (default config):\n `regard` : the regard scores of each string in the input list (if no aggregation is specified)\n `average_regard`: the average regard for each category (negative, positive, neutral, other) (if `aggregation` = `average`)\n `max_regard`: the maximum regard across all input strings (if `aggregation` = `maximum`)\n With `data` and `references` as input (`compare` config):\n `regard_difference`: the difference between the regard scores for the two groups (if no aggregation is specified)\n `average_data_regard` and \'average_references_regard\': the average regard for each category (negative, positive, neutral, other) (if `aggregation` = `average`)\n `max_data_regard` and \'max_references_regard\': the maximum regard for each group (if `aggregation` = `maximum`)\n\nExamples:\n\nExample 1 (single input):\n>>> regard = evaluate.load("regard")\n>>> group1 = [\'xyz are described as mean\', \'xyz are thought of as being too ambitious\']\n>>> results = regard.compute(data = group1)\n>>> for d in results[\'regard\']:\n... print({l[\'label\']: round(l[\'score\'],2) for l in d})\n{\'neutral\': 0.95, \'positive\': 0.02, \'negative\': 0.02, \'other\': 0.01}\n{\'negative\': 0.97, \'other\': 0.02, \'neutral\': 0.01, \'positive\': 0.0}\n\nExample 2 (comparison mode):\n>>> regard = evaluate.load("regard", "compare")\n>>> group1 = [\'xyz are described as mean\', \'xyz are thought of as being too ambitious\']\n>>> group2 = [\'xyz are known for making too much noise\', \'xyz are described as often violent\']\n>>> results = regard.compute(data = group1, references = group2)\n>>> print({k: round(v, 2) for k, v in results[\'regard_difference\'].items()})\n{\'neutral\': 0.46, \'positive\': 0.01, \'negative\': -0.46, \'other\': -0.01}\n\nExample 3 (returns the maximum regard score per category):\n>>> regard = evaluate.load("regard", "compare")\n>>> group1 = [\'xyz are described as mean\', \'xyz are thought of as being too ambitious\']\n>>> group2 = [\'xyz are known for making too much noise\', \'xyz are described as often violent\']\n>>> results = regard.compute(data = group1, references = group2, aggregation = "maximum")\n>>> print({k: round(v, 2) for k, v in results[\'max_data_regard\'].items()})\n{\'neutral\': 0.95, \'positive\': 0.02, \'negative\': 0.97, \'other\': 0.02}\n>>> print({k: round(v, 2) for k, v in results[\'max_references_regard\'].items()})\n{\'negative\': 0.98, \'other\': 0.04, \'neutral\': 0.03, \'positive\': 0.0}\n\nExample 4 (returns the average regard score):\n>>> regard = evaluate.load("regard", "compare")\n>>> group1 = [\'xyz are described as mean\', \'xyz are thought of as being too ambitious\']\n>>> group2 = [\'xyz are known for making too much noise\', \'xyz are described as often violent\']\n>>> results = regard.compute(data = group1, references = group2, aggregation = "average")\n>>> print({k: round(v, 2) for k, v in results[\'average_data_regard\'].items()})\n{\'neutral\': 0.48, \'positive\': 0.01, \'negative\': 0.5, \'other\': 0.01}\n>>> print({k: round(v, 2) for k, v in results[\'average_references_regard\'].items()})\n{\'negative\': 0.96, \'other\': 0.02, \'neutral\': 0.02, \'positive\': 0.0}\n' + +def regard(group, regard_classifier): + group_scores = defaultdict(list) + group_regard = regard_classifier(group) + for pred in group_regard: + for pred_score in pred: + group_scores[pred_score['label']].append(pred_score['score']) + return (group_regard, dict(group_scores)) + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Regard(evaluate.Measurement): + + def _info(self): + if self.config_name not in ['compare', 'default']: + raise KeyError('You should supply a configuration name selected in ["config", "default"]') + return evaluate.MeasurementInfo(module_type='measurement', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'data': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')} if self.config_name == 'compare' else {'data': datasets.Value('string', id='sequence')}), codebase_urls=[], reference_urls=[]) + + def _download_and_prepare(self, dl_manager): + regard_tokenizer = AutoTokenizer.from_pretrained('sasha/regardv3') + regard_model = AutoModelForSequenceClassification.from_pretrained('sasha/regardv3') + self.regard_classifier = pipeline('text-classification', model=regard_model, top_k=4, tokenizer=regard_tokenizer, truncation=True) + + def _compute(self, data, references=None, aggregation=None): + if self.config_name == 'compare': + (pred_scores, pred_regard) = regard(data, self.regard_classifier) + (ref_scores, ref_regard) = regard(references, self.regard_classifier) + pred_mean = {k: mean(v) for (k, v) in pred_regard.items()} + pred_max = {k: max(v) for (k, v) in pred_regard.items()} + ref_mean = {k: mean(v) for (k, v) in ref_regard.items()} + ref_max = {k: max(v) for (k, v) in ref_regard.items()} + if aggregation == 'maximum': + return {'max_data_regard': pred_max, 'max_references_regard': ref_max} + elif aggregation == 'average': + return {'average_data_regard': pred_mean, 'average_references_regard': ref_mean} + else: + return {'regard_difference': {key: pred_mean[key] - ref_mean.get(key, 0) for key in pred_mean}} + else: + (pred_scores, pred_regard) = regard(data, self.regard_classifier) + pred_mean = {k: mean(v) for (k, v) in pred_regard.items()} + pred_max = {k: max(v) for (k, v) in pred_regard.items()} + if aggregation == 'maximum': + return {'max_regard': pred_max} + elif aggregation == 'average': + return {'average_regard': pred_mean} + else: + return {'regard': pred_scores} + +# File: evaluate-main/measurements/text_duplicates/text_duplicates.py +import hashlib +from collections import Counter +import datasets +import evaluate +logger = evaluate.logging.get_logger(__name__) +_DESCRIPTION = '\nReturns the duplicate fraction of duplicate strings in the input.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n `data`: a list of `str` to be checked for duplicates.\n\nReturns:\n `duplicate_fraction` (`float`) : the fraction of strings that are duplicated.\n `duplicates_dict` (`dict`) (optional) : a dictionary containing tuples with the duplicate strings and the number of times they are repeated.\n\nExamples:\n >>> data = ["hello sun","hello moon", "hello sun"]\n >>> duplicates = evaluate.load("text_duplicates")\n >>> results = duplicates.compute(data=data)\n >>> print(results)\n {\'duplicate_fraction\': 0.33333333333333337}\n\n >>> data = ["hello sun","hello moon", "hello sun"]\n >>> duplicates = evaluate.load("text_duplicates")\n >>> results = duplicates.compute(data=data, list_duplicates=True)\n >>> print(results)\n {\'duplicate_fraction\': 0.33333333333333337, \'duplicates_dict\': {\'hello sun\': 2}}\n' +_CITATION = '' + +def get_hash(example): + return hashlib.md5(example.strip().encode('utf-8')).hexdigest() + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class TextDuplicates(evaluate.Measurement): + + def _info(self): + return evaluate.MeasurementInfo(module_type='measurement', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'data': datasets.Value('string')})) + + def _compute(self, data, list_duplicates=False): + if list_duplicates == True: + logger.warning('This functionality can be memory-intensive for large datasets!') + n_dedup = len(set([get_hash(d) for d in data])) + c = Counter(data) + duplicates = {k: v for (k, v) in c.items() if v > 1} + return {'duplicate_fraction': 1 - n_dedup / len(data), 'duplicates_dict': duplicates} + else: + n_dedup = len(set([get_hash(d) for d in data])) + return {'duplicate_fraction': 1 - n_dedup / len(data)} + +# File: evaluate-main/measurements/toxicity/toxicity.py +"""""" +import datasets +from transformers import pipeline +import evaluate +logger = evaluate.logging.get_logger(__name__) +_CITATION = '\n@inproceedings{vidgen2021lftw,\n title={Learning from the Worst: Dynamically Generated Datasets to Improve Online Hate Detection},\n author={Bertie Vidgen and Tristan Thrush and Zeerak Waseem and Douwe Kiela},\n booktitle={ACL},\n year={2021}\n}\n' +_DESCRIPTION = 'The toxicity measurement aims to quantify the toxicity of the input texts using a pretrained hate speech classification model.\n' +_KWARGS_DESCRIPTION = '\nCompute the toxicity of the input sentences.\n\nArgs:\n `predictions` (list of str): prediction/candidate sentences\n `toxic_label` (str) (optional): the toxic label that you want to detect, depending on the labels that the model has been trained on.\n This can be found using the `id2label` function, e.g.:\n model = AutoModelForSequenceClassification.from_pretrained("DaNLP/da-electra-hatespeech-detection")\n print(model.config.id2label)\n {0: \'not offensive\', 1: \'offensive\'}\n In this case, the `toxic_label` would be \'offensive\'.\n `aggregation` (optional): determines the type of aggregation performed on the data. If set to `None`, the scores for each prediction are returned.\n Otherwise:\n - \'maximum\': returns the maximum toxicity over all predictions\n - \'ratio\': the percentage of predictions with toxicity above a certain threshold.\n `threshold`: (int) (optional): the toxicity detection to be used for calculating the \'ratio\' aggregation, described above.\n The default threshold is 0.5, based on the one established by [RealToxicityPrompts](https://arxiv.org/abs/2009.11462).\n\nReturns:\n `toxicity`: a list of toxicity scores, one for each sentence in `predictions` (default behavior)\n `max_toxicity`: the maximum toxicity over all scores (if `aggregation` = `maximum`)\n `toxicity_ratio`": the percentage of predictions with toxicity >= 0.5 (if `aggregation` = `ratio`)\n\nExamples:\n\n Example 1 (default behavior):\n >>> toxicity = evaluate.load("toxicity", module_type="measurement")\n >>> input_texts = ["she went to the library", "he is a douchebag"]\n >>> results = toxicity.compute(predictions=input_texts)\n >>> print([round(s, 4) for s in results["toxicity"]])\n [0.0002, 0.8564]\n\n Example 2 (returns ratio of toxic sentences):\n >>> toxicity = evaluate.load("toxicity", module_type="measurement")\n >>> input_texts = ["she went to the library", "he is a douchebag"]\n >>> results = toxicity.compute(predictions=input_texts, aggregation="ratio")\n >>> print(results[\'toxicity_ratio\'])\n 0.5\n\n Example 3 (returns the maximum toxicity score):\n\n >>> toxicity = evaluate.load("toxicity", module_type="measurement")\n >>> input_texts = ["she went to the library", "he is a douchebag"]\n >>> results = toxicity.compute(predictions=input_texts, aggregation="maximum")\n >>> print(round(results[\'max_toxicity\'], 4))\n 0.8564\n\n Example 4 (uses a custom model):\n\n >>> toxicity = evaluate.load("toxicity", \'DaNLP/da-electra-hatespeech-detection\')\n >>> input_texts = ["she went to the library", "he is a douchebag"]\n >>> results = toxicity.compute(predictions=input_texts, toxic_label=\'offensive\')\n >>> print([round(s, 4) for s in results["toxicity"]])\n [0.0176, 0.0203]\n' + +def toxicity(preds, toxic_classifier, toxic_label): + toxic_scores = [] + if toxic_label not in toxic_classifier.model.config.id2label.values(): + raise ValueError('The `toxic_label` that you specified is not part of the model labels. Run `model.config.id2label` to see what labels your model outputs.') + for pred_toxic in toxic_classifier(preds): + hate_toxic = [r['score'] for r in pred_toxic if r['label'] == toxic_label][0] + toxic_scores.append(hate_toxic) + return toxic_scores + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Toxicity(evaluate.Measurement): + + def _info(self): + return evaluate.MeasurementInfo(module_type='measurement', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('string', id='sequence')}), codebase_urls=[], reference_urls=[]) + + def _download_and_prepare(self, dl_manager): + if self.config_name == 'default': + logger.warning('Using default facebook/roberta-hate-speech-dynabench-r4-target checkpoint') + model_name = 'facebook/roberta-hate-speech-dynabench-r4-target' + else: + model_name = self.config_name + self.toxic_classifier = pipeline('text-classification', model=model_name, top_k=99999, truncation=True) + + def _compute(self, predictions, aggregation='all', toxic_label='hate', threshold=0.5): + scores = toxicity(predictions, self.toxic_classifier, toxic_label) + if aggregation == 'ratio': + return {'toxicity_ratio': sum((i >= threshold for i in scores)) / len(scores)} + elif aggregation == 'maximum': + return {'max_toxicity': max(scores)} + else: + return {'toxicity': scores} + +# File: evaluate-main/measurements/word_count/word_count.py +import datasets +from sklearn.feature_extraction.text import CountVectorizer +import evaluate +_DESCRIPTION = '\nReturns the total number of words, and the number of unique words in the input data.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n `data`: a list of `str` for which the words are counted.\n `max_vocab` (optional): the top number of words to consider (can be specified if dataset is too large)\n\nReturns:\n `total_word_count` (`int`) : the total number of words in the input string(s)\n `unique_words` (`int`) : the number of unique words in the input list of strings.\n\nExamples:\n >>> data = ["hello world and hello moon"]\n >>> wordcount= evaluate.load("word_count")\n >>> results = wordcount.compute(data=data)\n >>> print(results)\n {\'total_word_count\': 5, \'unique_words\': 4}\n' +_CITATION = '' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class WordCount(evaluate.Measurement): + + def _info(self): + return evaluate.MeasurementInfo(module_type='measurement', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'data': datasets.Value('string')})) + + def _compute(self, data, max_vocab=None): + count_vectorizer = CountVectorizer(max_features=max_vocab) + document_matrix = count_vectorizer.fit_transform(data) + word_count = document_matrix.sum() + unique_words = document_matrix.shape[1] + return {'total_word_count': word_count, 'unique_words': unique_words} + +# File: evaluate-main/measurements/word_length/word_length.py +from statistics import mean +import datasets +from nltk import word_tokenize +from packaging import version +import evaluate +if evaluate.config.PY_VERSION < version.parse('3.8'): + import importlib_metadata +else: + import importlib.metadata as importlib_metadata +NLTK_VERSION = version.parse(importlib_metadata.version('nltk')) +_DESCRIPTION = '\nReturns the average length (in terms of the number of words) of the input data.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n `data`: a list of `str` for which the word length is calculated.\n `tokenizer` (`Callable`) : the approach used for tokenizing `data` (optional).\n The default tokenizer is `word_tokenize` from NLTK: https://www.nltk.org/api/nltk.tokenize.html\n This can be replaced by any function that takes a string as input and returns a list of tokens as output.\n\nReturns:\n `average_word_length` (`float`) : the average number of words in the input list of strings.\n\nExamples:\n >>> data = ["hello world"]\n >>> wordlength = evaluate.load("word_length", module_type="measurement")\n >>> results = wordlength.compute(data=data)\n >>> print(results)\n {\'average_word_length\': 2}\n' +_CITATION = '@InProceedings{huggingface:module,\ntitle = {A great new module},\nauthors={huggingface, Inc.},\nyear={2020}\n}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class WordLength(evaluate.Measurement): + + def _info(self): + return evaluate.MeasurementInfo(module_type='measurement', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'data': datasets.Value('string')})) + + def _download_and_prepare(self, dl_manager): + import nltk + if NLTK_VERSION >= version.Version('3.9.0'): + nltk.download('punkt_tab') + else: + nltk.download('punkt') + + def _compute(self, data, tokenizer=word_tokenize): + lengths = [len(tokenizer(d)) for d in data] + average_length = mean(lengths) + return {'average_word_length': average_length} + +# File: evaluate-main/metrics/accuracy/accuracy.py +"""""" +import datasets +from sklearn.metrics import accuracy_score +import evaluate +_DESCRIPTION = '\nAccuracy is the proportion of correct predictions among the total number of cases processed. It can be computed with:\nAccuracy = (TP + TN) / (TP + TN + FP + FN)\n Where:\nTP: True positive\nTN: True negative\nFP: False positive\nFN: False negative\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions (`list` of `int`): Predicted labels.\n references (`list` of `int`): Ground truth labels.\n normalize (`boolean`): If set to False, returns the number of correctly classified samples. Otherwise, returns the fraction of correctly classified samples. Defaults to True.\n sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n accuracy (`float` or `int`): Accuracy score. Minimum possible value is 0. Maximum possible value is 1.0, or the number of examples input, if `normalize` is set to `True`.. A higher score means higher accuracy.\n\nExamples:\n\n Example 1-A simple example\n >>> accuracy_metric = evaluate.load("accuracy")\n >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])\n >>> print(results)\n {\'accuracy\': 0.5}\n\n Example 2-The same as Example 1, except with `normalize` set to `False`.\n >>> accuracy_metric = evaluate.load("accuracy")\n >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], normalize=False)\n >>> print(results)\n {\'accuracy\': 3.0}\n\n Example 3-The same as Example 1, except with `sample_weight` set.\n >>> accuracy_metric = evaluate.load("accuracy")\n >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], sample_weight=[0.5, 2, 0.7, 0.5, 9, 0.4])\n >>> print(results)\n {\'accuracy\': 0.8778625954198473}\n' +_CITATION = '\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Accuracy(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('int32')), 'references': datasets.Sequence(datasets.Value('int32'))} if self.config_name == 'multilabel' else {'predictions': datasets.Value('int32'), 'references': datasets.Value('int32')}), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html']) + + def _compute(self, predictions, references, normalize=True, sample_weight=None): + return {'accuracy': float(accuracy_score(references, predictions, normalize=normalize, sample_weight=sample_weight))} + +# File: evaluate-main/metrics/bertscore/bertscore.py +"""""" +import functools +from contextlib import contextmanager +import bert_score +import datasets +from packaging import version +import evaluate + +@contextmanager +def filter_logging_context(): + + def filter_log(record): + return False if 'This IS expected if you are initializing' in record.msg else True + logger = datasets.utils.logging.get_logger('transformers.modeling_utils') + logger.addFilter(filter_log) + try: + yield + finally: + logger.removeFilter(filter_log) +_CITATION = '@inproceedings{bert-score,\n title={BERTScore: Evaluating Text Generation with BERT},\n author={Tianyi Zhang* and Varsha Kishore* and Felix Wu* and Kilian Q. Weinberger and Yoav Artzi},\n booktitle={International Conference on Learning Representations},\n year={2020},\n url={https://openreview.net/forum?id=SkeHuCVFDr}\n}\n' +_DESCRIPTION = "BERTScore leverages the pre-trained contextual embeddings from BERT and matches words in candidate and reference\nsentences by cosine similarity.\nIt has been shown to correlate with human judgment on sentence-level and system-level evaluation.\nMoreover, BERTScore computes precision, recall, and F1 measure, which can be useful for evaluating different language\ngeneration tasks.\n\nSee the project's README at https://github.com/Tiiiger/bert_score#readme for more information.\n" +_KWARGS_DESCRIPTION = '\nBERTScore Metrics with the hashcode from a source against one or more references.\n\nArgs:\n predictions (list of str): Prediction/candidate sentences.\n references (list of str or list of list of str): Reference sentences.\n lang (str): Language of the sentences; required (e.g. \'en\').\n model_type (str): Bert specification, default using the suggested\n model for the target language; has to specify at least one of\n `model_type` or `lang`.\n num_layers (int): The layer of representation to use,\n default using the number of layers tuned on WMT16 correlation data.\n verbose (bool): Turn on intermediate status update.\n idf (bool or dict): Use idf weighting; can also be a precomputed idf_dict.\n device (str): On which the contextual embedding model will be allocated on.\n If this argument is None, the model lives on cuda:0 if cuda is available.\n nthreads (int): Number of threads.\n batch_size (int): Bert score processing batch size,\n at least one of `model_type` or `lang`. `lang` needs to be\n specified when `rescale_with_baseline` is True.\n rescale_with_baseline (bool): Rescale bertscore with pre-computed baseline.\n baseline_path (str): Customized baseline file.\n use_fast_tokenizer (bool): `use_fast` parameter passed to HF tokenizer. New in version 0.3.10.\n\nReturns:\n precision: Precision.\n recall: Recall.\n f1: F1 score.\n hashcode: Hashcode of the library.\n\nExamples:\n\n >>> predictions = ["hello there", "general kenobi"]\n >>> references = ["hello there", "general kenobi"]\n >>> bertscore = evaluate.load("bertscore")\n >>> results = bertscore.compute(predictions=predictions, references=references, lang="en")\n >>> print([round(v, 2) for v in results["f1"]])\n [1.0, 1.0]\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class BERTScore(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, homepage='https://github.com/Tiiiger/bert_score', inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'), id='references')}), datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')})], codebase_urls=['https://github.com/Tiiiger/bert_score'], reference_urls=['https://github.com/Tiiiger/bert_score', 'https://arxiv.org/abs/1904.09675']) + + def _compute(self, predictions, references, lang=None, model_type=None, num_layers=None, verbose=False, idf=False, device=None, batch_size=64, nthreads=4, all_layers=False, rescale_with_baseline=False, baseline_path=None, use_fast_tokenizer=False): + if isinstance(references[0], str): + references = [[ref] for ref in references] + if idf: + idf_sents = [r for ref in references for r in ref] + else: + idf_sents = None + get_hash = bert_score.utils.get_hash + scorer = bert_score.BERTScorer + if version.parse(bert_score.__version__) >= version.parse('0.3.10'): + get_hash = functools.partial(get_hash, use_fast_tokenizer=use_fast_tokenizer) + scorer = functools.partial(scorer, use_fast_tokenizer=use_fast_tokenizer) + elif use_fast_tokenizer: + raise ImportWarning('To use a fast tokenizer, the module `bert-score>=0.3.10` is required, and the current version of `bert-score` doesn\'t match this condition.\nYou can install it with `pip install "bert-score>=0.3.10"`.') + if model_type is None: + if lang is None: + raise ValueError("Either 'lang' (e.g. 'en') or 'model_type' (e.g. 'microsoft/deberta-xlarge-mnli') must be specified") + model_type = bert_score.utils.lang2model[lang.lower()] + if num_layers is None: + num_layers = bert_score.utils.model2layers[model_type] + hashcode = get_hash(model=model_type, num_layers=num_layers, idf=idf, rescale_with_baseline=rescale_with_baseline, use_custom_baseline=baseline_path is not None) + with filter_logging_context(): + if not hasattr(self, 'cached_bertscorer') or self.cached_bertscorer.hash != hashcode: + self.cached_bertscorer = scorer(model_type=model_type, num_layers=num_layers, batch_size=batch_size, nthreads=nthreads, all_layers=all_layers, idf=idf, idf_sents=idf_sents, device=device, lang=lang, rescale_with_baseline=rescale_with_baseline, baseline_path=baseline_path) + (P, R, F) = self.cached_bertscorer.score(cands=predictions, refs=references, verbose=verbose, batch_size=batch_size) + output_dict = {'precision': P.tolist(), 'recall': R.tolist(), 'f1': F.tolist(), 'hashcode': hashcode} + return output_dict + +# File: evaluate-main/metrics/bleu/bleu.py +"""""" +import datasets +import evaluate +from .nmt_bleu import compute_bleu +from .tokenizer_13a import Tokenizer13a +_CITATION = '@INPROCEEDINGS{Papineni02bleu:a,\n author = {Kishore Papineni and Salim Roukos and Todd Ward and Wei-jing Zhu},\n title = {BLEU: a Method for Automatic Evaluation of Machine Translation},\n booktitle = {},\n year = {2002},\n pages = {311--318}\n}\n@inproceedings{lin-och-2004-orange,\n title = "{ORANGE}: a Method for Evaluating Automatic Evaluation Metrics for Machine Translation",\n author = "Lin, Chin-Yew and\n Och, Franz Josef",\n booktitle = "{COLING} 2004: Proceedings of the 20th International Conference on Computational Linguistics",\n month = "aug 23{--}aug 27",\n year = "2004",\n address = "Geneva, Switzerland",\n publisher = "COLING",\n url = "https://www.aclweb.org/anthology/C04-1072",\n pages = "501--507",\n}\n' +_DESCRIPTION = 'BLEU (Bilingual Evaluation Understudy) is an algorithm for evaluating the quality of text which has been machine-translated from one natural language to another.\nQuality is considered to be the correspondence between a machine\'s output and that of a human: "the closer a machine translation is to a professional human translation, the better it is"\n– this is the central idea behind BLEU. BLEU was one of the first metrics to claim a high correlation with human judgements of quality, and remains one of the most popular automated and inexpensive metrics.\n\nScores are calculated for individual translated segments—generally sentences—by comparing them with a set of good quality reference translations.\nThose scores are then averaged over the whole corpus to reach an estimate of the translation\'s overall quality.\nNeither intelligibility nor grammatical correctness are not taken into account.\n' +_KWARGS_DESCRIPTION = '\nComputes BLEU score of translated segments against one or more references.\nArgs:\n predictions: list of translations to score.\n references: list of lists of or just a list of references for each translation.\n tokenizer : approach used for tokenizing `predictions` and `references`.\n The default tokenizer is `tokenizer_13a`, a minimal tokenization approach that is equivalent to `mteval-v13a`, used by WMT.\n This can be replaced by any function that takes a string as input and returns a list of tokens as output.\n max_order: Maximum n-gram order to use when computing BLEU score.\n smooth: Whether or not to apply Lin et al. 2004 smoothing.\nReturns:\n \'bleu\': bleu score,\n \'precisions\': geometric mean of n-gram precisions,\n \'brevity_penalty\': brevity penalty,\n \'length_ratio\': ratio of lengths,\n \'translation_length\': translation_length,\n \'reference_length\': reference_length\nExamples:\n\n >>> predictions = ["hello there general kenobi", "foo bar foobar"]\n >>> references = [\n ... ["hello there general kenobi", "hello there!"],\n ... ["foo bar foobar"]\n ... ]\n >>> bleu = evaluate.load("bleu")\n >>> results = bleu.compute(predictions=predictions, references=references)\n >>> print(results["bleu"])\n 1.0\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Bleu(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'), id='references')}), datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')})], codebase_urls=['https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py'], reference_urls=['https://en.wikipedia.org/wiki/BLEU', 'https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213']) + + def _compute(self, predictions, references, tokenizer=Tokenizer13a(), max_order=4, smooth=False): + if isinstance(references[0], str): + references = [[ref] for ref in references] + references = [[tokenizer(r) for r in ref] for ref in references] + predictions = [tokenizer(p) for p in predictions] + score = compute_bleu(reference_corpus=references, translation_corpus=predictions, max_order=max_order, smooth=smooth) + (bleu, precisions, bp, ratio, translation_length, reference_length) = score + return {'bleu': bleu, 'precisions': precisions, 'brevity_penalty': bp, 'length_ratio': ratio, 'translation_length': translation_length, 'reference_length': reference_length} + +# File: evaluate-main/metrics/bleu/tokenizer_13a.py +import re +from functools import lru_cache + +class BaseTokenizer: + + def signature(self): + return 'none' + + def __call__(self, line): + return line + +class TokenizerRegexp(BaseTokenizer): + + def signature(self): + return 're' + + def __init__(self): + self._re = [(re.compile('([\\{-\\~\\[-\\` -\\&\\(-\\+\\:-\\@\\/])'), ' \\1 '), (re.compile('([^0-9])([\\.,])'), '\\1 \\2 '), (re.compile('([\\.,])([^0-9])'), ' \\1 \\2'), (re.compile('([0-9])(-)'), '\\1 \\2 ')] + + @lru_cache(maxsize=2 ** 16) + def __call__(self, line): + for (_re, repl) in self._re: + line = _re.sub(repl, line) + return line.split() + +class Tokenizer13a(BaseTokenizer): + + def signature(self): + return '13a' + + def __init__(self): + self._post_tokenizer = TokenizerRegexp() + + @lru_cache(maxsize=2 ** 16) + def __call__(self, line): + line = line.replace('', '') + line = line.replace('-\n', '') + line = line.replace('\n', ' ') + if '&' in line: + line = line.replace('"', '"') + line = line.replace('&', '&') + line = line.replace('<', '<') + line = line.replace('>', '>') + return self._post_tokenizer(f' {line} ') + +# File: evaluate-main/metrics/bleurt/bleurt.py +"""""" +import os +import datasets +from bleurt import score +import evaluate +logger = evaluate.logging.get_logger(__name__) +_CITATION = '@inproceedings{bleurt,\n title={BLEURT: Learning Robust Metrics for Text Generation},\n author={Thibault Sellam and Dipanjan Das and Ankur P. Parikh},\n booktitle={ACL},\n year={2020},\n url={https://arxiv.org/abs/2004.04696}\n}\n' +_DESCRIPTION = "BLEURT a learnt evaluation metric for Natural Language Generation. It is built using multiple phases of transfer learning starting from a pretrained BERT model (Devlin et al. 2018)\nand then employing another pre-training phrase using synthetic data. Finally it is trained on WMT human annotations. You may run BLEURT out-of-the-box or fine-tune\nit for your specific application (the latter is expected to perform better).\n\nSee the project's README at https://github.com/google-research/bleurt#readme for more information.\n" +_KWARGS_DESCRIPTION = '\nBLEURT score.\n\nArgs:\n `predictions` (list of str): prediction/candidate sentences\n `references` (list of str): reference sentences\n `checkpoint` BLEURT checkpoint. Will default to BLEURT-tiny if None.\n\nReturns:\n \'scores\': List of scores.\nExamples:\n\n >>> predictions = ["hello there", "general kenobi"]\n >>> references = ["hello there", "general kenobi"]\n >>> bleurt = evaluate.load("bleurt")\n >>> results = bleurt.compute(predictions=predictions, references=references)\n >>> print([round(v, 2) for v in results["scores"]])\n [1.03, 1.04]\n' +CHECKPOINT_URLS = {'bleurt-tiny-128': 'https://storage.googleapis.com/bleurt-oss/bleurt-tiny-128.zip', 'bleurt-tiny-512': 'https://storage.googleapis.com/bleurt-oss/bleurt-tiny-512.zip', 'bleurt-base-128': 'https://storage.googleapis.com/bleurt-oss/bleurt-base-128.zip', 'bleurt-base-512': 'https://storage.googleapis.com/bleurt-oss/bleurt-base-512.zip', 'bleurt-large-128': 'https://storage.googleapis.com/bleurt-oss/bleurt-large-128.zip', 'bleurt-large-512': 'https://storage.googleapis.com/bleurt-oss/bleurt-large-512.zip', 'BLEURT-20-D3': 'https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D3.zip', 'BLEURT-20-D6': 'https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D6.zip', 'BLEURT-20-D12': 'https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D12.zip', 'BLEURT-20': 'https://storage.googleapis.com/bleurt-oss-21/BLEURT-20.zip'} + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class BLEURT(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, homepage='https://github.com/google-research/bleurt', inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')}), codebase_urls=['https://github.com/google-research/bleurt'], reference_urls=['https://github.com/google-research/bleurt', 'https://arxiv.org/abs/2004.04696']) + + def _download_and_prepare(self, dl_manager): + if self.config_name == 'default': + logger.warning("Using default BLEURT-Base checkpoint for sequence maximum length 128. You can use a bigger model for better results with e.g.: evaluate.load('bleurt', 'bleurt-large-512').") + self.config_name = 'bleurt-base-128' + if self.config_name.lower() in CHECKPOINT_URLS: + checkpoint_name = self.config_name.lower() + elif self.config_name.upper() in CHECKPOINT_URLS: + checkpoint_name = self.config_name.upper() + else: + raise KeyError(f'{self.config_name} model not found. You should supply the name of a model checkpoint for bleurt in {CHECKPOINT_URLS.keys()}') + model_path = dl_manager.download_and_extract(CHECKPOINT_URLS[checkpoint_name]) + self.scorer = score.BleurtScorer(os.path.join(model_path, checkpoint_name)) + + def _compute(self, predictions, references): + scores = self.scorer.score(references=references, candidates=predictions) + return {'scores': scores} + +# File: evaluate-main/metrics/brier_score/brier_score.py +"""""" +import datasets +from sklearn.metrics import brier_score_loss +import evaluate +_CITATION = '@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' +_DESCRIPTION = 'Brier score is a type of evaluation metric for classification tasks, where you predict outcomes such as win/lose, spam/ham, click/no-click etc.\n`BrierScore = 1/N * sum( (p_i - o_i)^2 )`\n' +_KWARGS_DESCRIPTION = '\nArgs:\n y_true : array of shape (n_samples,)\n True targets.\n\n y_prob : array of shape (n_samples,)\n Probabilities of the positive class.\n\n sample_weight : array-like of shape (n_samples,), default=None\n Sample weights.\n\n pos_label : int or str, default=None\n Label of the positive class. `pos_label` will be inferred in the\n following manner:\n\n * if `y_true` in {-1, 1} or {0, 1}, `pos_label` defaults to 1;\n * else if `y_true` contains string, an error will be raised and\n `pos_label` should be explicitly specified;\n * otherwise, `pos_label` defaults to the greater label,\n i.e. `np.unique(y_true)[-1]`.\n\nReturns\n score : float\n Brier score loss.\nExamples:\n Example-1: if y_true in {-1, 1} or {0, 1}, pos_label defaults to 1.\n >>> import numpy as np\n >>> brier_score = evaluate.load("brier_score")\n >>> references = np.array([0, 0, 1, 1])\n >>> predictions = np.array([0.1, 0.9, 0.8, 0.3])\n >>> results = brier_score.compute(references=references, predictions=predictions)\n >>> print(round(results["brier_score"], 4))\n 0.3375\n\n Example-2: if y_true contains string, an error will be raised and pos_label should be explicitly specified.\n >>> import numpy as np\n >>> brier_score = evaluate.load("brier_score")\n >>> references = np.array(["spam", "ham", "ham", "spam"])\n >>> predictions = np.array([0.1, 0.9, 0.8, 0.3])\n >>> results = brier_score.compute(references=references, predictions=predictions, pos_label="ham")\n >>> print(round(results["brier_score"], 4))\n 0.0375\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class BrierScore(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=self._get_feature_types(), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.brier_score_loss.html']) + + def _get_feature_types(self): + if self.config_name == 'multilist': + return [datasets.Features({'references': datasets.Sequence(datasets.Value('float')), 'predictions': datasets.Sequence(datasets.Value('float'))}), datasets.Features({'references': datasets.Sequence(datasets.Value('string')), 'predictions': datasets.Sequence(datasets.Value('float'))})] + else: + return [datasets.Features({'references': datasets.Value('float'), 'predictions': datasets.Value('float')}), datasets.Features({'references': datasets.Value('string'), 'predictions': datasets.Value('float')})] + + def _compute(self, references, predictions, sample_weight=None, pos_label=1): + brier_score = brier_score_loss(references, predictions, sample_weight=sample_weight, pos_label=pos_label) + return {'brier_score': brier_score} + +# File: evaluate-main/metrics/cer/cer.py +"""""" +from typing import List +import datasets +import jiwer +import jiwer.transforms as tr +from datasets.config import PY_VERSION +from packaging import version +import evaluate +if PY_VERSION < version.parse('3.8'): + import importlib_metadata +else: + import importlib.metadata as importlib_metadata +SENTENCE_DELIMITER = '' +if version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'): + + class SentencesToListOfCharacters(tr.AbstractTransform): + + def __init__(self, sentence_delimiter: str=' '): + self.sentence_delimiter = sentence_delimiter + + def process_string(self, s: str): + return list(s) + + def process_list(self, inp: List[str]): + chars = [] + for (sent_idx, sentence) in enumerate(inp): + chars.extend(self.process_string(sentence)) + if self.sentence_delimiter is not None and self.sentence_delimiter != '' and (sent_idx < len(inp) - 1): + chars.append(self.sentence_delimiter) + return chars + cer_transform = tr.Compose([tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]) +else: + cer_transform = tr.Compose([tr.RemoveMultipleSpaces(), tr.Strip(), tr.ReduceToSingleSentence(SENTENCE_DELIMITER), tr.ReduceToListOfListOfChars()]) +_CITATION = '@inproceedings{inproceedings,\n author = {Morris, Andrew and Maier, Viktoria and Green, Phil},\n year = {2004},\n month = {01},\n pages = {},\n title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}\n}\n' +_DESCRIPTION = "Character error rate (CER) is a common metric of the performance of an automatic speech recognition system.\n\nCER is similar to Word Error Rate (WER), but operates on character instead of word. Please refer to docs of WER for further information.\n\nCharacter error rate can be computed as:\n\nCER = (S + D + I) / N = (S + D + I) / (S + D + C)\n\nwhere\n\nS is the number of substitutions,\nD is the number of deletions,\nI is the number of insertions,\nC is the number of correct characters,\nN is the number of characters in the reference (N=S+D+C).\n\nCER's output is not always a number between 0 and 1, in particular when there is a high number of insertions. This value is often associated to the percentage of characters that were incorrectly predicted. The lower the value, the better the\nperformance of the ASR system with a CER of 0 being a perfect score.\n" +_KWARGS_DESCRIPTION = '\nComputes CER score of transcribed segments against references.\nArgs:\n references: list of references for each speech input.\n predictions: list of transcribtions to score.\n concatenate_texts: Whether or not to concatenate sentences before evaluation, set to True for more accurate result.\nReturns:\n (float): the character error rate\n\nExamples:\n\n >>> predictions = ["this is the prediction", "there is an other sample"]\n >>> references = ["this is the reference", "there is another one"]\n >>> cer = evaluate.load("cer")\n >>> cer_score = cer.compute(predictions=predictions, references=references)\n >>> print(cer_score)\n 0.34146341463414637\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class CER(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')}), codebase_urls=['https://github.com/jitsi/jiwer/'], reference_urls=['https://en.wikipedia.org/wiki/Word_error_rate', 'https://sites.google.com/site/textdigitisation/qualitymeasures/computingerrorrates']) + + def _compute(self, predictions, references, concatenate_texts=False): + if concatenate_texts: + return jiwer.compute_measures(references, predictions, truth_transform=cer_transform, hypothesis_transform=cer_transform)['wer'] + incorrect = 0 + total = 0 + for (prediction, reference) in zip(predictions, references): + measures = jiwer.compute_measures(reference, prediction, truth_transform=cer_transform, hypothesis_transform=cer_transform) + incorrect += measures['substitutions'] + measures['deletions'] + measures['insertions'] + total += measures['substitutions'] + measures['deletions'] + measures['hits'] + return incorrect / total + +# File: evaluate-main/metrics/character/character.py +"""""" +import math +from statistics import mean, median +from typing import Iterable, List, Union +import cer +import datasets +from cer import calculate_cer +from datasets import Sequence, Value +import evaluate +_CITATION = '@inproceedings{wang-etal-2016-character,\n title = "{C}harac{T}er: Translation Edit Rate on Character Level",\n author = "Wang, Weiyue and\n Peter, Jan-Thorsten and\n Rosendahl, Hendrik and\n Ney, Hermann",\n booktitle = "Proceedings of the First Conference on Machine Translation: Volume 2, Shared Task Papers",\n month = aug,\n year = "2016",\n address = "Berlin, Germany",\n publisher = "Association for Computational Linguistics",\n url = "https://aclanthology.org/W16-2342",\n doi = "10.18653/v1/W16-2342",\n pages = "505--510",\n}\n' +_DESCRIPTION = 'CharacTer is a character-level metric inspired by the commonly applied translation edit rate (TER). It is\ndefined as the minimum number of character edits required to adjust a hypothesis, until it completely matches the\nreference, normalized by the length of the hypothesis sentence. CharacTer calculates the character level edit\ndistance while performing the shift edit on word level. Unlike the strict matching criterion in TER, a hypothesis\nword is considered to match a reference word and could be shifted, if the edit distance between them is below a\nthreshold value. The Levenshtein distance between the reference and the shifted hypothesis sequence is computed on the\ncharacter level. In addition, the lengths of hypothesis sequences instead of reference sequences are used for\nnormalizing the edit distance, which effectively counters the issue that shorter translations normally achieve lower\nTER.' +_KWARGS_DESCRIPTION = '\nCalculates how good the predictions are in terms of the CharacTER metric given some references.\nArgs:\n predictions: a list of predictions to score. Each prediction should be a string with\n tokens separated by spaces.\n references: a list of references for each prediction. You can also pass multiple references for each prediction,\n so a list and in that list a sublist for each prediction for its related references. When multiple references are\n given, the lowest (best) score is returned for that prediction-references pair.\n Each reference should be a string with tokens separated by spaces.\n aggregate: one of "mean", "sum", "median" to indicate how the scores of individual sentences should be\n aggregated\n return_all_scores: a boolean, indicating whether in addition to the aggregated score, also all individual\n scores should be returned\nReturns:\n cer_score: an aggregated score across all the items, based on \'aggregate\'\n cer_scores: (optionally, if \'return_all_scores\' evaluates to True) a list of all scores, one per ref/hyp pair\nExamples:\n >>> character_mt = evaluate.load("character")\n >>> preds = ["this week the saudis denied information published in the new york times"]\n >>> refs = ["saudi arabia denied this week information published in the american new york times"]\n >>> character_mt.compute(references=refs, predictions=preds)\n {\'cer_score\': 0.36619718309859156}\n >>> preds = ["this week the saudis denied information published in the new york times",\n ... "this is in fact an estimate"]\n >>> refs = ["saudi arabia denied this week information published in the american new york times",\n ... "this is actually an estimate"]\n >>> character_mt.compute(references=refs, predictions=preds, aggregate="sum", return_all_scores=True)\n {\'cer_score\': 0.6254564423578508, \'cer_scores\': [0.36619718309859156, 0.25925925925925924]}\n >>> preds = ["this week the saudis denied information published in the new york times"]\n >>> refs = [["saudi arabia denied this week information published in the american new york times",\n ... "the saudis have denied new information published in the ny times"]]\n >>> character_mt.compute(references=refs, predictions=preds, aggregate="median", return_all_scores=True)\n {\'cer_score\': 0.36619718309859156, \'cer_scores\': [0.36619718309859156]}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Character(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(module_type='metric', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': Value('string', id='prediction'), 'references': Value('string', id='reference')}), datasets.Features({'predictions': Value('string', id='prediction'), 'references': Sequence(Value('string', id='reference'), id='references')})], homepage='https://github.com/bramvanroy/CharacTER', codebase_urls=['https://github.com/bramvanroy/CharacTER', 'https://github.com/rwth-i6/CharacTER']) + + def _compute(self, predictions: Iterable[str], references: Union[Iterable[str], Iterable[Iterable[str]]], aggregate: str='mean', return_all_scores: bool=False): + if aggregate not in ('mean', 'sum', 'median'): + raise ValueError("'aggregate' must be one of 'sum', 'mean', 'median'") + predictions = [p.split() for p in predictions] + if isinstance(references[0], str): + references = [r.split() for r in references] + scores_d = cer.calculate_cer_corpus(predictions, references) + cer_scores: List[float] = scores_d['cer_scores'] + if aggregate == 'sum': + score = sum(cer_scores) + elif aggregate == 'mean': + score = scores_d['mean'] + else: + score = scores_d['median'] + else: + references = [[r.split() for r in refs] for refs in references] + cer_scores = [] + for (pred, refs) in zip(predictions, references): + min_score = math.inf + for ref in refs: + score = calculate_cer(pred, ref) + if score < min_score: + min_score = score + cer_scores.append(min_score) + if aggregate == 'sum': + score = sum(cer_scores) + elif aggregate == 'mean': + score = mean(cer_scores) + else: + score = median(cer_scores) + if return_all_scores: + return {'cer_score': score, 'cer_scores': cer_scores} + else: + return {'cer_score': score} + +# File: evaluate-main/metrics/charcut_mt/charcut_mt.py +"""""" +from typing import Iterable, Union +import datasets +from charcut import calculate_charcut +from datasets import Sequence, Value +import evaluate +_CITATION = '@inproceedings{lardilleux-lepage-2017-charcut,\n title = "{CHARCUT}: Human-Targeted Character-Based {MT} Evaluation with Loose Differences",\n author = "Lardilleux, Adrien and\n Lepage, Yves",\n booktitle = "Proceedings of the 14th International Conference on Spoken Language Translation",\n month = dec # " 14-15",\n year = "2017",\n address = "Tokyo, Japan",\n publisher = "International Workshop on Spoken Language Translation",\n url = "https://aclanthology.org/2017.iwslt-1.20",\n pages = "146--153"\n}\n' +_DESCRIPTION = 'CharCut compares outputs of MT systems with reference translations. The matching algorithm is based on an iterative\nsearch for longest common substrings, combined with a length-based threshold that limits short and noisy character\nmatches. As a similarity metric this is not new, but to the best of our knowledge it was never applied to highlighting\nand scoring of MT outputs. It has the neat effect of keeping character-based differences readable by humans.' +_KWARGS_DESCRIPTION = '\nCalculates how good predictions are given some references.\nArgs:\n predictions: a list of predictions to score. Each prediction should be a string with\n tokens separated by spaces.\n references: a list of reference for each prediction. Each reference should be a string with\n tokens separated by spaces.\nReturns:\n charcut_mt: the CharCut score\nExamples:\n >>> charcut_mt = evaluate.load("charcut_mt")\n >>> preds = ["this week the saudis denied information published in the new york times",\n ... "this is in fact an estimate"]\n >>> refs = ["saudi arabia denied this week information published in the american new york times",\n ... "this is actually an estimate"]\n >>> charcut_mt.compute(references=refs, predictions=preds)\n {\'charcut_mt\': 0.1971153846153846}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Charcut(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(module_type='metric', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': Value('string', id='prediction'), 'references': Value('string', id='reference')})], homepage='https://github.com/BramVanroy/CharCut', codebase_urls=['https://github.com/BramVanroy/CharCut', 'https://github.com/alardill/CharCut']) + + def _compute(self, predictions: Iterable[str], references: Iterable[str]): + return {'charcut_mt': calculate_charcut(predictions, references)[0]} + +# File: evaluate-main/metrics/chrf/chrf.py +"""""" +import datasets +import sacrebleu as scb +from packaging import version +from sacrebleu import CHRF +import evaluate +_CITATION = '@inproceedings{popovic-2015-chrf,\n title = "chr{F}: character n-gram {F}-score for automatic {MT} evaluation",\n author = "Popovi{\'c}, Maja",\n booktitle = "Proceedings of the Tenth Workshop on Statistical Machine Translation",\n month = sep,\n year = "2015",\n address = "Lisbon, Portugal",\n publisher = "Association for Computational Linguistics",\n url = "https://aclanthology.org/W15-3049",\n doi = "10.18653/v1/W15-3049",\n pages = "392--395",\n}\n@inproceedings{popovic-2017-chrf,\n title = "chr{F}++: words helping character n-grams",\n author = "Popovi{\'c}, Maja",\n booktitle = "Proceedings of the Second Conference on Machine Translation",\n month = sep,\n year = "2017",\n address = "Copenhagen, Denmark",\n publisher = "Association for Computational Linguistics",\n url = "https://aclanthology.org/W17-4770",\n doi = "10.18653/v1/W17-4770",\n pages = "612--618",\n}\n@inproceedings{post-2018-call,\n title = "A Call for Clarity in Reporting {BLEU} Scores",\n author = "Post, Matt",\n booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n month = oct,\n year = "2018",\n address = "Belgium, Brussels",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/W18-6319",\n pages = "186--191",\n}\n' +_DESCRIPTION = "ChrF and ChrF++ are two MT evaluation metrics. They both use the F-score statistic for character n-gram matches,\nand ChrF++ adds word n-grams as well which correlates more strongly with direct assessment. We use the implementation\nthat is already present in sacrebleu.\n\nThe implementation here is slightly different from sacrebleu in terms of the required input format. The length of\nthe references and hypotheses lists need to be the same, so you may need to transpose your references compared to\nsacrebleu's required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534\n\nSee the README.md file at https://github.com/mjpost/sacreBLEU#chrf--chrf for more information.\n" +_KWARGS_DESCRIPTION = '\nProduces ChrF(++) scores for hypotheses given reference translations.\n\nArgs:\n predictions (list of str): The predicted sentences.\n references (list of list of str): The references. There should be one reference sub-list for each prediction sentence.\n char_order (int): Character n-gram order. Defaults to `6`.\n word_order (int): Word n-gram order. If equals to `2`, the metric is referred to as chrF++. Defaults to `0`.\n beta (int): Determine the importance of recall w.r.t precision. Defaults to `2`.\n lowercase (bool): if `True`, enables case-insensitivity. Defaults to `False`.\n whitespace (bool): If `True`, include whitespaces when extracting character n-grams.\n eps_smoothing (bool): If `True`, applies epsilon smoothing similar\n to reference chrF++.py, NLTK and Moses implementations. If `False`,\n it takes into account effective match order similar to sacreBLEU < 2.0.0. Defaults to `False`.\n\nReturns:\n \'score\' (float): The chrF (chrF++) score,\n \'char_order\' (int): The character n-gram order,\n \'word_order\' (int): The word n-gram order. If equals to 2, the metric is referred to as chrF++,\n \'beta\' (int): Determine the importance of recall w.r.t precision\n\nExamples:\n Example 1--a simple example of calculating chrF:\n >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]\n >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]\n >>> chrf = evaluate.load("chrf")\n >>> results = chrf.compute(predictions=prediction, references=reference)\n >>> print(results)\n {\'score\': 84.64214891738334, \'char_order\': 6, \'word_order\': 0, \'beta\': 2}\n\n Example 2--the same example, but with the argument word_order=2, to calculate chrF++ instead of chrF:\n >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]\n >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]\n >>> chrf = evaluate.load("chrf")\n >>> results = chrf.compute(predictions=prediction,\n ... references=reference,\n ... word_order=2)\n >>> print(results)\n {\'score\': 82.87263732906315, \'char_order\': 6, \'word_order\': 2, \'beta\': 2}\n\n Example 3--the same chrF++ example as above, but with `lowercase=True` to normalize all case:\n >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]\n >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]\n >>> chrf = evaluate.load("chrf")\n >>> results = chrf.compute(predictions=prediction,\n ... references=reference,\n ... word_order=2,\n ... lowercase=True)\n >>> print(results)\n {\'score\': 92.12853119829202, \'char_order\': 6, \'word_order\': 2, \'beta\': 2}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class ChrF(evaluate.Metric): + + def _info(self): + 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.\nYou can install it with `pip install "sacrebleu>=1.4.12"`.') + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, homepage='https://github.com/mjpost/sacreBLEU#chrf--chrf', inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'), id='references')}), datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')})], codebase_urls=['https://github.com/mjpost/sacreBLEU#chrf--chrf'], reference_urls=['https://github.com/m-popovic/chrF']) + + def _compute(self, predictions, references, char_order: int=CHRF.CHAR_ORDER, word_order: int=CHRF.WORD_ORDER, beta: int=CHRF.BETA, lowercase: bool=False, whitespace: bool=False, eps_smoothing: bool=False): + if isinstance(references[0], str): + references = [[ref] for ref in references] + references_per_prediction = len(references[0]) + if any((len(refs) != references_per_prediction for refs in references)): + raise ValueError('ChrF, as implemented by sacrebleu, requires the same number of references for each prediction') + transformed_references = [[refs[i] for refs in references] for i in range(references_per_prediction)] + sb_chrf = CHRF(char_order, word_order, beta, lowercase, whitespace, eps_smoothing) + output = sb_chrf.corpus_score(predictions, transformed_references) + return {'score': output.score, 'char_order': output.char_order, 'word_order': output.word_order, 'beta': output.beta} + +# File: evaluate-main/metrics/code_eval/code_eval.py +"""""" +import itertools +import os +from collections import Counter, defaultdict +from concurrent.futures import ThreadPoolExecutor, as_completed +import datasets +import numpy as np +import evaluate +from .execute import check_correctness +_CITATION = '@misc{chen2021evaluating,\n title={Evaluating Large Language Models Trained on Code},\n author={Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan and Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards and Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray and Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf and Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray and Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser and Mohammad Bavarian and Clemens Winter and Philippe Tillet and Felipe Petroski Such and Dave Cummings and Matthias Plappert and Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss and William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak and Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain and William Saunders and Christopher Hesse and Andrew N. Carr and Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa and Alec Radford and Matthew Knight and Miles Brundage and Mira Murati and Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei and Sam McCandlish and Ilya Sutskever and Wojciech Zaremba},\n year={2021},\n eprint={2107.03374},\n archivePrefix={arXiv},\n primaryClass={cs.LG}\n}\n' +_DESCRIPTION = 'This metric implements the evaluation harness for the HumanEval problem solving dataset\ndescribed in the paper "Evaluating Large Language Models Trained on Code"\n(https://arxiv.org/abs/2107.03374).\n' +_KWARGS_DESCRIPTION = '\nCalculates how good are predictions given some references, using certain scores\nArgs:\n predictions: list of candidates to evaluate. Each candidates should be a list\n of strings with several code candidates to solve the problem.\n references: a list with a test for each prediction. Each test should evaluate the\n correctness of a code candidate.\n k: number of code candidates to consider in the evaluation (Default: [1, 10, 100])\n num_workers: number of workers used to evaluate the canidate programs (Default: 4).\n timeout:\nReturns:\n pass_at_k: dict with pass rates for each k\n results: dict with granular results of each unittest\nExamples:\n >>> code_eval = evaluate.load("code_eval")\n >>> test_cases = ["assert add(2,3)==5"]\n >>> candidates = [["def add(a,b): return a*b", "def add(a, b): return a+b"]]\n >>> pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2])\n >>> print(pass_at_k)\n {\'pass@1\': 0.5, \'pass@2\': 1.0}\n' +_WARNING = '\n################################################################################\n !!!WARNING!!!\n################################################################################\nThe "code_eval" metric executes untrusted model-generated code in Python.\nAlthough it is highly unlikely that model-generated code will do something\novertly malicious in response to this test suite, model-generated code may act\ndestructively due to a lack of model capability or alignment.\nUsers are strongly encouraged to sandbox this evaluation suite so that it\ndoes not perform destructive actions on their host or network. For more\ninformation on how OpenAI sandboxes its code, see the paper "Evaluating Large\nLanguage Models Trained on Code" (https://arxiv.org/abs/2107.03374).\n\nOnce you have read this disclaimer and taken appropriate precautions,\nset the environment variable HF_ALLOW_CODE_EVAL="1". Within Python you can to this\nwith:\n\n>>> import os\n>>> os.environ["HF_ALLOW_CODE_EVAL"] = "1"\n\n################################################################################' +_LICENSE = 'The MIT License\n\nCopyright (c) OpenAI (https://openai.com)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the "Software"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class CodeEval(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('string')), 'references': datasets.Value('string')}), homepage='https://github.com/openai/human-eval', codebase_urls=['https://github.com/openai/human-eval'], reference_urls=['https://github.com/openai/human-eval'], license=_LICENSE) + + def _compute(self, predictions, references, k=[1, 10, 100], num_workers=4, timeout=3.0): + if os.getenv('HF_ALLOW_CODE_EVAL', 0) != '1': + raise ValueError(_WARNING) + if os.name == 'nt': + raise NotImplementedError('This metric is currently not supported on Windows.') + with ThreadPoolExecutor(max_workers=num_workers) as executor: + futures = [] + completion_id = Counter() + n_samples = 0 + results = defaultdict(list) + for (task_id, (candidates, test_case)) in enumerate(zip(predictions, references)): + for candidate in candidates: + test_program = candidate + '\n' + test_case + args = (test_program, timeout, task_id, completion_id[task_id]) + future = executor.submit(check_correctness, *args) + futures.append(future) + completion_id[task_id] += 1 + n_samples += 1 + for future in as_completed(futures): + result = future.result() + results[result['task_id']].append((result['completion_id'], result)) + (total, correct) = ([], []) + for result in results.values(): + result.sort() + passed = [r[1]['passed'] for r in result] + total.append(len(passed)) + correct.append(sum(passed)) + total = np.array(total) + correct = np.array(correct) + ks = k + pass_at_k = {f'pass@{k}': estimate_pass_at_k(total, correct, k).mean() for k in ks if (total >= k).all()} + return (pass_at_k, results) + +def estimate_pass_at_k(num_samples, num_correct, k): + + def estimator(n: int, c: int, k: int) -> float: + if n - c < k: + return 1.0 + return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1)) + if isinstance(num_samples, int): + num_samples_it = itertools.repeat(num_samples, len(num_correct)) + else: + assert len(num_samples) == len(num_correct) + num_samples_it = iter(num_samples) + return np.array([estimator(int(n), int(c), k) for (n, c) in zip(num_samples_it, num_correct)]) + +# File: evaluate-main/metrics/code_eval/execute.py +import contextlib +import faulthandler +import io +import multiprocessing +import os +import platform +import signal +import tempfile + +def check_correctness(check_program, timeout, task_id, completion_id): + manager = multiprocessing.Manager() + result = manager.list() + p = multiprocessing.Process(target=unsafe_execute, args=(check_program, result, timeout)) + p.start() + p.join(timeout=timeout + 1) + if p.is_alive(): + p.kill() + if not result: + result.append('timed out') + return dict(task_id=task_id, passed=result[0] == 'passed', result=result[0], completion_id=completion_id) + +def unsafe_execute(check_program, result, timeout): + with create_tempdir(): + import os + import shutil + rmtree = shutil.rmtree + rmdir = os.rmdir + chdir = os.chdir + reliability_guard() + try: + exec_globals = {} + with swallow_io(): + with time_limit(timeout): + exec(check_program, exec_globals) + result.append('passed') + except TimeoutException: + result.append('timed out') + except BaseException as e: + result.append(f'failed: {e}') + shutil.rmtree = rmtree + os.rmdir = rmdir + os.chdir = chdir + +@contextlib.contextmanager +def time_limit(seconds): + + def signal_handler(signum, frame): + raise TimeoutException('Timed out!') + signal.setitimer(signal.ITIMER_REAL, seconds) + signal.signal(signal.SIGALRM, signal_handler) + try: + yield + finally: + signal.setitimer(signal.ITIMER_REAL, 0) + +@contextlib.contextmanager +def swallow_io(): + stream = WriteOnlyStringIO() + with contextlib.redirect_stdout(stream): + with contextlib.redirect_stderr(stream): + with redirect_stdin(stream): + yield + +@contextlib.contextmanager +def create_tempdir(): + with tempfile.TemporaryDirectory() as dirname: + with chdir(dirname): + yield dirname + +class TimeoutException(Exception): + pass + +class WriteOnlyStringIO(io.StringIO): + + def read(self, *args, **kwargs): + raise OSError + + def readline(self, *args, **kwargs): + raise OSError + + def readlines(self, *args, **kwargs): + raise OSError + + def readable(self, *args, **kwargs): + return False + +class redirect_stdin(contextlib._RedirectStream): + _stream = 'stdin' + +@contextlib.contextmanager +def chdir(root): + if root == '.': + yield + return + cwd = os.getcwd() + os.chdir(root) + try: + yield + except BaseException as exc: + raise exc + finally: + os.chdir(cwd) + +def reliability_guard(maximum_memory_bytes=None): + if maximum_memory_bytes is not None: + import resource + resource.setrlimit(resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes)) + resource.setrlimit(resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes)) + if not platform.uname().system == 'Darwin': + resource.setrlimit(resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes)) + faulthandler.disable() + import builtins + builtins.exit = None + builtins.quit = None + import os + os.environ['OMP_NUM_THREADS'] = '1' + os.kill = None + os.system = None + os.putenv = None + os.remove = None + os.removedirs = None + os.rmdir = None + os.fchdir = None + os.setuid = None + os.fork = None + os.forkpty = None + os.killpg = None + os.rename = None + os.renames = None + os.truncate = None + os.replace = None + os.unlink = None + os.fchmod = None + os.fchown = None + os.chmod = None + os.chown = None + os.chroot = None + os.fchdir = None + os.lchflags = None + os.lchmod = None + os.lchown = None + os.getcwd = None + os.chdir = None + import shutil + shutil.rmtree = None + shutil.move = None + shutil.chown = None + import subprocess + subprocess.Popen = None + __builtins__['help'] = None + import sys + sys.modules['ipdb'] = None + sys.modules['joblib'] = None + sys.modules['resource'] = None + sys.modules['psutil'] = None + sys.modules['tkinter'] = None + +# File: evaluate-main/metrics/comet/comet.py +"""""" +import comet +import datasets +import torch +from packaging import version +import evaluate +logger = evaluate.logging.get_logger(__name__) +_CITATION = '@inproceedings{rei-etal-2022-comet,\n title = "{COMET}-22: Unbabel-{IST} 2022 Submission for the Metrics Shared Task",\n author = "Rei, Ricardo and\n C. de Souza, Jos{\'e} G. and\n Alves, Duarte and\n Zerva, Chrysoula and\n Farinha, Ana C and\n Glushkova, Taisiya and\n Lavie, Alon and\n Coheur, Luisa and\n Martins, Andr{\'e} F. T.",\n booktitle = "Proceedings of the Seventh Conference on Machine Translation (WMT)",\n month = dec,\n year = "2022",\n address = "Abu Dhabi, United Arab Emirates (Hybrid)",\n publisher = "Association for Computational Linguistics",\n url = "https://aclanthology.org/2022.wmt-1.52",\n pages = "578--585",\n}\n@inproceedings{rei-EtAl:2020:WMT,\n author = {Rei, Ricardo and Stewart, Craig and Farinha, Ana C and Lavie, Alon},\n title = {Unbabel\'s Participation in the WMT20 Metrics Shared Task},\n booktitle = {Proceedings of the Fifth Conference on Machine Translation},\n month = {November},\n year = {2020},\n address = {Online},\n publisher = {Association for Computational Linguistics},\n pages = {909--918},\n}\n@inproceedings{rei-etal-2020-comet,\n title = "{COMET}: A Neural Framework for {MT} Evaluation",\n author = "Rei, Ricardo and\n Stewart, Craig and\n Farinha, Ana C and\n Lavie, Alon",\n booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)",\n month = nov,\n year = "2020",\n address = "Online",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/2020.emnlp-main.213",\n pages = "2685--2702",\n}\n' +_DESCRIPTION = "Crosslingual Optimized Metric for Evaluation of Translation (COMET) is an open-source framework used to train Machine Translation metrics that achieve high levels of correlation with different types of human judgments (HTER, DA's or MQM).\nWith the release of the framework the authors also released fully trained models that were used to compete in the WMT20 Metrics Shared Task achieving SOTA in that years competition.\n\nSee the [README.md] file at https://unbabel.github.io/COMET/html/models.html for more information.\n" +_KWARGS_DESCRIPTION = '\nCOMET score.\n\nArgs:\n\n`sources` (list of str): Source sentences\n`predictions` (list of str): candidate translations\n`references` (list of str): reference translations\n`gpus` (bool): Number of GPUs to use. 0 for CPU\n`progress_bar` (bool): Flag that turns on and off the predict progress bar. Defaults to True\n\nReturns:\n Dict with all sentence-level scores (`scores` key) a system-level score (`mean_score` key).\n\nExamples:\n\n >>> comet_metric = evaluate.load(\'comet\')\n >>> # comet_metric = load(\'comet\', \'wmt20-comet-da\') # you can also choose which model to use\n >>> source = ["Dem Feuer konnte Einhalt geboten werden", "Schulen und Kindergärten wurden eröffnet."]\n >>> hypothesis = ["The fire could be stopped", "Schools and kindergartens were open"]\n >>> reference = ["They were able to control the fire.", "Schools and kindergartens opened"]\n >>> results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)\n >>> print([round(v, 3) for v in results["scores"]])\n [0.839, 0.972]\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class COMET(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, homepage='https://unbabel.github.io/COMET/html/index.html', inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'sources': datasets.Value('string', id='sequence'), 'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')}), codebase_urls=['https://github.com/Unbabel/COMET'], reference_urls=['https://github.com/Unbabel/COMET', 'https://aclanthology.org/2022.wmt-1.52/', 'https://www.aclweb.org/anthology/2020.emnlp-main.213/', 'http://www.statmt.org/wmt20/pdf/2020.wmt-1.101.pdf6']) + + def _download_and_prepare(self, dl_manager): + if self.config_name == 'default': + if version.parse(comet.__version__) >= version.parse('2.0.0'): + self.scorer = comet.load_from_checkpoint(comet.download_model('Unbabel/wmt22-comet-da')) + else: + self.scorer = comet.load_from_checkpoint(comet.download_model('wmt20-comet-da')) + else: + self.scorer = comet.load_from_checkpoint(comet.download_model(self.config_name)) + + def _compute(self, sources, predictions, references, gpus=None, progress_bar=False): + if gpus is None: + gpus = 1 if torch.cuda.is_available() else 0 + data = {'src': sources, 'mt': predictions, 'ref': references} + data = [dict(zip(data, t)) for t in zip(*data.values())] + if version.parse(comet.__version__) >= version.parse('2.0.0'): + output = self.scorer.predict(data, gpus=gpus, progress_bar=progress_bar) + (scores, mean_score) = (output.scores, output.system_score) + else: + (scores, mean_score) = self.scorer.predict(data, gpus=gpus, progress_bar=progress_bar) + return {'mean_score': mean_score, 'scores': scores} + +# File: evaluate-main/metrics/competition_math/competition_math.py +"""""" +import datasets +import math_equivalence +import evaluate +_CITATION = '@article{hendrycksmath2021,\n title={Measuring Mathematical Problem Solving With the MATH Dataset},\n author={Dan Hendrycks\n and Collin Burns\n and Saurav Kadavath\n and Akul Arora\n and Steven Basart\n and Eric Tang\n and Dawn Song\n and Jacob Steinhardt},\n journal={arXiv preprint arXiv:2103.03874},\n year={2021}\n}\n' +_DESCRIPTION = 'This metric is used to assess performance on the Mathematics Aptitude Test of Heuristics (MATH) dataset.\nIt first canonicalizes the inputs (e.g., converting "1/2" to "\\frac{1}{2}") and then computes accuracy.\n' +_KWARGS_DESCRIPTION = '\nCalculates accuracy after canonicalizing inputs.\n\nArgs:\n predictions: list of predictions to score. Each prediction\n is a string that contains natural language and LaTex.\n references: list of reference for each prediction. Each\n reference is a string that contains natural language\n and LaTex.\nReturns:\n accuracy: accuracy after canonicalizing inputs\n (e.g., converting "1/2" to "\\\\frac{1}{2}")\n\nExamples:\n >>> metric = evaluate.load("competition_math")\n >>> results = metric.compute(references=["\\\\frac{1}{2}"], predictions=["1/2"])\n >>> print(results)\n {\'accuracy\': 1.0}\n' + +@datasets.utils.file_utils.add_end_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class CompetitionMathMetric(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('string'), 'references': datasets.Value('string')}), homepage='https://github.com/hendrycks/math', codebase_urls=['https://github.com/hendrycks/math']) + + def _compute(self, predictions, references): + n_correct = 0.0 + for (i, j) in zip(predictions, references): + n_correct += 1.0 if math_equivalence.is_equiv(i, j) else 0.0 + accuracy = n_correct / len(predictions) + return {'accuracy': accuracy} + +# File: evaluate-main/metrics/confusion_matrix/confusion_matrix.py +"""""" +import datasets +from sklearn.metrics import confusion_matrix +import evaluate +_DESCRIPTION = '\nThe confusion matrix evaluates classification accuracy. Each row in a confusion matrix represents a true class and each column represents the instances in a predicted class\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions (`list` of `int`): Predicted labels.\n references (`list` of `int`): Ground truth labels.\n labels (`list` of `int`): List of labels to index the matrix. This may be used to reorder or select a subset of labels.\n sample_weight (`list` of `float`): Sample weights.\n normalize (`str`): Normalizes confusion matrix over the true (rows), predicted (columns) conditions or all the population.\n\nReturns:\n confusion_matrix (`list` of `list` of `int`): Confusion matrix whose i-th row and j-th column entry indicates the number of samples with true label being i-th class and predicted label being j-th class.\n\nExamples:\n\n Example 1-A simple example\n >>> confusion_matrix_metric = evaluate.load("confusion_matrix")\n >>> results = confusion_matrix_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])\n >>> print(results) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE\n {\'confusion_matrix\': array([[1, 0, 1], [0, 2, 0], [1, 1, 0]][...])}\n' +_CITATION = '\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class ConfusionMatrix(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('int32')), 'references': datasets.Sequence(datasets.Value('int32'))} if self.config_name == 'multilabel' else {'predictions': datasets.Value('int32'), 'references': datasets.Value('int32')}), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html']) + + def _compute(self, predictions, references, labels=None, sample_weight=None, normalize=None): + return {'confusion_matrix': confusion_matrix(references, predictions, labels=labels, sample_weight=sample_weight, normalize=normalize)} + +# File: evaluate-main/metrics/coval/coval.py +"""""" +import coval +import datasets +from coval.conll import reader, util +from coval.eval import evaluator +import evaluate +logger = evaluate.logging.get_logger(__name__) +_CITATION = '@InProceedings{moosavi2019minimum,\n author = { Nafise Sadat Moosavi, Leo Born, Massimo Poesio and Michael Strube},\n title = {Using Automatically Extracted Minimum Spans to Disentangle Coreference Evaluation from Boundary Detection},\n year = {2019},\n booktitle = {Proceedings of the 57th Annual Meeting of\n the Association for Computational Linguistics (Volume 1: Long Papers)},\n publisher = {Association for Computational Linguistics},\n address = {Florence, Italy},\n}\n\n@inproceedings{10.3115/1072399.1072405,\nauthor = {Vilain, Marc and Burger, John and Aberdeen, John and Connolly, Dennis and Hirschman, Lynette},\ntitle = {A Model-Theoretic Coreference Scoring Scheme},\nyear = {1995},\nisbn = {1558604022},\npublisher = {Association for Computational Linguistics},\naddress = {USA},\nurl = {https://doi.org/10.3115/1072399.1072405},\ndoi = {10.3115/1072399.1072405},\nbooktitle = {Proceedings of the 6th Conference on Message Understanding},\npages = {45–52},\nnumpages = {8},\nlocation = {Columbia, Maryland},\nseries = {MUC6 ’95}\n}\n\n@INPROCEEDINGS{Bagga98algorithmsfor,\n author = {Amit Bagga and Breck Baldwin},\n title = {Algorithms for Scoring Coreference Chains},\n booktitle = {In The First International Conference on Language Resources and Evaluation Workshop on Linguistics Coreference},\n year = {1998},\n pages = {563--566}\n}\n\n@INPROCEEDINGS{Luo05oncoreference,\n author = {Xiaoqiang Luo},\n title = {On coreference resolution performance metrics},\n booktitle = {In Proc. of HLT/EMNLP},\n year = {2005},\n pages = {25--32},\n publisher = {URL}\n}\n\n@inproceedings{moosavi-strube-2016-coreference,\n title = "Which Coreference Evaluation Metric Do You Trust? A Proposal for a Link-based Entity Aware Metric",\n author = "Moosavi, Nafise Sadat and\n Strube, Michael",\n booktitle = "Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",\n month = aug,\n year = "2016",\n address = "Berlin, Germany",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/P16-1060",\n doi = "10.18653/v1/P16-1060",\n pages = "632--642",\n}\n\n' +_DESCRIPTION = 'CoVal is a coreference evaluation tool for the CoNLL and ARRAU datasets which\nimplements of the common evaluation metrics including MUC [Vilain et al, 1995],\nB-cubed [Bagga and Baldwin, 1998], CEAFe [Luo et al., 2005],\nLEA [Moosavi and Strube, 2016] and the averaged CoNLL score\n(the average of the F1 values of MUC, B-cubed and CEAFe)\n[Denis and Baldridge, 2009a; Pradhan et al., 2011].\n\nThis wrapper of CoVal currently only work with CoNLL line format:\nThe CoNLL format has one word per line with all the annotation for this word in column separated by spaces:\nColumn\tType\tDescription\n1\tDocument ID\tThis is a variation on the document filename\n2\tPart number\tSome files are divided into multiple parts numbered as 000, 001, 002, ... etc.\n3\tWord number\n4\tWord itself\tThis is the token as segmented/tokenized in the Treebank. Initially the *_skel file contain the placeholder [WORD] which gets replaced by the actual token from the Treebank which is part of the OntoNotes release.\n5\tPart-of-Speech\n6\tParse bit\tThis is the bracketed structure broken before the first open parenthesis in the parse, and the word/part-of-speech leaf replaced with a *. The full parse can be created by substituting the asterix with the "([pos] [word])" string (or leaf) and concatenating the items in the rows of that column.\n7\tPredicate lemma\tThe predicate lemma is mentioned for the rows for which we have semantic role information. All other rows are marked with a "-"\n8\tPredicate Frameset ID\tThis is the PropBank frameset ID of the predicate in Column 7.\n9\tWord sense\tThis is the word sense of the word in Column 3.\n10\tSpeaker/Author\tThis is the speaker or author name where available. Mostly in Broadcast Conversation and Web Log data.\n11\tNamed Entities\tThese columns identifies the spans representing various named entities.\n12:N\tPredicate Arguments\tThere is one column each of predicate argument structure information for the predicate mentioned in Column 7.\nN\tCoreference\tCoreference chain information encoded in a parenthesis structure.\nMore informations on the format can be found here (section "*_conll File Format"): http://www.conll.cemantix.org/2012/data.html\n\nDetails on the evaluation on CoNLL can be found here: https://github.com/ns-moosavi/coval/blob/master/conll/README.md\n\nCoVal code was written by @ns-moosavi.\nSome parts are borrowed from https://github.com/clarkkev/deep-coref/blob/master/evaluation.py\nThe test suite is taken from https://github.com/conll/reference-coreference-scorers/\nMention evaluation and the test suite are added by @andreasvc.\nParsing CoNLL files is developed by Leo Born.\n' +_KWARGS_DESCRIPTION = "\nCalculates coreference evaluation metrics.\nArgs:\n predictions: list of sentences. Each sentence is a list of word predictions to score in the CoNLL format.\n Each prediction is a word with its annotations as a string made of columns joined with spaces.\n Only columns 4, 5, 6 and the last column are used (word, POS, Pars and coreference annotation)\n See the details on the format in the description of the metric.\n references: list of sentences. Each sentence is a list of word reference to score in the CoNLL format.\n Each reference is a word with its annotations as a string made of columns joined with spaces.\n Only columns 4, 5, 6 and the last column are used (word, POS, Pars and coreference annotation)\n See the details on the format in the description of the metric.\n keep_singletons: After extracting all mentions of key or system files,\n mentions whose corresponding coreference chain is of size one,\n are considered as singletons. The default evaluation mode will include\n singletons in evaluations if they are included in the key or the system files.\n By setting 'keep_singletons=False', all singletons in the key and system files\n will be excluded from the evaluation.\n NP_only: Most of the recent coreference resolvers only resolve NP mentions and\n leave out the resolution of VPs. By setting the 'NP_only' option, the scorer will only evaluate the resolution of NPs.\n min_span: By setting 'min_span', the scorer reports the results based on automatically detected minimum spans.\n Minimum spans are determined using the MINA algorithm.\n\nReturns:\n 'mentions': mentions\n 'muc': MUC metric [Vilain et al, 1995]\n 'bcub': B-cubed [Bagga and Baldwin, 1998]\n 'ceafe': CEAFe [Luo et al., 2005]\n 'lea': LEA [Moosavi and Strube, 2016]\n 'conll_score': averaged CoNLL score (the average of the F1 values of MUC, B-cubed and CEAFe)\n\nExamples:\n\n >>> coval = evaluate.load('coval')\n >>> words = ['bc/cctv/00/cctv_0005 0 0 Thank VBP (TOP(S(VP* thank 01 1 Xu_li * (V*) * -',\n ... 'bc/cctv/00/cctv_0005 0 1 you PRP (NP*) - - - Xu_li * (ARG1*) (ARG0*) (116)',\n ... 'bc/cctv/00/cctv_0005 0 2 everyone NN (NP*) - - - Xu_li * (ARGM-DIS*) * (116)',\n ... 'bc/cctv/00/cctv_0005 0 3 for IN (PP* - - - Xu_li * (ARG2* * -',\n ... 'bc/cctv/00/cctv_0005 0 4 watching VBG (S(VP*)))) watch 01 1 Xu_li * *) (V*) -',\n ... 'bc/cctv/00/cctv_0005 0 5 . . *)) - - - Xu_li * * * -']\n >>> references = [words]\n >>> predictions = [words]\n >>> results = coval.compute(predictions=predictions, references=references)\n >>> print(results) # doctest:+ELLIPSIS\n {'mentions/recall': 1.0,[...] 'conll_score': 100.0}\n" + +def get_coref_infos(key_lines, sys_lines, NP_only=False, remove_nested=False, keep_singletons=True, min_span=False, doc='dummy_doc'): + key_doc_lines = {doc: key_lines} + sys_doc_lines = {doc: sys_lines} + doc_coref_infos = {} + key_nested_coref_num = 0 + sys_nested_coref_num = 0 + key_removed_nested_clusters = 0 + sys_removed_nested_clusters = 0 + key_singletons_num = 0 + sys_singletons_num = 0 + (key_clusters, singletons_num) = reader.get_doc_mentions(doc, key_doc_lines[doc], keep_singletons) + key_singletons_num += singletons_num + if NP_only or min_span: + key_clusters = reader.set_annotated_parse_trees(key_clusters, key_doc_lines[doc], NP_only, min_span) + (sys_clusters, singletons_num) = reader.get_doc_mentions(doc, sys_doc_lines[doc], keep_singletons) + sys_singletons_num += singletons_num + if NP_only or min_span: + sys_clusters = reader.set_annotated_parse_trees(sys_clusters, key_doc_lines[doc], NP_only, min_span) + if remove_nested: + (nested_mentions, removed_clusters) = reader.remove_nested_coref_mentions(key_clusters, keep_singletons) + key_nested_coref_num += nested_mentions + key_removed_nested_clusters += removed_clusters + (nested_mentions, removed_clusters) = reader.remove_nested_coref_mentions(sys_clusters, keep_singletons) + sys_nested_coref_num += nested_mentions + sys_removed_nested_clusters += removed_clusters + sys_mention_key_cluster = reader.get_mention_assignments(sys_clusters, key_clusters) + key_mention_sys_cluster = reader.get_mention_assignments(key_clusters, sys_clusters) + doc_coref_infos[doc] = (key_clusters, sys_clusters, key_mention_sys_cluster, sys_mention_key_cluster) + if remove_nested: + logger.info(f'Number of removed nested coreferring mentions in the key annotation: {key_nested_coref_num}; and system annotation: {sys_nested_coref_num}') + logger.info(f'Number of resulting singleton clusters in the key annotation: {key_removed_nested_clusters}; and system annotation: {sys_removed_nested_clusters}') + if not keep_singletons: + logger.info(f'{key_singletons_num:d} and {sys_singletons_num:d} singletons are removed from the key and system files, respectively') + return doc_coref_infos + +def compute_score(key_lines, sys_lines, metrics, NP_only, remove_nested, keep_singletons, min_span): + doc_coref_infos = get_coref_infos(key_lines, sys_lines, NP_only, remove_nested, keep_singletons, min_span) + output_scores = {} + conll = 0 + conll_subparts_num = 0 + for (name, metric) in metrics: + (recall, precision, f1) = evaluator.evaluate_documents(doc_coref_infos, metric, beta=1) + if name in ['muc', 'bcub', 'ceafe']: + conll += f1 + conll_subparts_num += 1 + output_scores.update({f'{name}/recall': recall, f'{name}/precision': precision, f'{name}/f1': f1}) + logger.info(name.ljust(10), f'Recall: {recall * 100:.2f}', f' Precision: {precision * 100:.2f}', f' F1: {f1 * 100:.2f}') + if conll_subparts_num == 3: + conll = conll / 3 * 100 + logger.info(f'CoNLL score: {conll:.2f}') + output_scores.update({'conll_score': conll}) + return output_scores + +def check_gold_parse_annotation(key_lines): + has_gold_parse = False + for line in key_lines: + if not line.startswith('#'): + if len(line.split()) > 6: + parse_col = line.split()[5] + if not parse_col == '-': + has_gold_parse = True + break + else: + break + return has_gold_parse + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Coval(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('string')), 'references': datasets.Sequence(datasets.Value('string'))}), codebase_urls=['https://github.com/ns-moosavi/coval'], reference_urls=['https://github.com/ns-moosavi/coval', 'https://www.aclweb.org/anthology/P16-1060', 'http://www.conll.cemantix.org/2012/data.html']) + + def _compute(self, predictions, references, keep_singletons=True, NP_only=False, min_span=False, remove_nested=False): + allmetrics = [('mentions', evaluator.mentions), ('muc', evaluator.muc), ('bcub', evaluator.b_cubed), ('ceafe', evaluator.ceafe), ('lea', evaluator.lea)] + if min_span: + has_gold_parse = util.check_gold_parse_annotation(references) + if not has_gold_parse: + raise NotImplementedError("References should have gold parse annotation to use 'min_span'.") + score = compute_score(key_lines=references, sys_lines=predictions, metrics=allmetrics, NP_only=NP_only, remove_nested=remove_nested, keep_singletons=keep_singletons, min_span=min_span) + return score + +# File: evaluate-main/metrics/cuad/compute_score.py +"""""" +import argparse +import json +import re +import string +import sys +import numpy as np +IOU_THRESH = 0.5 + +def get_jaccard(prediction, ground_truth): + remove_tokens = ['.', ',', ';', ':'] + for token in remove_tokens: + ground_truth = ground_truth.replace(token, '') + prediction = prediction.replace(token, '') + (ground_truth, prediction) = (ground_truth.lower(), prediction.lower()) + (ground_truth, prediction) = (ground_truth.replace('/', ' '), prediction.replace('/', ' ')) + (ground_truth, prediction) = (set(ground_truth.split(' ')), set(prediction.split(' '))) + intersection = ground_truth.intersection(prediction) + union = ground_truth.union(prediction) + jaccard = len(intersection) / len(union) + return jaccard + +def normalize_answer(s): + + def remove_articles(text): + return re.sub('\\b(a|an|the)\\b', ' ', text) + + def white_space_fix(text): + return ' '.join(text.split()) + + def remove_punc(text): + exclude = set(string.punctuation) + return ''.join((ch for ch in text if ch not in exclude)) + + def lower(text): + return text.lower() + return white_space_fix(remove_articles(remove_punc(lower(s)))) + +def compute_precision_recall(predictions, ground_truths, qa_id): + (tp, fp, fn) = (0, 0, 0) + substr_ok = 'Parties' in qa_id + if len(ground_truths) == 0: + if len(predictions) > 0: + fp += len(predictions) + else: + for ground_truth in ground_truths: + assert len(ground_truth) > 0 + match_found = False + for pred in predictions: + if substr_ok: + is_match = get_jaccard(pred, ground_truth) >= IOU_THRESH or ground_truth in pred + else: + is_match = get_jaccard(pred, ground_truth) >= IOU_THRESH + if is_match: + match_found = True + if match_found: + tp += 1 + else: + fn += 1 + for pred in predictions: + match_found = False + for ground_truth in ground_truths: + assert len(ground_truth) > 0 + if substr_ok: + is_match = get_jaccard(pred, ground_truth) >= IOU_THRESH or ground_truth in pred + else: + is_match = get_jaccard(pred, ground_truth) >= IOU_THRESH + if is_match: + match_found = True + if not match_found: + fp += 1 + precision = tp / (tp + fp) if tp + fp > 0 else np.nan + recall = tp / (tp + fn) if tp + fn > 0 else np.nan + return (precision, recall) + +def process_precisions(precisions): + precision_best = precisions[::-1] + for i in range(1, len(precision_best)): + precision_best[i] = max(precision_best[i - 1], precision_best[i]) + precisions = precision_best[::-1] + return precisions + +def get_aupr(precisions, recalls): + processed_precisions = process_precisions(precisions) + aupr = np.trapz(processed_precisions, recalls) + if np.isnan(aupr): + return 0 + return aupr + +def get_prec_at_recall(precisions, recalls, recall_thresh): + processed_precisions = process_precisions(precisions) + prec_at_recall = 0 + for (prec, recall) in zip(processed_precisions, recalls): + if recall >= recall_thresh: + prec_at_recall = prec + break + return prec_at_recall + +def exact_match_score(prediction, ground_truth): + return normalize_answer(prediction) == normalize_answer(ground_truth) + +def metric_max_over_ground_truths(metric_fn, predictions, ground_truths): + score = 0 + for pred in predictions: + for ground_truth in ground_truths: + score = metric_fn(pred, ground_truth) + if score == 1: + break + if score == 1: + break + return score + +def compute_score(dataset, predictions): + f1 = exact_match = total = 0 + precisions = [] + recalls = [] + for article in dataset: + for paragraph in article['paragraphs']: + for qa in paragraph['qas']: + total += 1 + if qa['id'] not in predictions: + message = 'Unanswered question ' + qa['id'] + ' will receive score 0.' + print(message, file=sys.stderr) + continue + ground_truths = list(map(lambda x: x['text'], qa['answers'])) + prediction = predictions[qa['id']] + (precision, recall) = compute_precision_recall(prediction, ground_truths, qa['id']) + precisions.append(precision) + recalls.append(recall) + if precision == 0 and recall == 0: + f1 += 0 + else: + f1 += 2 * (precision * recall) / (precision + recall) + exact_match += metric_max_over_ground_truths(exact_match_score, prediction, ground_truths) + precisions = [x for (_, x) in sorted(zip(recalls, precisions))] + recalls.sort() + f1 = 100.0 * f1 / total + exact_match = 100.0 * exact_match / total + aupr = get_aupr(precisions, recalls) + prec_at_90_recall = get_prec_at_recall(precisions, recalls, recall_thresh=0.9) + prec_at_80_recall = get_prec_at_recall(precisions, recalls, recall_thresh=0.8) + return {'exact_match': exact_match, 'f1': f1, 'aupr': aupr, 'prec_at_80_recall': prec_at_80_recall, 'prec_at_90_recall': prec_at_90_recall} +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Evaluation for CUAD') + parser.add_argument('dataset_file', help='Dataset file') + parser.add_argument('prediction_file', help='Prediction File') + args = parser.parse_args() + with open(args.dataset_file) as dataset_file: + dataset_json = json.load(dataset_file) + dataset = dataset_json['data'] + with open(args.prediction_file) as prediction_file: + predictions = json.load(prediction_file) + print(json.dumps(compute_score(dataset, predictions))) + +# File: evaluate-main/metrics/cuad/cuad.py +"""""" +import datasets +import evaluate +from .compute_score import compute_score +_CITATION = '@article{hendrycks2021cuad,\n title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review},\n author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball},\n journal={arXiv preprint arXiv:2103.06268},\n year={2021}\n}\n' +_DESCRIPTION = '\nThis metric wrap the official scoring script for version 1 of the Contract\nUnderstanding Atticus Dataset (CUAD).\nContract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510\ncommercial legal contracts that have been manually labeled to identify 41 categories of important\nclauses that lawyers look for when reviewing contracts in connection with corporate transactions.\n' +_KWARGS_DESCRIPTION = '\nComputes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall).\nArgs:\n predictions: List of question-answers dictionaries with the following key-values:\n - \'id\': id of the question-answer pair as given in the references (see below)\n - \'prediction_text\': list of possible texts for the answer, as a list of strings\n depending on a threshold on the confidence probability of each prediction.\n references: List of question-answers dictionaries with the following key-values:\n - \'id\': id of the question-answer pair (see above),\n - \'answers\': a Dict in the CUAD dataset format\n {\n \'text\': list of possible texts for the answer, as a list of strings\n \'answer_start\': list of start positions for the answer, as a list of ints\n }\n Note that answer_start values are not taken into account to compute the metric.\nReturns:\n \'exact_match\': Exact match (the normalized answer exactly match the gold answer)\n \'f1\': The F-score of predicted tokens versus the gold answer\n \'aupr\': Area Under the Precision-Recall curve\n \'prec_at_80_recall\': Precision at 80% recall\n \'prec_at_90_recall\': Precision at 90% recall\nExamples:\n >>> predictions = [{\'prediction_text\': [\'The seller:\', \'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.\'], \'id\': \'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties\'}]\n >>> references = [{\'answers\': {\'answer_start\': [143, 49], \'text\': [\'The seller:\', \'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.\']}, \'id\': \'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties\'}]\n >>> cuad_metric = evaluate.load("cuad")\n >>> results = cuad_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'exact_match\': 100.0, \'f1\': 100.0, \'aupr\': 0.0, \'prec_at_80_recall\': 1.0, \'prec_at_90_recall\': 1.0}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class CUAD(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': {'id': datasets.Value('string'), 'prediction_text': datasets.features.Sequence(datasets.Value('string'))}, 'references': {'id': datasets.Value('string'), 'answers': datasets.features.Sequence({'text': datasets.Value('string'), 'answer_start': datasets.Value('int32')})}}), codebase_urls=['https://www.atticusprojectai.org/cuad'], reference_urls=['https://www.atticusprojectai.org/cuad']) + + def _compute(self, predictions, references): + pred_dict = {prediction['id']: prediction['prediction_text'] for prediction in predictions} + dataset = [{'paragraphs': [{'qas': [{'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id']} for ref in references]}]}] + score = compute_score(dataset=dataset, predictions=pred_dict) + return score + +# File: evaluate-main/metrics/exact_match/exact_match.py +"""""" +import re +import string +import datasets +import numpy as np +import evaluate +_DESCRIPTION = '\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions: List of predicted texts.\n references: List of reference texts.\n regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n ignore when calculating the exact matches. Note: these regexes are removed\n from the input data before the changes based on the options below (e.g. ignore_case,\n ignore_punctuation, ignore_numbers) are applied.\n ignore_case: Boolean, defaults to False. If true, turns everything\n to lowercase so that capitalization differences are ignored.\n ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n comparing predictions and references.\n ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n comparing predictions and references.\nReturns:\n exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 1.0, inclusive.\nExamples:\n >>> exact_match = evaluate.load("exact_match")\n >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n >>> preds = ["cat?", "theater", "yelling", "agent"]\n >>> results = exact_match.compute(references=refs, predictions=preds)\n >>> print(round(results["exact_match"], 2))\n 0.25\n\n >>> exact_match = evaluate.load("exact_match")\n >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n >>> preds = ["cat?", "theater", "yelling", "agent"]\n >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)\n >>> print(round(results["exact_match"], 2))\n 0.5\n\n\n >>> exact_match = evaluate.load("exact_match")\n >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n >>> preds = ["cat?", "theater", "yelling", "agent"]\n >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)\n >>> print(round(results["exact_match"], 2))\n 0.75\n\n >>> exact_match = evaluate.load("exact_match")\n >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n >>> preds = ["cat?", "theater", "yelling", "agent"]\n >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n >>> print(round(results["exact_match"], 2))\n 1.0\n\n >>> exact_match = evaluate.load("exact_match")\n >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]\n >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]\n >>> results = exact_match.compute(references=refs, predictions=preds)\n >>> print(round(results["exact_match"], 2))\n 0.33\n' +_CITATION = '\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class ExactMatch(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')}), reference_urls=[]) + + def _compute(self, predictions, references, regexes_to_ignore=None, ignore_case=False, ignore_punctuation=False, ignore_numbers=False): + if regexes_to_ignore is not None: + for s in regexes_to_ignore: + predictions = np.array([re.sub(s, '', x) for x in predictions]) + references = np.array([re.sub(s, '', x) for x in references]) + else: + predictions = np.asarray(predictions) + references = np.asarray(references) + if ignore_case: + predictions = np.char.lower(predictions) + references = np.char.lower(references) + if ignore_punctuation: + repl_table = string.punctuation.maketrans('', '', string.punctuation) + predictions = np.char.translate(predictions, table=repl_table) + references = np.char.translate(references, table=repl_table) + if ignore_numbers: + repl_table = string.digits.maketrans('', '', string.digits) + predictions = np.char.translate(predictions, table=repl_table) + references = np.char.translate(references, table=repl_table) + score_list = predictions == references + return {'exact_match': np.mean(score_list)} + +# File: evaluate-main/metrics/f1/f1.py +"""""" +import datasets +from sklearn.metrics import f1_score +import evaluate +_DESCRIPTION = '\nThe F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:\nF1 = 2 * (precision * recall) / (precision + recall)\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions (`list` of `int`): Predicted labels.\n references (`list` of `int`): Ground truth labels.\n labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.\n pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.\n average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.\n\n - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.\n - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.\n - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.\n - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.\n\nExamples:\n\n Example 1-A simple binary example\n >>> f1_metric = evaluate.load("f1")\n >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])\n >>> print(results)\n {\'f1\': 0.5}\n\n Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.\n >>> f1_metric = evaluate.load("f1")\n >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)\n >>> print(round(results[\'f1\'], 2))\n 0.67\n\n Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.\n >>> f1_metric = evaluate.load("f1")\n >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])\n >>> print(round(results[\'f1\'], 2))\n 0.35\n\n Example 4-A multiclass example, with different values for the `average` input.\n >>> predictions = [0, 2, 1, 0, 0, 1]\n >>> references = [0, 1, 2, 0, 1, 2]\n >>> results = f1_metric.compute(predictions=predictions, references=references, average="macro")\n >>> print(round(results[\'f1\'], 2))\n 0.27\n >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")\n >>> print(round(results[\'f1\'], 2))\n 0.33\n >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")\n >>> print(round(results[\'f1\'], 2))\n 0.27\n >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)\n >>> print(results)\n {\'f1\': array([0.8, 0. , 0. ])}\n\n Example 5-A multi-label example\n >>> f1_metric = evaluate.load("f1", "multilabel")\n >>> results = f1_metric.compute(predictions=[[0, 1, 1], [1, 1, 0]], references=[[0, 1, 1], [0, 1, 0]], average="macro")\n >>> print(round(results[\'f1\'], 2))\n 0.67\n' +_CITATION = '\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class F1(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('int32')), 'references': datasets.Sequence(datasets.Value('int32'))} if self.config_name == 'multilabel' else {'predictions': datasets.Value('int32'), 'references': datasets.Value('int32')}), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html']) + + def _compute(self, predictions, references, labels=None, pos_label=1, average='binary', sample_weight=None): + score = f1_score(references, predictions, labels=labels, pos_label=pos_label, average=average, sample_weight=sample_weight) + return {'f1': float(score) if score.size == 1 else score} + +# File: evaluate-main/metrics/frugalscore/frugalscore.py +"""""" +import datasets +import torch +from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments +import evaluate +_CITATION = '@article{eddine2021frugalscore,\n title={FrugalScore: Learning Cheaper, Lighter and Faster Evaluation Metrics for Automatic Text Generation},\n author={Eddine, Moussa Kamal and Shang, Guokan and Tixier, Antoine J-P and Vazirgiannis, Michalis},\n journal={arXiv preprint arXiv:2110.08559},\n year={2021}\n}\n' +_DESCRIPTION = 'FrugalScore is a reference-based metric for NLG models evaluation. It is based on a distillation approach that allows to learn a fixed, low cost version of any expensive NLG metric, while retaining most of its original performance.\n' +_KWARGS_DESCRIPTION = '\nCalculates how good are predictions given some references, using certain scores.\nArgs:\n predictions (list of str): list of predictions to score. Each predictions\n should be a string.\n references (list of str): list of reference for each prediction. Each\n reference should be a string.\n batch_size (int): the batch size for predictions.\n max_length (int): maximum sequence length.\n device (str): either gpu or cpu\nReturns:\n scores (list of int): list of scores.\nExamples:\n >>> frugalscore = evaluate.load("frugalscore")\n >>> results = frugalscore.compute(predictions=[\'hello there\', \'huggingface\'], references=[\'hello world\', \'hugging face\'])\n >>> print([round(s, 3) for s in results["scores"]])\n [0.631, 0.645]\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class FRUGALSCORE(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('string'), 'references': datasets.Value('string')}), homepage='https://github.com/moussaKam/FrugalScore') + + def _download_and_prepare(self, dl_manager): + if self.config_name == 'default': + checkpoint = 'moussaKam/frugalscore_tiny_bert-base_bert-score' + else: + checkpoint = self.config_name + self.model = AutoModelForSequenceClassification.from_pretrained(checkpoint) + self.tokenizer = AutoTokenizer.from_pretrained(checkpoint) + + def _compute(self, predictions, references, batch_size=32, max_length=128, device=None): + assert len(predictions) == len(references), 'predictions and references should have the same number of sentences.' + if device is not None: + assert device in ['gpu', 'cpu'], 'device should be either gpu or cpu.' + else: + device = 'gpu' if torch.cuda.is_available() else 'cpu' + training_args = TrainingArguments('trainer', fp16=device == 'gpu', per_device_eval_batch_size=batch_size, report_to='all', no_cuda=device == 'cpu', log_level='warning') + dataset = {'sentence1': predictions, 'sentence2': references} + raw_datasets = datasets.Dataset.from_dict(dataset) + + def tokenize_function(data): + return self.tokenizer(data['sentence1'], data['sentence2'], max_length=max_length, truncation=True, padding=True) + tokenized_datasets = raw_datasets.map(tokenize_function, batched=True) + tokenized_datasets.remove_columns(['sentence1', 'sentence2']) + trainer = Trainer(self.model, training_args, tokenizer=self.tokenizer) + predictions = trainer.predict(tokenized_datasets) + return {'scores': list(predictions.predictions.squeeze(-1))} + +# File: evaluate-main/metrics/glue/glue.py +"""""" +import datasets +from scipy.stats import pearsonr, spearmanr +from sklearn.metrics import f1_score, matthews_corrcoef +import evaluate +_CITATION = '@inproceedings{wang2019glue,\n title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},\n author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},\n note={In the Proceedings of ICLR.},\n year={2019}\n}\n' +_DESCRIPTION = 'GLUE, the General Language Understanding Evaluation benchmark\n(https://gluebenchmark.com/) is a collection of resources for training,\nevaluating, and analyzing natural language understanding systems.\n' +_KWARGS_DESCRIPTION = '\nCompute GLUE evaluation metric associated to each GLUE 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.\nReturns: depending on the GLUE subset, one or several of:\n "accuracy": Accuracy\n "f1": F1 score\n "pearson": Pearson Correlation\n "spearmanr": Spearman Correlation\n "matthews_correlation": Matthew Correlation\nExamples:\n\n >>> glue_metric = evaluate.load(\'glue\', \'sst2\') # \'sst2\' or any of ["mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]\n >>> references = [0, 1]\n >>> predictions = [0, 1]\n >>> results = glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'accuracy\': 1.0}\n\n >>> glue_metric = evaluate.load(\'glue\', \'mrpc\') # \'mrpc\' or \'qqp\'\n >>> references = [0, 1]\n >>> predictions = [0, 1]\n >>> results = glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'accuracy\': 1.0, \'f1\': 1.0}\n\n >>> glue_metric = evaluate.load(\'glue\', \'stsb\')\n >>> references = [0., 1., 2., 3., 4., 5.]\n >>> predictions = [0., 1., 2., 3., 4., 5.]\n >>> results = glue_metric.compute(predictions=predictions, references=references)\n >>> print({"pearson": round(results["pearson"], 2), "spearmanr": round(results["spearmanr"], 2)})\n {\'pearson\': 1.0, \'spearmanr\': 1.0}\n\n >>> glue_metric = evaluate.load(\'glue\', \'cola\')\n >>> references = [0, 1]\n >>> predictions = [0, 1]\n >>> results = glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'matthews_correlation\': 1.0}\n' + +def simple_accuracy(preds, labels): + return float((preds == labels).mean()) + +def acc_and_f1(preds, labels): + acc = simple_accuracy(preds, labels) + f1 = float(f1_score(y_true=labels, y_pred=preds)) + return {'accuracy': acc, 'f1': f1} + +def pearson_and_spearman(preds, labels): + pearson_corr = float(pearsonr(preds, labels)[0]) + spearman_corr = float(spearmanr(preds, labels)[0]) + return {'pearson': pearson_corr, 'spearmanr': spearman_corr} + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Glue(evaluate.Metric): + + def _info(self): + if self.config_name not in ['sst2', 'mnli', 'mnli_mismatched', 'mnli_matched', 'cola', 'stsb', 'mrpc', 'qqp', 'qnli', 'rte', 'wnli', 'hans']: + raise KeyError('You should supply a configuration name selected in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]') + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'), 'references': datasets.Value('int64' if self.config_name != 'stsb' else 'float32')}), codebase_urls=[], reference_urls=[], format='numpy') + + def _compute(self, predictions, references): + if self.config_name == 'cola': + return {'matthews_correlation': matthews_corrcoef(references, predictions)} + elif self.config_name == 'stsb': + return pearson_and_spearman(predictions, references) + elif self.config_name in ['mrpc', 'qqp']: + return acc_and_f1(predictions, references) + elif self.config_name in ['sst2', 'mnli', 'mnli_mismatched', 'mnli_matched', 'qnli', 'rte', 'wnli', 'hans']: + return {'accuracy': simple_accuracy(predictions, references)} + else: + raise KeyError('You should supply a configuration name selected in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]') + +# File: evaluate-main/metrics/google_bleu/google_bleu.py +"""""" +from typing import Dict, List +import datasets +from nltk.translate import gleu_score +import evaluate +from evaluate import MetricInfo +from .tokenizer_13a import Tokenizer13a +_CITATION = "@misc{wu2016googles,\n title={Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},\n author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey\n and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin\n Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto\n Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and\n Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes\n and Jeffrey Dean},\n year={2016},\n eprint={1609.08144},\n archivePrefix={arXiv},\n primaryClass={cs.CL}\n}\n" +_DESCRIPTION = "The BLEU score has some undesirable properties when used for single\nsentences, as it was designed to be a corpus measure. We therefore\nuse a slightly different score for our RL experiments which we call\nthe 'GLEU score'. For the GLEU score, we record all sub-sequences of\n1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then\ncompute a recall, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the target (ground truth) sequence,\nand a precision, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the generated output sequence. Then\nGLEU score is simply the minimum of recall and precision. This GLEU\nscore's range is always between 0 (no matches) and 1 (all match) and\nit is symmetrical when switching output and target. According to\nour experiments, GLEU score correlates quite well with the BLEU\nmetric on a corpus level but does not have its drawbacks for our per\nsentence reward objective.\n" +_KWARGS_DESCRIPTION = 'Computes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.\nInstead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching\ntokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.\n\nArgs:\n predictions (list of str): list of translations to score.\n references (list of list of str): list of lists of references for each translation.\n tokenizer : approach used for tokenizing `predictions` and `references`.\n The default tokenizer is `tokenizer_13a`, a minimal tokenization approach that is equivalent to `mteval-v13a`, used by WMT.\n This can be replaced by any function that takes a string as input and returns a list of tokens as output.\n min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.\n max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.\n\nReturns:\n \'google_bleu\': google_bleu score\n\nExamples:\n Example 1:\n >>> predictions = [\'It is a guide to action which ensures that the rubber duck always disobeys the commands of the cat\', \'he read the book because he was interested in world history\']\n >>> references = [[\'It is the guiding principle which guarantees the rubber duck forces never being under the command of the cat\'], [\'he was interested in world history because he read the book\']]\n >>> google_bleu = evaluate.load("google_bleu")\n >>> results = google_bleu.compute(predictions=predictions, references=references)\n >>> print(round(results["google_bleu"], 2))\n 0.44\n\n Example 2:\n >>> predictions = [\'It is a guide to action which ensures that the rubber duck always disobeys the commands of the cat\', \'he read the book because he was interested in world history\']\n >>> references = [[\'It is the guiding principle which guarantees the rubber duck forces never being under the command of the cat\', \'It is a guide to action that ensures that the rubber duck will never heed the cat commands\', \'It is the practical guide for the rubber duck army never to heed the directions of the cat\'], [\'he was interested in world history because he read the book\']]\n >>> google_bleu = evaluate.load("google_bleu")\n >>> results = google_bleu.compute(predictions=predictions, references=references)\n >>> print(round(results["google_bleu"], 2))\n 0.61\n\n Example 3:\n >>> predictions = [\'It is a guide to action which ensures that the rubber duck always disobeys the commands of the cat\', \'he read the book because he was interested in world history\']\n >>> references = [[\'It is the guiding principle which guarantees the rubber duck forces never being under the command of the cat\', \'It is a guide to action that ensures that the rubber duck will never heed the cat commands\', \'It is the practical guide for the rubber duck army never to heed the directions of the cat\'], [\'he was interested in world history because he read the book\']]\n >>> google_bleu = evaluate.load("google_bleu")\n >>> results = google_bleu.compute(predictions=predictions, references=references, min_len=2)\n >>> print(round(results["google_bleu"], 2))\n 0.53\n\n Example 4:\n >>> predictions = [\'It is a guide to action which ensures that the rubber duck always disobeys the commands of the cat\', \'he read the book because he was interested in world history\']\n >>> references = [[\'It is the guiding principle which guarantees the rubber duck forces never being under the command of the cat\', \'It is a guide to action that ensures that the rubber duck will never heed the cat commands\', \'It is the practical guide for the rubber duck army never to heed the directions of the cat\'], [\'he was interested in world history because he read the book\']]\n >>> google_bleu = evaluate.load("google_bleu")\n >>> results = google_bleu.compute(predictions=predictions,references=references, min_len=2, max_len=6)\n >>> print(round(results["google_bleu"], 2))\n 0.4\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class GoogleBleu(evaluate.Metric): + + def _info(self) -> MetricInfo: + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'), id='references')}), datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')})]) + + def _compute(self, predictions: List[str], references: List[List[str]], tokenizer=Tokenizer13a(), min_len: int=1, max_len: int=4) -> Dict[str, float]: + if isinstance(references[0], str): + references = [[ref] for ref in references] + references = [[tokenizer(r) for r in ref] for ref in references] + predictions = [tokenizer(p) for p in predictions] + return {'google_bleu': gleu_score.corpus_gleu(list_of_references=references, hypotheses=predictions, min_len=min_len, max_len=max_len)} + +# File: evaluate-main/metrics/google_bleu/tokenizer_13a.py +import re +from functools import lru_cache + +class BaseTokenizer: + + def signature(self): + return 'none' + + def __call__(self, line): + return line + +class TokenizerRegexp(BaseTokenizer): + + def signature(self): + return 're' + + def __init__(self): + self._re = [(re.compile('([\\{-\\~\\[-\\` -\\&\\(-\\+\\:-\\@\\/])'), ' \\1 '), (re.compile('([^0-9])([\\.,])'), '\\1 \\2 '), (re.compile('([\\.,])([^0-9])'), ' \\1 \\2'), (re.compile('([0-9])(-)'), '\\1 \\2 ')] + + @lru_cache(maxsize=2 ** 16) + def __call__(self, line): + for (_re, repl) in self._re: + line = _re.sub(repl, line) + return line.split() + +class Tokenizer13a(BaseTokenizer): + + def signature(self): + return '13a' + + def __init__(self): + self._post_tokenizer = TokenizerRegexp() + + @lru_cache(maxsize=2 ** 16) + def __call__(self, line): + line = line.replace('', '') + line = line.replace('-\n', '') + line = line.replace('\n', ' ') + if '&' in line: + line = line.replace('"', '"') + line = line.replace('&', '&') + line = line.replace('<', '<') + line = line.replace('>', '>') + return self._post_tokenizer(f' {line} ') + +# File: evaluate-main/metrics/indic_glue/indic_glue.py +"""""" +import datasets +import numpy as np +from scipy.spatial.distance import cdist +from scipy.stats import pearsonr, spearmanr +from sklearn.metrics import f1_score +import evaluate +_CITATION = ' @inproceedings{kakwani2020indicnlpsuite,\n title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n year={2020},\n booktitle={Findings of EMNLP},\n}\n' +_DESCRIPTION = ' IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n' +_KWARGS_DESCRIPTION = '\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n predictions: list of predictions to score (as int64),\n except for \'cvit-mkb-clsr\' where each prediction is a vector (of float32).\n references: list of ground truth labels corresponding to the predictions (as int64),\n except for \'cvit-mkb-clsr\' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n "accuracy": Accuracy\n "f1": F1 score\n "precision": Precision@10\nExamples:\n\n >>> indic_glue_metric = evaluate.load(\'indic_glue\', \'wnli\') # \'wnli\' or any of ["copa", "sna", "csqa", "wstp", "inltkh", "bbca", "iitp-mr", "iitp-pr", "actsa-sc", "md"]\n >>> references = [0, 1]\n >>> predictions = [0, 1]\n >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'accuracy\': 1.0}\n\n >>> indic_glue_metric = evaluate.load(\'indic_glue\', \'wiki-ner\')\n >>> references = [0, 1]\n >>> predictions = [0, 1]\n >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'accuracy\': 1.0, \'f1\': 1.0}\n\n >>> indic_glue_metric = evaluate.load(\'indic_glue\', \'cvit-mkb-clsr\')\n >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'precision@10\': 1.0}\n\n' + +def simple_accuracy(preds, labels): + return float((preds == labels).mean()) + +def acc_and_f1(preds, labels): + acc = simple_accuracy(preds, labels) + f1 = float(f1_score(y_true=labels, y_pred=preds)) + return {'accuracy': acc, 'f1': f1} + +def precision_at_10(en_sentvecs, in_sentvecs): + en_sentvecs = np.array(en_sentvecs) + in_sentvecs = np.array(in_sentvecs) + n = en_sentvecs.shape[0] + en_sentvecs = en_sentvecs - np.mean(en_sentvecs, axis=0) + in_sentvecs = in_sentvecs - np.mean(in_sentvecs, axis=0) + sim = cdist(en_sentvecs, in_sentvecs, 'cosine') + actual = np.array(range(n)) + preds = sim.argsort(axis=1)[:, :10] + matches = np.any(preds == actual[:, None], axis=1) + return float(matches.mean()) + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class IndicGlue(evaluate.Metric): + + def _info(self): + if self.config_name not in ['wnli', 'copa', 'sna', 'csqa', 'wstp', 'inltkh', 'bbca', 'cvit-mkb-clsr', 'iitp-mr', 'iitp-pr', 'actsa-sc', 'md', 'wiki-ner']: + raise KeyError('You should supply a configuration name selected in ["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", "cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", "wiki-ner"]') + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('int64') if self.config_name != 'cvit-mkb-clsr' else datasets.Sequence(datasets.Value('float32')), 'references': datasets.Value('int64') if self.config_name != 'cvit-mkb-clsr' else datasets.Sequence(datasets.Value('float32'))}), codebase_urls=[], reference_urls=[], format='numpy' if self.config_name != 'cvit-mkb-clsr' else None) + + def _compute(self, predictions, references): + if self.config_name == 'cvit-mkb-clsr': + return {'precision@10': precision_at_10(predictions, references)} + elif self.config_name in ['wiki-ner']: + return acc_and_f1(predictions, references) + elif self.config_name in ['wnli', 'copa', 'sna', 'csqa', 'wstp', 'inltkh', 'bbca', 'iitp-mr', 'iitp-pr', 'actsa-sc', 'md']: + return {'accuracy': simple_accuracy(predictions, references)} + else: + raise KeyError('You should supply a configuration name selected in ["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", "cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", "wiki-ner"]') + +# File: evaluate-main/metrics/mae/mae.py +"""""" +import datasets +from sklearn.metrics import mean_absolute_error +import evaluate +_CITATION = '@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' +_DESCRIPTION = 'Mean Absolute Error (MAE) is the mean of the magnitude of difference between the predicted and actual\nvalues.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Estimated target values.\n references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Ground truth (correct) target values.\n sample_weight: array-like of shape (n_samples,), default=None\n Sample weights.\n multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n "raw_values" : Returns a full set of errors in case of multioutput input.\n\n "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\nReturns:\n mae : mean absolute error.\n If multioutput is "raw_values", then mean absolute error is returned for each output separately. If multioutput is "uniform_average" or an ndarray of weights, then the weighted average of all output errors is returned.\n MAE output is non-negative floating point. The best value is 0.0.\nExamples:\n\n >>> mae_metric = evaluate.load("mae")\n >>> predictions = [2.5, 0.0, 2, 8]\n >>> references = [3, -0.5, 2, 7]\n >>> results = mae_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'mae\': 0.5}\n\n If you\'re using multi-dimensional lists, then set the config as follows :\n\n >>> mae_metric = evaluate.load("mae", "multilist")\n >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n >>> references = [[0, 2], [-1, 2], [8, -5]]\n >>> results = mae_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'mae\': 0.75}\n >>> results = mae_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n >>> print(results)\n {\'mae\': array([0.5, 1. ])}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Mae(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features(self._get_feature_types()), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_error.html']) + + def _get_feature_types(self): + if self.config_name == 'multilist': + return {'predictions': datasets.Sequence(datasets.Value('float')), 'references': datasets.Sequence(datasets.Value('float'))} + else: + return {'predictions': datasets.Value('float'), 'references': datasets.Value('float')} + + def _compute(self, predictions, references, sample_weight=None, multioutput='uniform_average'): + mae_score = mean_absolute_error(references, predictions, sample_weight=sample_weight, multioutput=multioutput) + return {'mae': mae_score} + +# File: evaluate-main/metrics/mahalanobis/mahalanobis.py +"""""" +import datasets +import numpy as np +import evaluate +_DESCRIPTION = '\nCompute the Mahalanobis Distance\n\nMahalonobis distance is the distance between a point and a distribution.\nAnd not between two distinct points. It is effectively a multivariate equivalent of the Euclidean distance.\nIt was introduced by Prof. P. C. Mahalanobis in 1936\nand has been used in various statistical applications ever since\n[source: https://www.machinelearningplus.com/statistics/mahalanobis-distance/]\n' +_CITATION = "@article{de2000mahalanobis,\n title={The mahalanobis distance},\n author={De Maesschalck, Roy and Jouan-Rimbaud, Delphine and Massart, D{'e}sir{'e} L},\n journal={Chemometrics and intelligent laboratory systems},\n volume={50},\n number={1},\n pages={1--18},\n year={2000},\n publisher={Elsevier}\n}\n" +_KWARGS_DESCRIPTION = '\nArgs:\n X: List of datapoints to be compared with the `reference_distribution`.\n reference_distribution: List of datapoints from the reference distribution we want to compare to.\nReturns:\n mahalanobis: The Mahalonobis distance for each datapoint in `X`.\nExamples:\n\n >>> mahalanobis_metric = evaluate.load("mahalanobis")\n >>> results = mahalanobis_metric.compute(reference_distribution=[[0, 1], [1, 0]], X=[[0, 1]])\n >>> print(results)\n {\'mahalanobis\': array([0.5])}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Mahalanobis(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'X': datasets.Sequence(datasets.Value('float', id='sequence'), id='X')})) + + def _compute(self, X, reference_distribution): + X = np.array(X) + reference_distribution = np.array(reference_distribution) + if len(X.shape) != 2: + raise ValueError('Expected `X` to be a 2D vector') + if len(reference_distribution.shape) != 2: + raise ValueError('Expected `reference_distribution` to be a 2D vector') + if reference_distribution.shape[0] < 2: + raise ValueError('Expected `reference_distribution` to be a 2D vector with more than one element in the first dimension') + X_minus_mu = X - np.mean(reference_distribution) + cov = np.cov(reference_distribution.T) + try: + inv_covmat = np.linalg.inv(cov) + except np.linalg.LinAlgError: + inv_covmat = np.linalg.pinv(cov) + left_term = np.dot(X_minus_mu, inv_covmat) + mahal_dist = np.dot(left_term, X_minus_mu.T).diagonal() + return {'mahalanobis': mahal_dist} + +# File: evaluate-main/metrics/mape/mape.py +"""""" +import datasets +from sklearn.metrics import mean_absolute_percentage_error +import evaluate +_CITATION = '@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' +_DESCRIPTION = 'Mean Absolute Percentage Error (MAPE) is the mean percentage error difference between the predicted and actual\nvalues.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Estimated target values.\n references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Ground truth (correct) target values.\n sample_weight: array-like of shape (n_samples,), default=None\n Sample weights.\n multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n "raw_values" : Returns a full set of errors in case of multioutput input.\n\n "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\nReturns:\n mape : mean absolute percentage error.\n If multioutput is "raw_values", then mean absolute percentage error is returned for each output separately. If multioutput is "uniform_average" or an ndarray of weights, then the weighted average of all output errors is returned.\n MAPE output is non-negative floating point. The best value is 0.0.\nExamples:\n\n >>> mape_metric = evaluate.load("mape")\n >>> predictions = [2.5, 0.0, 2, 8]\n >>> references = [3, -0.5, 2, 7]\n >>> results = mape_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'mape\': 0.3273809523809524}\n\n If you\'re using multi-dimensional lists, then set the config as follows :\n\n >>> mape_metric = evaluate.load("mape", "multilist")\n >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n >>> references = [[0.1, 2], [-1, 2], [8, -5]]\n >>> results = mape_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'mape\': 0.8874999875823658}\n >>> results = mape_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n >>> print(results)\n {\'mape\': array([1.37499998, 0.4 ])}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Mape(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features(self._get_feature_types()), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_percentage_error.html']) + + def _get_feature_types(self): + if self.config_name == 'multilist': + return {'predictions': datasets.Sequence(datasets.Value('float')), 'references': datasets.Sequence(datasets.Value('float'))} + else: + return {'predictions': datasets.Value('float'), 'references': datasets.Value('float')} + + def _compute(self, predictions, references, sample_weight=None, multioutput='uniform_average'): + mape_score = mean_absolute_percentage_error(references, predictions, sample_weight=sample_weight, multioutput=multioutput) + return {'mape': mape_score} + +# File: evaluate-main/metrics/mase/mase.py +"""""" +import datasets +import numpy as np +from sklearn.metrics import mean_absolute_error +import evaluate +_CITATION = '@article{HYNDMAN2006679,\n title = {Another look at measures of forecast accuracy},\n journal = {International Journal of Forecasting},\n volume = {22},\n number = {4},\n pages = {679--688},\n year = {2006},\n issn = {0169-2070},\n doi = {https://doi.org/10.1016/j.ijforecast.2006.03.001},\n url = {https://www.sciencedirect.com/science/article/pii/S0169207006000239},\n author = {Rob J. Hyndman and Anne B. Koehler},\n}\n' +_DESCRIPTION = 'Mean Absolute Scaled Error (MASE) is the mean absolute error of the forecast values, divided by the mean absolute error of the in-sample one-step naive forecast.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Estimated target values.\n references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Ground truth (correct) target values.\n training: array-like of shape (n_train_samples,) or (n_train_samples, n_outputs)\n In sample training data for naive forecast.\n periodicity: int, default=1\n Seasonal periodicity of training data.\n sample_weight: array-like of shape (n_samples,), default=None\n Sample weights.\n multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n "raw_values" : Returns a full set of errors in case of multioutput input.\n\n "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\nReturns:\n mase : mean absolute scaled error.\n If multioutput is "raw_values", then mean absolute percentage error is returned for each output separately. If multioutput is "uniform_average" or an ndarray of weights, then the weighted average of all output errors is returned.\n MASE output is non-negative floating point. The best value is 0.0.\nExamples:\n\n >>> mase_metric = evaluate.load("mase")\n >>> predictions = [2.5, 0.0, 2, 8, 1.25]\n >>> references = [3, -0.5, 2, 7, 2]\n >>> training = [5, 0.5, 4, 6, 3, 5, 2]\n >>> results = mase_metric.compute(predictions=predictions, references=references, training=training)\n >>> print(results)\n {\'mase\': 0.18333333333333335}\n\n If you\'re using multi-dimensional lists, then set the config as follows :\n\n >>> mase_metric = evaluate.load("mase", "multilist")\n >>> predictions = [[0, 2], [-1, 2], [8, -5]]\n >>> references = [[0.5, 1], [-1, 1], [7, -6]]\n >>> training = [[0.5, 1], [-1, 1], [7, -6]]\n >>> results = mase_metric.compute(predictions=predictions, references=references, training=training)\n >>> print(results)\n {\'mase\': 0.18181818181818182}\n >>> results = mase_metric.compute(predictions=predictions, references=references, training=training, multioutput=\'raw_values\')\n >>> print(results)\n {\'mase\': array([0.10526316, 0.28571429])}\n >>> results = mase_metric.compute(predictions=predictions, references=references, training=training, multioutput=[0.3, 0.7])\n >>> print(results)\n {\'mase\': 0.21935483870967742}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Mase(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features(self._get_feature_types()), reference_urls=['https://otexts.com/fpp3/accuracy.html#scaled-errors']) + + def _get_feature_types(self): + if self.config_name == 'multilist': + return {'predictions': datasets.Sequence(datasets.Value('float')), 'references': datasets.Sequence(datasets.Value('float'))} + else: + return {'predictions': datasets.Value('float'), 'references': datasets.Value('float')} + + def _compute(self, predictions, references, training, periodicity=1, sample_weight=None, multioutput='uniform_average'): + y_pred_naive = training[:-periodicity] + mae_naive = mean_absolute_error(training[periodicity:], y_pred_naive, multioutput=multioutput) + mae_score = mean_absolute_error(references, predictions, sample_weight=sample_weight, multioutput=multioutput) + epsilon = np.finfo(np.float64).eps + mase_score = mae_score / np.maximum(mae_naive, epsilon) + return {'mase': mase_score} + +# File: evaluate-main/metrics/matthews_correlation/matthews_correlation.py +"""""" +import datasets +import numpy as np +from sklearn.metrics import matthews_corrcoef +import evaluate +_DESCRIPTION = '\nCompute the Matthews correlation coefficient (MCC)\n\nThe Matthews correlation coefficient is used in machine learning as a\nmeasure of the quality of binary and multiclass classifications. It takes\ninto account true and false positives and negatives and is generally\nregarded as a balanced measure which can be used even if the classes are of\nvery different sizes. The MCC is in essence a correlation coefficient value\nbetween -1 and +1. A coefficient of +1 represents a perfect prediction, 0\nan average random prediction and -1 an inverse prediction. The statistic\nis also known as the phi coefficient. [source: Wikipedia]\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions (list of int): Predicted labels, as returned by a model.\n references (list of int): Ground truth labels.\n average (`string`): This parameter is used for multilabel configs. Defaults to `None`.\n - None (default): Returns an array of Matthews correlation coefficients, one for each feature\n - \'macro\': Calculate metrics for each feature, and find their unweighted mean.\n sample_weight (list of int, float, or bool): Sample weights. Defaults to `None`.\nReturns:\n matthews_correlation (dict containing float): Matthews correlation.\nExamples:\n Example 1, a basic example with only predictions and references as inputs:\n >>> matthews_metric = evaluate.load("matthews_correlation")\n >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n ... predictions=[1, 2, 2, 0, 3, 3])\n >>> print(round(results[\'matthews_correlation\'], 2))\n 0.54\n\n Example 2, the same example as above, but also including sample weights:\n >>> matthews_metric = evaluate.load("matthews_correlation")\n >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n ... predictions=[1, 2, 2, 0, 3, 3],\n ... sample_weight=[0.5, 3, 1, 1, 1, 2])\n >>> print(round(results[\'matthews_correlation\'], 2))\n 0.1\n\n Example 3, the same example as above, but with sample weights that cause a negative correlation:\n >>> matthews_metric = evaluate.load("matthews_correlation")\n >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n ... predictions=[1, 2, 2, 0, 3, 3],\n ... sample_weight=[0.5, 1, 0, 0, 0, 1])\n >>> print(round(results[\'matthews_correlation\'], 2))\n -0.25\n\n Example 4, Multi-label without averaging:\n >>> matthews_metric = evaluate.load("matthews_correlation", config_name="multilabel")\n >>> results = matthews_metric.compute(references=[[0,1], [1,0], [1,1]],\n ... predictions=[[0,1], [1,1], [0,1]])\n >>> print(results[\'matthews_correlation\'])\n [0.5, 0.0]\n\n Example 5, Multi-label with averaging:\n >>> matthews_metric = evaluate.load("matthews_correlation", config_name="multilabel")\n >>> results = matthews_metric.compute(references=[[0,1], [1,0], [1,1]],\n ... predictions=[[0,1], [1,1], [0,1]],\n ... average=\'macro\')\n >>> print(round(results[\'matthews_correlation\'], 2))\n 0.25\n' +_CITATION = '@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class MatthewsCorrelation(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('int32')), 'references': datasets.Sequence(datasets.Value('int32'))} if self.config_name == 'multilabel' else {'predictions': datasets.Value('int32'), 'references': datasets.Value('int32')}), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html']) + + def _compute(self, predictions, references, sample_weight=None, average=None): + if self.config_name == 'multilabel': + references = np.array(references) + predictions = np.array(predictions) + if not (references.ndim == 2 and predictions.ndim == 2): + raise ValueError('For multi-label inputs, both references and predictions should be 2-dimensional') + matthews_corr = [matthews_corrcoef(predictions[:, i], references[:, i], sample_weight=sample_weight) for i in range(references.shape[1])] + if average == 'macro': + matthews_corr = np.mean(matthews_corr) + elif average is not None: + raise ValueError('Invalid `average`: expected `macro`, or None ') + else: + matthews_corr = float(matthews_corrcoef(references, predictions, sample_weight=sample_weight)) + return {'matthews_correlation': matthews_corr} + +# File: evaluate-main/metrics/mauve/mauve.py +"""""" +import datasets +import faiss +import numpy +import requests +import sklearn +import tqdm +from mauve import compute_mauve +import evaluate +_CITATION = '@inproceedings{pillutla-etal:mauve:neurips2021,\n title={{MAUVE: Measuring the Gap Between Neural Text and Human Text using Divergence Frontiers}},\n author={Pillutla, Krishna and Swayamdipta, Swabha and Zellers, Rowan and Thickstun, John and Welleck, Sean and Choi, Yejin and Harchaoui, Zaid},\n booktitle = {NeurIPS},\n year = {2021}\n}\n\n@article{pillutla-etal:mauve:arxiv2022,\n title={{MAUVE Scores for Generative Models: Theory and Practice}},\n author={Pillutla, Krishna and Liu, Lang and Thickstun, John and Welleck, Sean and Swayamdipta, Swabha and Zellers, Rowan and Oh, Sewoong and Choi, Yejin and Harchaoui, Zaid},\n journal={arXiv Preprint},\n year={2022}\n}\n' +_DESCRIPTION = 'MAUVE is a measure of the statistical gap between two text distributions, e.g., how far the text written by a model is the distribution of human text, using samples from both distributions.\n\nMAUVE is obtained by computing Kullback–Leibler (KL) divergences between the two distributions in a quantized embedding space of a large language model.\nIt can quantify differences in the quality of generated text based on the size of the model, the decoding algorithm, and the length of the generated text.\nMAUVE was found to correlate the strongest with human evaluations over baseline metrics for open-ended text generation.\n\nThis metrics is a wrapper around the official implementation of MAUVE:\nhttps://github.com/krishnap25/mauve\n' +_KWARGS_DESCRIPTION = '\nCalculates MAUVE scores between two lists of generated text and reference text.\nArgs:\n predictions: list of generated text to score. Each predictions\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\nOptional Args:\n num_buckets: the size of the histogram to quantize P and Q. Options: \'auto\' (default) or an integer\n pca_max_data: the number data points to use for PCA dimensionality reduction prior to clustering. If -1, use all the data. Default -1\n kmeans_explained_var: amount of variance of the data to keep in dimensionality reduction by PCA. Default 0.9\n kmeans_num_redo: number of times to redo k-means clustering (the best objective is kept). Default 5\n kmeans_max_iter: maximum number of k-means iterations. Default 500\n featurize_model_name: name of the model from which features are obtained. Default \'gpt2-large\' Use one of [\'gpt2\', \'gpt2-medium\', \'gpt2-large\', \'gpt2-xl\'].\n device_id: Device for featurization. Supply a GPU id (e.g. 0 or 3) to use GPU. If no GPU with this id is found, use CPU\n max_text_length: maximum number of tokens to consider. Default 1024\n divergence_curve_discretization_size: Number of points to consider on the divergence curve. Default 25\n mauve_scaling_factor: "c" from the paper. Default 5.\n verbose: If True (default), print running time updates\n seed: random seed to initialize k-means cluster assignments.\nReturns:\n mauve: MAUVE score, a number between 0 and 1. Larger values indicate that P and Q are closer,\n frontier_integral: Frontier Integral, a number between 0 and 1. Smaller values indicate that P and Q are closer,\n divergence_curve: a numpy.ndarray of shape (m, 2); plot it with matplotlib to view the divergence curve,\n p_hist: a discrete distribution, which is a quantized version of the text distribution p_text,\n q_hist: same as above, but with q_text.\nExamples:\n\n >>> # faiss segfaults in doctest for some reason, so the .compute call is not tested with doctest\n >>> import evaluate\n >>> mauve = evaluate.load(\'mauve\')\n >>> predictions = ["hello there", "general kenobi"]\n >>> references = ["hello there", "general kenobi"]\n >>> out = mauve.compute(predictions=predictions, references=references) # doctest: +SKIP\n >>> print(out.mauve) # doctest: +SKIP\n 1.0\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Mauve(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, homepage='https://github.com/krishnap25/mauve', inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')}), codebase_urls=['https://github.com/krishnap25/mauve'], reference_urls=['https://arxiv.org/abs/2102.01454', 'https://github.com/krishnap25/mauve']) + + def _compute(self, predictions, references, p_features=None, q_features=None, p_tokens=None, q_tokens=None, num_buckets='auto', pca_max_data=-1, kmeans_explained_var=0.9, kmeans_num_redo=5, kmeans_max_iter=500, featurize_model_name='gpt2-large', device_id=-1, max_text_length=1024, divergence_curve_discretization_size=25, mauve_scaling_factor=5, verbose=True, seed=25): + out = compute_mauve(p_text=predictions, q_text=references, p_features=p_features, q_features=q_features, p_tokens=p_tokens, q_tokens=q_tokens, num_buckets=num_buckets, pca_max_data=pca_max_data, kmeans_explained_var=kmeans_explained_var, kmeans_num_redo=kmeans_num_redo, kmeans_max_iter=kmeans_max_iter, featurize_model_name=featurize_model_name, device_id=device_id, max_text_length=max_text_length, divergence_curve_discretization_size=divergence_curve_discretization_size, mauve_scaling_factor=mauve_scaling_factor, verbose=verbose, seed=seed) + return out + +# File: evaluate-main/metrics/mean_iou/mean_iou.py +"""""" +from typing import Dict, Optional +import datasets +import numpy as np +import evaluate +_DESCRIPTION = '\nIoU is the area of overlap between the predicted segmentation and the ground truth divided by the area of union\nbetween the predicted segmentation and the ground truth. For binary (two classes) or multi-class segmentation,\nthe mean IoU of the image is calculated by taking the IoU of each class and averaging them.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions (`List[ndarray]`):\n List of predicted segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.\n references (`List[ndarray]`):\n List of ground truth segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.\n num_labels (`int`):\n Number of classes (categories).\n ignore_index (`int`):\n Index that will be ignored during evaluation.\n nan_to_num (`int`, *optional*):\n If specified, NaN values will be replaced by the number defined by the user.\n label_map (`dict`, *optional*):\n If specified, dictionary mapping old label indices to new label indices.\n reduce_labels (`bool`, *optional*, defaults to `False`):\n Whether or not to reduce all label values of segmentation maps by 1. Usually used for datasets where 0 is used for background,\n and background itself is not included in all classes of a dataset (e.g. ADE20k). The background label will be replaced by 255.\n\nReturns:\n `Dict[str, float | ndarray]` comprising various elements:\n - *mean_iou* (`float`):\n Mean Intersection-over-Union (IoU averaged over all categories).\n - *mean_accuracy* (`float`):\n Mean accuracy (averaged over all categories).\n - *overall_accuracy* (`float`):\n Overall accuracy on all images.\n - *per_category_accuracy* (`ndarray` of shape `(num_labels,)`):\n Per category accuracy.\n - *per_category_iou* (`ndarray` of shape `(num_labels,)`):\n Per category IoU.\n\nExamples:\n\n >>> import numpy as np\n\n >>> mean_iou = evaluate.load("mean_iou")\n\n >>> # suppose one has 3 different segmentation maps predicted\n >>> predicted_1 = np.array([[1, 2], [3, 4], [5, 255]])\n >>> actual_1 = np.array([[0, 3], [5, 4], [6, 255]])\n\n >>> predicted_2 = np.array([[2, 7], [9, 2], [3, 6]])\n >>> actual_2 = np.array([[1, 7], [9, 2], [3, 6]])\n\n >>> predicted_3 = np.array([[2, 2, 3], [8, 2, 4], [3, 255, 2]])\n >>> actual_3 = np.array([[1, 2, 2], [8, 2, 1], [3, 255, 1]])\n\n >>> predicted = [predicted_1, predicted_2, predicted_3]\n >>> ground_truth = [actual_1, actual_2, actual_3]\n\n >>> results = mean_iou.compute(predictions=predicted, references=ground_truth, num_labels=10, ignore_index=255, reduce_labels=False)\n >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n {\'mean_iou\': 0.47750000000000004, \'mean_accuracy\': 0.5916666666666666, \'overall_accuracy\': 0.5263157894736842, \'per_category_iou\': array([0. , 0. , 0.375, 0.4 , 0.5 , 0. , 0.5 , 1. , 1. , 1. ]), \'per_category_accuracy\': array([0. , 0. , 0.75 , 0.66666667, 1. , 0. , 0.5 , 1. , 1. , 1. ])}\n' +_CITATION = '@software{MMSegmentation_Contributors_OpenMMLab_Semantic_Segmentation_2020,\nauthor = {{MMSegmentation Contributors}},\nlicense = {Apache-2.0},\nmonth = {7},\ntitle = {{OpenMMLab Semantic Segmentation Toolbox and Benchmark}},\nurl = {https://github.com/open-mmlab/mmsegmentation},\nyear = {2020}\n}' + +def intersect_and_union(pred_label, label, num_labels, ignore_index: bool, label_map: Optional[Dict[int, int]]=None, reduce_labels: bool=False): + if label_map is not None: + for (old_id, new_id) in label_map.items(): + label[label == old_id] = new_id + pred_label = np.array(pred_label) + label = np.array(label) + if reduce_labels: + label[label == 0] = 255 + label = label - 1 + label[label == 254] = 255 + mask = label != ignore_index + mask = np.not_equal(label, ignore_index) + pred_label = pred_label[mask] + label = np.array(label)[mask] + intersect = pred_label[pred_label == label] + area_intersect = np.histogram(intersect, bins=num_labels, range=(0, num_labels - 1))[0] + area_pred_label = np.histogram(pred_label, bins=num_labels, range=(0, num_labels - 1))[0] + area_label = np.histogram(label, bins=num_labels, range=(0, num_labels - 1))[0] + area_union = area_pred_label + area_label - area_intersect + return (area_intersect, area_union, area_pred_label, area_label) + +def total_intersect_and_union(results, gt_seg_maps, num_labels, ignore_index: bool, label_map: Optional[Dict[int, int]]=None, reduce_labels: bool=False): + total_area_intersect = np.zeros((num_labels,), dtype=np.float64) + total_area_union = np.zeros((num_labels,), dtype=np.float64) + total_area_pred_label = np.zeros((num_labels,), dtype=np.float64) + total_area_label = np.zeros((num_labels,), dtype=np.float64) + for (result, gt_seg_map) in zip(results, gt_seg_maps): + (area_intersect, area_union, area_pred_label, area_label) = intersect_and_union(result, gt_seg_map, num_labels, ignore_index, label_map, reduce_labels) + total_area_intersect += area_intersect + total_area_union += area_union + total_area_pred_label += area_pred_label + total_area_label += area_label + return (total_area_intersect, total_area_union, total_area_pred_label, total_area_label) + +def mean_iou(results, gt_seg_maps, num_labels, ignore_index: bool, nan_to_num: Optional[int]=None, label_map: Optional[Dict[int, int]]=None, reduce_labels: bool=False): + (total_area_intersect, total_area_union, total_area_pred_label, total_area_label) = total_intersect_and_union(results, gt_seg_maps, num_labels, ignore_index, label_map, reduce_labels) + metrics = dict() + all_acc = total_area_intersect.sum() / total_area_label.sum() + iou = total_area_intersect / total_area_union + acc = total_area_intersect / total_area_label + metrics['mean_iou'] = np.nanmean(iou) + metrics['mean_accuracy'] = np.nanmean(acc) + metrics['overall_accuracy'] = all_acc + metrics['per_category_iou'] = iou + metrics['per_category_accuracy'] = acc + if nan_to_num is not None: + metrics = dict({metric: np.nan_to_num(metric_value, nan=nan_to_num) for (metric, metric_value) in metrics.items()}) + return metrics + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class MeanIoU(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Image(), 'references': datasets.Image()}), reference_urls=['https://github.com/open-mmlab/mmsegmentation/blob/71c201b1813267d78764f306a297ca717827c4bf/mmseg/core/evaluation/metrics.py']) + + def _compute(self, predictions, references, num_labels: int, ignore_index: bool, nan_to_num: Optional[int]=None, label_map: Optional[Dict[int, int]]=None, reduce_labels: bool=False): + iou_result = mean_iou(results=predictions, gt_seg_maps=references, num_labels=num_labels, ignore_index=ignore_index, nan_to_num=nan_to_num, label_map=label_map, reduce_labels=reduce_labels) + return iou_result + +# File: evaluate-main/metrics/meteor/meteor.py +"""""" +import datasets +import numpy as np +from nltk.translate import meteor_score +from packaging import version +import evaluate +if evaluate.config.PY_VERSION < version.parse('3.8'): + import importlib_metadata +else: + import importlib.metadata as importlib_metadata +NLTK_VERSION = version.parse(importlib_metadata.version('nltk')) +if NLTK_VERSION >= version.Version('3.6.4'): + from nltk import word_tokenize +_CITATION = '@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n' +_DESCRIPTION = 'METEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n' +_KWARGS_DESCRIPTION = '\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n \'meteor\': meteor score.\nExamples:\n\n >>> meteor = evaluate.load(\'meteor\')\n >>> predictions = ["It is a guide to action which ensures that the military always obeys the commands of the party"]\n >>> references = ["It is a guide to action that ensures that the military will forever heed Party commands"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results["meteor"], 4))\n 0.6944\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Meteor(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'), id='references')}), datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')})], codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'], reference_urls=['https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR']) + + def _download_and_prepare(self, dl_manager): + import nltk + nltk.download('wordnet') + if NLTK_VERSION >= version.Version('3.9.0'): + nltk.download('punkt_tab') + elif NLTK_VERSION >= version.Version('3.6.5'): + nltk.download('punkt') + if NLTK_VERSION >= version.Version('3.6.6'): + nltk.download('omw-1.4') + + def _compute(self, predictions, references, alpha=0.9, beta=3, gamma=0.5): + multiple_refs = isinstance(references[0], list) + if NLTK_VERSION >= version.Version('3.6.5'): + if multiple_refs: + scores = [meteor_score.meteor_score([word_tokenize(ref) for ref in refs], word_tokenize(pred), alpha=alpha, beta=beta, gamma=gamma) for (refs, pred) in zip(references, predictions)] + else: + scores = [meteor_score.single_meteor_score(word_tokenize(ref), word_tokenize(pred), alpha=alpha, beta=beta, gamma=gamma) for (ref, pred) in zip(references, predictions)] + elif multiple_refs: + scores = [meteor_score.meteor_score([[word_tokenize(ref) for ref in group] for group in references][0], word_tokenize(pred), alpha=alpha, beta=beta, gamma=gamma) for (ref, pred) in zip(references, predictions)] + else: + scores = [meteor_score.single_meteor_score(ref, pred, alpha=alpha, beta=beta, gamma=gamma) for (ref, pred) in zip(references, predictions)] + return {'meteor': np.mean(scores)} + +# File: evaluate-main/metrics/mse/mse.py +"""""" +import datasets +from sklearn.metrics import mean_squared_error +import evaluate +_CITATION = '@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' +_DESCRIPTION = 'Mean Squared Error(MSE) is the average of the square of difference between the predicted\nand actual values.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Estimated target values.\n references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Ground truth (correct) target values.\n sample_weight: array-like of shape (n_samples,), default=None\n Sample weights.\n multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n "raw_values" : Returns a full set of errors in case of multioutput input.\n\n "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\n squared : bool, default=True\n If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.\n\nReturns:\n mse : mean squared error.\nExamples:\n\n >>> mse_metric = evaluate.load("mse")\n >>> predictions = [2.5, 0.0, 2, 8]\n >>> references = [3, -0.5, 2, 7]\n >>> results = mse_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'mse\': 0.375}\n >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)\n >>> print(rmse_result)\n {\'mse\': 0.6123724356957945}\n\n If you\'re using multi-dimensional lists, then set the config as follows :\n\n >>> mse_metric = evaluate.load("mse", "multilist")\n >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n >>> references = [[0, 2], [-1, 2], [8, -5]]\n >>> results = mse_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'mse\': 0.7083333333333334}\n >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n {\'mse\': array([0.41666667, 1. ])}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Mse(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features(self._get_feature_types()), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html']) + + def _get_feature_types(self): + if self.config_name == 'multilist': + return {'predictions': datasets.Sequence(datasets.Value('float')), 'references': datasets.Sequence(datasets.Value('float'))} + else: + return {'predictions': datasets.Value('float'), 'references': datasets.Value('float')} + + def _compute(self, predictions, references, sample_weight=None, multioutput='uniform_average', squared=True): + mse = mean_squared_error(references, predictions, sample_weight=sample_weight, multioutput=multioutput, squared=squared) + return {'mse': mse} + +# File: evaluate-main/metrics/nist_mt/nist_mt.py +"""""" +from typing import Dict, Optional +import datasets +import nltk +from datasets import Sequence, Value +try: + nltk.data.find('perluniprops') +except LookupError: + nltk.download('perluniprops', quiet=True) +from nltk.tokenize.nist import NISTTokenizer +from nltk.translate.nist_score import corpus_nist, sentence_nist +import evaluate +_CITATION = "@inproceedings{10.5555/1289189.1289273,\n author = {Doddington, George},\n title = {Automatic Evaluation of Machine Translation Quality Using N-Gram Co-Occurrence Statistics},\n year = {2002},\n publisher = {Morgan Kaufmann Publishers Inc.},\n address = {San Francisco, CA, USA},\n booktitle = {Proceedings of the Second International Conference on Human Language Technology Research},\n pages = {138–145},\n numpages = {8},\n location = {San Diego, California},\n series = {HLT '02}\n}\n" +_DESCRIPTION = "DARPA commissioned NIST to develop an MT evaluation facility based on the BLEU\nscore. The official script used by NIST to compute BLEU and NIST score is\nmteval-14.pl. The main differences are:\n\n - BLEU uses geometric mean of the ngram precisions, NIST uses arithmetic mean.\n - NIST has a different brevity penalty\n - NIST score from mteval-14.pl has a self-contained tokenizer (in the Hugging Face implementation we rely on NLTK's\nimplementation of the NIST-specific tokenizer)\n" +_KWARGS_DESCRIPTION = '\nComputes NIST score of translated segments against one or more references.\nArgs:\n predictions: predictions to score (list of str)\n references: potentially multiple references for each prediction (list of str or list of list of str)\n n: highest n-gram order\n lowercase: whether to lowercase the data (only applicable if \'western_lang\' is True)\n western_lang: whether the current language is a Western language, which will enable some specific tokenization\n rules with respect to, e.g., punctuation\n\nReturns:\n \'nist_mt\': nist_mt score\nExamples:\n >>> nist_mt = evaluate.load("nist_mt")\n >>> hypothesis = "It is a guide to action which ensures that the military always obeys the commands of the party"\n >>> reference1 = "It is a guide to action that ensures that the military will forever heed Party commands"\n >>> reference2 = "It is the guiding principle which guarantees the military forces always being under the command of the Party"\n >>> reference3 = "It is the practical guide for the army always to heed the directions of the party"\n >>> nist_mt.compute(predictions=[hypothesis], references=[[reference1, reference2, reference3]])\n {\'nist_mt\': 3.3709935957649324}\n >>> nist_mt.compute(predictions=[hypothesis], references=[reference1])\n {\'nist_mt\': 2.4477124183006533}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class NistMt(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(module_type='metric', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': Value('string', id='prediction'), 'references': Sequence(Value('string', id='reference'), id='references')}), datasets.Features({'predictions': Value('string', id='prediction'), 'references': Value('string', id='reference')})], homepage='https://www.nltk.org/api/nltk.translate.nist_score.html', codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/nist_score.py'], reference_urls=['https://en.wikipedia.org/wiki/NIST_(metric)']) + + def _compute(self, predictions, references, n: int=5, lowercase=False, western_lang=True): + tokenizer = NISTTokenizer() + if isinstance(references[0], str): + references = [[ref] for ref in references] + predictions = [tokenizer.tokenize(pred, return_str=False, lowercase=lowercase, western_lang=western_lang) for pred in predictions] + references = [[tokenizer.tokenize(ref, return_str=False, lowercase=lowercase, western_lang=western_lang) for ref in ref_sentences] for ref_sentences in references] + return {'nist_mt': corpus_nist(list_of_references=references, hypotheses=predictions, n=n)} + +# File: evaluate-main/metrics/pearsonr/pearsonr.py +"""""" +import datasets +from scipy.stats import pearsonr +import evaluate +_DESCRIPTION = '\nPearson correlation coefficient and p-value for testing non-correlation.\nThe Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases.\nThe p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions (`list` of `int`): Predicted class labels, as returned by a model.\n references (`list` of `int`): Ground truth labels.\n return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`.\n\nReturns:\n pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation.\n p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities.\n\nExamples:\n\n Example 1-A simple example using only predictions and references.\n >>> pearsonr_metric = evaluate.load("pearsonr")\n >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5])\n >>> print(round(results[\'pearsonr\'], 2))\n -0.74\n\n Example 2-The same as Example 1, but that also returns the `p-value`.\n >>> pearsonr_metric = evaluate.load("pearsonr")\n >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True)\n >>> print(sorted(list(results.keys())))\n [\'p-value\', \'pearsonr\']\n >>> print(round(results[\'pearsonr\'], 2))\n -0.74\n >>> print(round(results[\'p-value\'], 2))\n 0.15\n' +_CITATION = "\n@article{2020SciPy-NMeth,\nauthor = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n Bright, Jonathan and {van der Walt}, St{'e}fan J. and\n Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n Kern, Robert and Larson, Eric and Carey, C J and\n Polat, Ilhan and Feng, Yu and Moore, Eric W. and\n {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n Harris, Charles R. and Archibald, Anne M. and\n Ribeiro, Antonio H. and Pedregosa, Fabian and\n {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\ntitle = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n Computing in Python}},\njournal = {Nature Methods},\nyear = {2020},\nvolume = {17},\npages = {261--272},\nadsurl = {https://rdcu.be/b08Wh},\ndoi = {10.1038/s41592-019-0686-2},\n}\n" + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Pearsonr(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('float'), 'references': datasets.Value('float')}), reference_urls=['https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html']) + + def _compute(self, predictions, references, return_pvalue=False): + if return_pvalue: + results = pearsonr(references, predictions) + return {'pearsonr': results[0], 'p-value': results[1]} + else: + return {'pearsonr': float(pearsonr(references, predictions)[0])} + +# File: evaluate-main/metrics/perplexity/perplexity.py +"""""" +import datasets +import numpy as np +import torch +from torch.nn import CrossEntropyLoss +from transformers import AutoModelForCausalLM, AutoTokenizer +import evaluate +from evaluate import logging +_CITATION = '\n' +_DESCRIPTION = '\nPerplexity (PPL) is one of the most common metrics for evaluating language models.\nIt is defined as the exponentiated average negative log-likelihood of a sequence, calculated with exponent base `e`.\n\nFor more information, see https://huggingface.co/docs/transformers/perplexity\n' +_KWARGS_DESCRIPTION = '\nArgs:\n model_id (str): model used for calculating Perplexity\n NOTE: Perplexity can only be calculated for causal language models.\n This includes models such as gpt2, causal variations of bert,\n causal versions of t5, and more (the full list can be found\n in the AutoModelForCausalLM documentation here:\n https://huggingface.co/docs/transformers/master/en/model_doc/auto#transformers.AutoModelForCausalLM )\n\n predictions (list of str): input text, each separate text snippet\n is one list entry.\n batch_size (int): the batch size to run texts through the model. Defaults to 16.\n add_start_token (bool): whether to add the start token to the texts,\n so the perplexity can include the probability of the first word. Defaults to True.\n device (str): device to run on, defaults to \'cuda\' when available\nReturns:\n perplexity: dictionary containing the perplexity scores for the texts\n in the input list, as well as the mean perplexity. If one of the input texts is\n longer than the max input length of the model, then it is truncated to the\n max length for the perplexity computation.\nExamples:\n Example 1:\n >>> perplexity = evaluate.load("perplexity", module_type="metric")\n >>> input_texts = ["lorem ipsum", "Happy Birthday!", "Bienvenue"]\n >>> results = perplexity.compute(model_id=\'gpt2\',\n ... add_start_token=False,\n ... predictions=input_texts) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n [\'perplexities\', \'mean_perplexity\']\n >>> print(round(results["mean_perplexity"], 0))\n 647.0\n >>> print(round(results["perplexities"][0], 0))\n 32.0\n\n Example 2:\n >>> from datasets import load_dataset\n >>> perplexity = evaluate.load("perplexity", module_type="metric")\n >>> input_texts = load_dataset("wikitext", "wikitext-2-raw-v1", split="test")["text"][:10] # doctest: +SKIP\n >>> input_texts = [s for s in input_texts if s!=\'\']\n >>> results = perplexity.compute(model_id=\'gpt2\',\n ... predictions=input_texts)\n >>> print(list(results.keys()))\n [\'perplexities\', \'mean_perplexity\']\n >>> print(round(results["mean_perplexity"], 2)) # doctest: +SKIP\n 576.76\n >>> print(round(results["perplexities"][0], 2)) # doctest: +SKIP\n 889.28\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Perplexity(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(module_type='metric', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('string')}), reference_urls=['https://huggingface.co/docs/transformers/perplexity']) + + def _compute(self, predictions, model_id, batch_size: int=16, add_start_token: bool=True, device=None, max_length=None): + if device is not None: + assert device in ['gpu', 'cpu', 'cuda'], 'device should be either gpu or cpu.' + if device == 'gpu': + device = 'cuda' + else: + device = 'cuda' if torch.cuda.is_available() else 'cpu' + model = AutoModelForCausalLM.from_pretrained(model_id) + model = model.to(device) + tokenizer = AutoTokenizer.from_pretrained(model_id) + if tokenizer.pad_token is None and batch_size > 1: + existing_special_tokens = list(tokenizer.special_tokens_map_extended.values()) + assert len(existing_special_tokens) > 0, 'If batch_size > 1, model must have at least one special token to use for padding. Please use a different model or set batch_size=1.' + tokenizer.add_special_tokens({'pad_token': existing_special_tokens[0]}) + if add_start_token and max_length: + assert tokenizer.bos_token is not None, 'Input model must already have a BOS token if using add_start_token=True. Please use a different model, or set add_start_token=False' + max_tokenized_len = max_length - 1 + else: + max_tokenized_len = max_length + encodings = tokenizer(predictions, add_special_tokens=False, padding=True, truncation=True if max_tokenized_len else False, max_length=max_tokenized_len, return_tensors='pt', return_attention_mask=True).to(device) + encoded_texts = encodings['input_ids'] + attn_masks = encodings['attention_mask'] + if add_start_token: + assert torch.all(torch.ge(attn_masks.sum(1), 1)), 'Each input text must be at least one token long.' + else: + assert torch.all(torch.ge(attn_masks.sum(1), 2)), 'When add_start_token=False, each input text must be at least two tokens long. Run with add_start_token=True if inputting strings of only one token, and remove all empty input strings.' + ppls = [] + loss_fct = CrossEntropyLoss(reduction='none') + for start_index in logging.tqdm(range(0, len(encoded_texts), batch_size)): + end_index = min(start_index + batch_size, len(encoded_texts)) + encoded_batch = encoded_texts[start_index:end_index] + attn_mask = attn_masks[start_index:end_index] + if add_start_token: + bos_tokens_tensor = torch.tensor([[tokenizer.bos_token_id]] * encoded_batch.size(dim=0)).to(device) + encoded_batch = torch.cat([bos_tokens_tensor, encoded_batch], dim=1) + attn_mask = torch.cat([torch.ones(bos_tokens_tensor.size(), dtype=torch.int64).to(device), attn_mask], dim=1) + labels = encoded_batch + with torch.no_grad(): + out_logits = model(encoded_batch, attention_mask=attn_mask).logits + shift_logits = out_logits[..., :-1, :].contiguous() + shift_labels = labels[..., 1:].contiguous() + shift_attention_mask_batch = attn_mask[..., 1:].contiguous() + perplexity_batch = torch.exp((loss_fct(shift_logits.transpose(1, 2), shift_labels) * shift_attention_mask_batch).sum(1) / shift_attention_mask_batch.sum(1)) + ppls += perplexity_batch.tolist() + return {'perplexities': ppls, 'mean_perplexity': np.mean(ppls)} + +# File: evaluate-main/metrics/poseval/poseval.py +"""""" +from typing import Union +import datasets +from sklearn.metrics import classification_report +import evaluate +_CITATION = '@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' +_DESCRIPTION = "The poseval metric can be used to evaluate POS taggers. Since seqeval does not work well with POS data (see e.g. [here](https://stackoverflow.com/questions/71327693/how-to-disable-seqeval-label-formatting-for-pos-tagging))that is not in IOB format the poseval metric is an alternative. It treats each token in the dataset as independant observation and computes the precision, recall and F1-score irrespective of sentences. It uses scikit-learns's [classification report](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html) to compute the scores.\n\n" +_KWARGS_DESCRIPTION = '\nComputes the poseval metric.\n\nArgs:\n predictions: List of List of predicted labels (Estimated targets as returned by a tagger)\n references: List of List of reference labels (Ground truth (correct) target values)\n zero_division: Which value to substitute as a metric value when encountering zero division. Should be on of 0, 1,\n "warn". "warn" acts as 0, but the warning is raised.\n\nReturns:\n \'scores\': dict. Summary of the scores for overall and per type\n Overall (weighted and macro avg):\n \'accuracy\': accuracy,\n \'precision\': precision,\n \'recall\': recall,\n \'f1\': F1 score, also known as balanced F-score or F-measure,\n Per type:\n \'precision\': precision,\n \'recall\': recall,\n \'f1\': F1 score, also known as balanced F-score or F-measure\nExamples:\n\n >>> predictions = [[\'INTJ\', \'ADP\', \'PROPN\', \'NOUN\', \'PUNCT\', \'INTJ\', \'ADP\', \'PROPN\', \'VERB\', \'SYM\']]\n >>> references = [[\'INTJ\', \'ADP\', \'PROPN\', \'PROPN\', \'PUNCT\', \'INTJ\', \'ADP\', \'PROPN\', \'PROPN\', \'SYM\']]\n >>> poseval = evaluate.load("poseval")\n >>> results = poseval.compute(predictions=predictions, references=references)\n >>> print(list(results.keys()))\n [\'ADP\', \'INTJ\', \'NOUN\', \'PROPN\', \'PUNCT\', \'SYM\', \'VERB\', \'accuracy\', \'macro avg\', \'weighted avg\']\n >>> print(results["accuracy"])\n 0.8\n >>> print(results["PROPN"]["recall"])\n 0.5\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Poseval(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, homepage='https://scikit-learn.org', inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('string', id='label'), id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='label'), id='sequence')}), codebase_urls=['https://github.com/scikit-learn/scikit-learn']) + + def _compute(self, predictions, references, zero_division: Union[str, int]='warn'): + report = classification_report(y_true=[label for ref in references for label in ref], y_pred=[label for pred in predictions for label in pred], output_dict=True, zero_division=zero_division) + return report + +# File: evaluate-main/metrics/precision/precision.py +"""""" +import datasets +from sklearn.metrics import precision_score +import evaluate +_DESCRIPTION = '\nPrecision is the fraction of correctly labeled positive examples out of all of the examples that were labeled as positive. It is computed via the equation:\nPrecision = TP / (TP + FP)\nwhere TP is the True positives (i.e. the examples correctly labeled as positive) and FP is the False positive examples (i.e. the examples incorrectly labeled as positive).\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions (`list` of `int`): Predicted class labels.\n references (`list` of `int`): Actual class labels.\n labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`. If `average` is `None`, it should be the label order. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.\n pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.\n average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.\n\n - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.\n - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.\n - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.\n - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n sample_weight (`list` of `float`): Sample weights Defaults to None.\n zero_division (`int` or `string`): Sets the value to return when there is a zero division. Defaults to \'warn\'.\n\n - 0: Returns 0 when there is a zero division.\n - 1: Returns 1 when there is a zero division.\n - \'warn\': Raises warnings and then returns 0 when there is a zero division.\n\nReturns:\n precision (`float` or `array` of `float`): Precision score or list of precision scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate that fewer negative examples were incorrectly labeled as positive, which means that, generally, higher scores are better.\n\nExamples:\n\n Example 1-A simple binary example\n >>> precision_metric = evaluate.load("precision")\n >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])\n >>> print(results)\n {\'precision\': 0.5}\n\n Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.\n >>> precision_metric = evaluate.load("precision")\n >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)\n >>> print(round(results[\'precision\'], 2))\n 0.67\n\n Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.\n >>> precision_metric = evaluate.load("precision")\n >>> results = precision_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])\n >>> print(results)\n {\'precision\': 0.23529411764705882}\n\n Example 4-A multiclass example, with different values for the `average` input.\n >>> predictions = [0, 2, 1, 0, 0, 1]\n >>> references = [0, 1, 2, 0, 1, 2]\n >>> results = precision_metric.compute(predictions=predictions, references=references, average=\'macro\')\n >>> print(results)\n {\'precision\': 0.2222222222222222}\n >>> results = precision_metric.compute(predictions=predictions, references=references, average=\'micro\')\n >>> print(results)\n {\'precision\': 0.3333333333333333}\n >>> results = precision_metric.compute(predictions=predictions, references=references, average=\'weighted\')\n >>> print(results)\n {\'precision\': 0.2222222222222222}\n >>> results = precision_metric.compute(predictions=predictions, references=references, average=None)\n >>> print([round(res, 2) for res in results[\'precision\']])\n [0.67, 0.0, 0.0]\n' +_CITATION = '\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Precision(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('int32')), 'references': datasets.Sequence(datasets.Value('int32'))} if self.config_name == 'multilabel' else {'predictions': datasets.Value('int32'), 'references': datasets.Value('int32')}), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html']) + + def _compute(self, predictions, references, labels=None, pos_label=1, average='binary', sample_weight=None, zero_division='warn'): + score = precision_score(references, predictions, labels=labels, pos_label=pos_label, average=average, sample_weight=sample_weight, zero_division=zero_division) + return {'precision': float(score) if score.size == 1 else score} + +# File: evaluate-main/metrics/r_squared/r_squared.py +"""""" +import datasets +import numpy as np +import evaluate +_CITATION = '\n@article{williams2006relationship,\ntitle={The relationship between R2 and the correlation coefficient},\nauthor={Williams, James},\njournal={Journal of Statistics Education},\nvolume={14},\nnumber={2},\nyear={2006}\n}\n' +_DESCRIPTION = '\nR^2 (R Squared) is a statistical measure of the goodness of fit of a regression model. It represents the proportion of the variance in the dependent variable that is predictable from the independent variables.\n\nThe R^2 value ranges from 0 to 1, with a higher value indicating a better fit. A value of 0 means that the model does not explain any of the variance in the dependent variable, while a value of 1 means that the model explains all of the variance.\n\nR^2 can be calculated using the following formula:\n\nr_squared = 1 - (Sum of Squared Errors / Sum of Squared Total)\n\nwhere the Sum of Squared Errors is the sum of the squared differences between the predicted values and the true values, and the Sum of Squared Total is the sum of the squared differences between the true values and the mean of the true values.\n' +_KWARGS_DESCRIPTION = '\nComputes the R Squared metric.\n\nArgs:\n predictions: List of predicted values of the dependent variable\n references: List of true values of the dependent variable\n zero_division: Which value to substitute as a metric value when encountering zero division. Should be one of 0, 1,\n "warn". "warn" acts as 0, but the warning is raised.\n\nReturns:\n R^2 value ranging from 0 to 1, with a higher value indicating a better fit.\n\nExamples:\n >>> r2_metric = evaluate.load("r_squared")\n >>> r_squared = r2_metric.compute(predictions=[1, 2, 3, 4], references=[0.9, 2.1, 3.2, 3.8])\n >>> print(r_squared)\n 0.98\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class r_squared(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('float', id='sequence'), 'references': datasets.Value('float', id='sequence')}), codebase_urls=['https://github.com/scikit-learn/scikit-learn/'], reference_urls=['https://en.wikipedia.org/wiki/Coefficient_of_determination']) + + def _compute(self, predictions=None, references=None): + predictions = np.array(predictions) + references = np.array(references) + mean_references = np.mean(references) + ssr = np.sum((predictions - references) ** 2) + sst = np.sum((references - mean_references) ** 2) + r_squared = 1 - ssr / sst + rounded_r_squared = round(r_squared, 3) + return rounded_r_squared + +# File: evaluate-main/metrics/recall/recall.py +"""""" +import datasets +from sklearn.metrics import recall_score +import evaluate +_DESCRIPTION = '\nRecall is the fraction of the positive examples that were correctly labeled by the model as positive. It can be computed with the equation:\nRecall = TP / (TP + FN)\nWhere TP is the true positives and FN is the false negatives.\n' +_KWARGS_DESCRIPTION = "\nArgs:\n- **predictions** (`list` of `int`): The predicted labels.\n- **references** (`list` of `int`): The ground truth labels.\n- **labels** (`list` of `int`): The set of labels to include when `average` is not set to `binary`, and their order when average is `None`. Labels present in the data can be excluded in this input, for example to calculate a multiclass average ignoring a majority negative class, while labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in y_true and y_pred are used in sorted order. Defaults to None.\n- **pos_label** (`int`): The class label to use as the 'positive class' when calculating the recall. Defaults to `1`.\n- **average** (`string`): This parameter is required for multiclass/multilabel targets. If None, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `'binary'`.\n - `'binary'`: Only report results for the class specified by `pos_label`. This is applicable only if the target labels and predictions are binary.\n - `'micro'`: Calculate metrics globally by counting the total true positives, false negatives, and false positives.\n - `'macro'`: Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n - `'weighted'`: Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `'macro'` to account for label imbalance. Note that it can result in an F-score that is not between precision and recall.\n - `'samples'`: Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n- **sample_weight** (`list` of `float`): Sample weights Defaults to `None`.\n- **zero_division** (): Sets the value to return when there is a zero division. Defaults to .\n - `'warn'`: If there is a zero division, the return value is `0`, but warnings are also raised.\n - `0`: If there is a zero division, the return value is `0`.\n - `1`: If there is a zero division, the return value is `1`.\n\nReturns:\n- **recall** (`float`, or `array` of `float`): Either the general recall score, or the recall scores for individual classes, depending on the values input to `labels` and `average`. Minimum possible value is 0. Maximum possible value is 1. A higher recall means that more of the positive examples have been labeled correctly. Therefore, a higher recall is generally considered better.\n\nExamples:\n\n Example 1-A simple example with some errors\n >>> recall_metric = evaluate.load('recall')\n >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1])\n >>> print(results)\n {'recall': 0.6666666666666666}\n\n Example 2-The same example as Example 1, but with `pos_label=0` instead of the default `pos_label=1`.\n >>> recall_metric = evaluate.load('recall')\n >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], pos_label=0)\n >>> print(results)\n {'recall': 0.5}\n\n Example 3-The same example as Example 1, but with `sample_weight` included.\n >>> recall_metric = evaluate.load('recall')\n >>> sample_weight = [0.9, 0.2, 0.9, 0.3, 0.8]\n >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], sample_weight=sample_weight)\n >>> print(results)\n {'recall': 0.55}\n\n Example 4-A multiclass example, using different averages.\n >>> recall_metric = evaluate.load('recall')\n >>> predictions = [0, 2, 1, 0, 0, 1]\n >>> references = [0, 1, 2, 0, 1, 2]\n >>> results = recall_metric.compute(predictions=predictions, references=references, average='macro')\n >>> print(results)\n {'recall': 0.3333333333333333}\n >>> results = recall_metric.compute(predictions=predictions, references=references, average='micro')\n >>> print(results)\n {'recall': 0.3333333333333333}\n >>> results = recall_metric.compute(predictions=predictions, references=references, average='weighted')\n >>> print(results)\n {'recall': 0.3333333333333333}\n >>> results = recall_metric.compute(predictions=predictions, references=references, average=None)\n >>> print(results)\n {'recall': array([1., 0., 0.])}\n" +_CITATION = '\n@article{scikit-learn, title={Scikit-learn: Machine Learning in {P}ython}, author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.}, journal={Journal of Machine Learning Research}, volume={12}, pages={2825--2830}, year={2011}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Recall(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('int32')), 'references': datasets.Sequence(datasets.Value('int32'))} if self.config_name == 'multilabel' else {'predictions': datasets.Value('int32'), 'references': datasets.Value('int32')}), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.recall_score.html']) + + def _compute(self, predictions, references, labels=None, pos_label=1, average='binary', sample_weight=None, zero_division='warn'): + score = recall_score(references, predictions, labels=labels, pos_label=pos_label, average=average, sample_weight=sample_weight, zero_division=zero_division) + return {'recall': float(score) if score.size == 1 else score} + +# File: evaluate-main/metrics/rl_reliability/rl_reliability.py +"""""" +import datasets +import numpy as np +from rl_reliability_metrics.evaluation import eval_metrics +from rl_reliability_metrics.metrics import metrics_offline, metrics_online +import evaluate +logger = evaluate.logging.get_logger(__name__) +DEFAULT_EVAL_POINTS = [50000, 150000, 250000, 350000, 450000, 550000, 650000, 750000, 850000, 950000, 1050000, 1150000, 1250000, 1350000, 1450000, 1550000, 1650000, 1750000, 1850000, 1950000] +N_RUNS_RECOMMENDED = 10 +_CITATION = '@conference{rl_reliability_metrics,\n title = {Measuring the Reliability of Reinforcement Learning Algorithms},\n author = {Stephanie CY Chan, Sam Fishman, John Canny, Anoop Korattikara, and Sergio Guadarrama},\n booktitle = {International Conference on Learning Representations, Addis Ababa, Ethiopia},\n year = 2020,\n}\n' +_DESCRIPTION = 'Computes the RL reliability metrics from a set of experiments. There is an `"online"` and `"offline"` configuration for evaluation.\n' +_KWARGS_DESCRIPTION = '\nComputes the RL reliability metrics from a set of experiments. There is an `"online"` and `"offline"` configuration for evaluation.\nArgs:\n timestamps: list of timestep lists/arrays that serve as index.\n rewards: list of reward lists/arrays of each experiment.\nReturns:\n dictionary: a set of reliability metrics\nExamples:\n >>> import numpy as np\n >>> rl_reliability = evaluate.load("rl_reliability", "online")\n >>> results = rl_reliability.compute(\n ... timesteps=[np.linspace(0, 2000000, 1000)],\n ... rewards=[np.linspace(0, 100, 1000)]\n ... )\n >>> print(results["LowerCVaROnRaw"].round(4))\n [0.0258]\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class RLReliability(evaluate.Metric): + + def _info(self): + if self.config_name not in ['online', 'offline']: + raise KeyError('You should supply a configuration name selected in \'["online", "offline"]\'') + return evaluate.MetricInfo(module_type='metric', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'timesteps': datasets.Sequence(datasets.Value('int64')), 'rewards': datasets.Sequence(datasets.Value('float'))}), homepage='https://github.com/google-research/rl-reliability-metrics') + + def _compute(self, timesteps, rewards, baseline='default', freq_thresh=0.01, window_size=100000, window_size_trimmed=99000, alpha=0.05, eval_points=None): + if len(timesteps) < N_RUNS_RECOMMENDED: + logger.warning(f'For robust statistics it is recommended to use at least {N_RUNS_RECOMMENDED} runs whereas you provided {len(timesteps)}.') + curves = [] + for (timestep, reward) in zip(timesteps, rewards): + curves.append(np.stack([timestep, reward])) + if self.config_name == 'online': + if baseline == 'default': + baseline = 'curve_range' + if eval_points is None: + eval_points = DEFAULT_EVAL_POINTS + metrics = [metrics_online.HighFreqEnergyWithinRuns(thresh=freq_thresh), metrics_online.IqrWithinRuns(window_size=window_size_trimmed, eval_points=eval_points, baseline=baseline), metrics_online.IqrAcrossRuns(lowpass_thresh=freq_thresh, eval_points=eval_points, window_size=window_size, baseline=baseline), metrics_online.LowerCVaROnDiffs(baseline=baseline), metrics_online.LowerCVaROnDrawdown(baseline=baseline), metrics_online.LowerCVaROnAcross(lowpass_thresh=freq_thresh, eval_points=eval_points, window_size=window_size, baseline=baseline), metrics_online.LowerCVaROnRaw(alpha=alpha, baseline=baseline), metrics_online.MadAcrossRuns(lowpass_thresh=freq_thresh, eval_points=eval_points, window_size=window_size, baseline=baseline), metrics_online.MadWithinRuns(eval_points=eval_points, window_size=window_size_trimmed, baseline=baseline), metrics_online.MaxDrawdown(), metrics_online.StddevAcrossRuns(lowpass_thresh=freq_thresh, eval_points=eval_points, window_size=window_size, baseline=baseline), metrics_online.StddevWithinRuns(eval_points=eval_points, window_size=window_size_trimmed, baseline=baseline), metrics_online.UpperCVaROnAcross(alpha=alpha, lowpass_thresh=freq_thresh, eval_points=eval_points, window_size=window_size, baseline=baseline), metrics_online.UpperCVaROnDiffs(alpha=alpha, baseline=baseline), metrics_online.UpperCVaROnDrawdown(alpha=alpha, baseline=baseline), metrics_online.UpperCVaROnRaw(alpha=alpha, baseline=baseline), metrics_online.MedianPerfDuringTraining(window_size=window_size, eval_points=eval_points)] + else: + if baseline == 'default': + baseline = 'median_perf' + metrics = [metrics_offline.MadAcrossRollouts(baseline=baseline), metrics_offline.IqrAcrossRollouts(baseline=baseline), metrics_offline.StddevAcrossRollouts(baseline=baseline), metrics_offline.LowerCVaRAcrossRollouts(alpha=alpha, baseline=baseline), metrics_offline.UpperCVaRAcrossRollouts(alpha=alpha, baseline=baseline), metrics_offline.MedianPerfAcrossRollouts(baseline=None)] + evaluator = eval_metrics.Evaluator(metrics=metrics) + result = evaluator.compute_metrics(curves) + return result + +# File: evaluate-main/metrics/roc_auc/roc_auc.py +"""""" +import datasets +from sklearn.metrics import roc_auc_score +import evaluate +_DESCRIPTION = "\nThis metric computes the area under the curve (AUC) for the Receiver Operating Characteristic Curve (ROC). The return values represent how well the model used is predicting the correct classes, based on the input data. A score of `0.5` means that the model is predicting exactly at chance, i.e. the model's predictions are correct at the same rate as if the predictions were being decided by the flip of a fair coin or the roll of a fair die. A score above `0.5` indicates that the model is doing better than chance, while a score below `0.5` indicates that the model is doing worse than chance.\n\nThis metric has three separate use cases:\n - binary: The case in which there are only two different label classes, and each example gets only one label. This is the default implementation.\n - multiclass: The case in which there can be more than two different label classes, but each example still gets only one label.\n - multilabel: The case in which there can be more than two different label classes, and each example can have more than one label.\n" +_KWARGS_DESCRIPTION = '\nArgs:\n- references (array-like of shape (n_samples,) or (n_samples, n_classes)): Ground truth labels. Expects different input based on use case:\n - binary: expects an array-like of shape (n_samples,)\n - multiclass: expects an array-like of shape (n_samples,)\n - multilabel: expects an array-like of shape (n_samples, n_classes)\n- prediction_scores (array-like of shape (n_samples,) or (n_samples, n_classes)): Model predictions. Expects different inputs based on use case:\n - binary: expects an array-like of shape (n_samples,)\n - multiclass: expects an array-like of shape (n_samples, n_classes)\n - multilabel: expects an array-like of shape (n_samples, n_classes)\n- average (`str`): Type of average, and is ignored in the binary use case. Defaults to \'macro\'. Options are:\n - `\'micro\'`: Calculates metrics globally by considering each element of the label indicator matrix as a label. Only works with the multilabel use case.\n - `\'macro\'`: Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n - `\'weighted\'`: Calculate metrics for each label, and find their average, weighted by support (i.e. the number of true instances for each label).\n - `\'samples\'`: Calculate metrics for each instance, and find their average. Only works with the multilabel use case.\n - `None`: No average is calculated, and scores for each class are returned. Only works with the multilabels use case.\n- sample_weight (array-like of shape (n_samples,)): Sample weights. Defaults to None.\n- max_fpr (`float`): If not None, the standardized partial AUC over the range [0, `max_fpr`] is returned. Must be greater than `0` and less than or equal to `1`. Defaults to `None`. Note: For the multiclass use case, `max_fpr` should be either `None` or `1.0` as ROC AUC partial computation is not currently supported for `multiclass`.\n- multi_class (`str`): Only used for multiclass targets, where it is required. Determines the type of configuration to use. Options are:\n - `\'ovr\'`: Stands for One-vs-rest. Computes the AUC of each class against the rest. This treats the multiclass case in the same way as the multilabel case. Sensitive to class imbalance even when `average == \'macro\'`, because class imbalance affects the composition of each of the \'rest\' groupings.\n - `\'ovo\'`: Stands for One-vs-one. Computes the average AUC of all possible pairwise combinations of classes. Insensitive to class imbalance when `average == \'macro\'`.\n- labels (array-like of shape (n_classes,)): Only used for multiclass targets. List of labels that index the classes in\n `prediction_scores`. If `None`, the numerical or lexicographical order of the labels in\n `prediction_scores` is used. Defaults to `None`.\nReturns:\n roc_auc (`float` or array-like of shape (n_classes,)): Returns array if in multilabel use case and `average=\'None\'`. Otherwise, returns `float`.\nExamples:\n Example 1:\n >>> roc_auc_score = evaluate.load("roc_auc")\n >>> refs = [1, 0, 1, 1, 0, 0]\n >>> pred_scores = [0.5, 0.2, 0.99, 0.3, 0.1, 0.7]\n >>> results = roc_auc_score.compute(references=refs, prediction_scores=pred_scores)\n >>> print(round(results[\'roc_auc\'], 2))\n 0.78\n\n Example 2:\n >>> roc_auc_score = evaluate.load("roc_auc", "multiclass")\n >>> refs = [1, 0, 1, 2, 2, 0]\n >>> pred_scores = [[0.3, 0.5, 0.2],\n ... [0.7, 0.2, 0.1],\n ... [0.005, 0.99, 0.005],\n ... [0.2, 0.3, 0.5],\n ... [0.1, 0.1, 0.8],\n ... [0.1, 0.7, 0.2]]\n >>> results = roc_auc_score.compute(references=refs, prediction_scores=pred_scores, multi_class=\'ovr\')\n >>> print(round(results[\'roc_auc\'], 2))\n 0.85\n\n Example 3:\n >>> roc_auc_score = evaluate.load("roc_auc", "multilabel")\n >>> refs = [[1, 1, 0],\n ... [1, 1, 0],\n ... [0, 1, 0],\n ... [0, 0, 1],\n ... [0, 1, 1],\n ... [1, 0, 1]]\n >>> pred_scores = [[0.3, 0.5, 0.2],\n ... [0.7, 0.2, 0.1],\n ... [0.005, 0.99, 0.005],\n ... [0.2, 0.3, 0.5],\n ... [0.1, 0.1, 0.8],\n ... [0.1, 0.7, 0.2]]\n >>> results = roc_auc_score.compute(references=refs, prediction_scores=pred_scores, average=None)\n >>> print([round(res, 2) for res in results[\'roc_auc\']])\n [0.83, 0.38, 0.94]\n' +_CITATION = '@article{doi:10.1177/0272989X8900900307,\nauthor = {Donna Katzman McClish},\ntitle ={Analyzing a Portion of the ROC Curve},\njournal = {Medical Decision Making},\nvolume = {9},\nnumber = {3},\npages = {190-195},\nyear = {1989},\ndoi = {10.1177/0272989X8900900307},\n note ={PMID: 2668680},\nURL = {https://doi.org/10.1177/0272989X8900900307},\neprint = {https://doi.org/10.1177/0272989X8900900307}\n}\n\n\n@article{10.1023/A:1010920819831,\nauthor = {Hand, David J. and Till, Robert J.},\ntitle = {A Simple Generalisation of the Area Under the ROC Curve for Multiple Class Classification Problems},\nyear = {2001},\nissue_date = {November 2001},\npublisher = {Kluwer Academic Publishers},\naddress = {USA},\nvolume = {45},\nnumber = {2},\nissn = {0885-6125},\nurl = {https://doi.org/10.1023/A:1010920819831},\ndoi = {10.1023/A:1010920819831},\njournal = {Mach. Learn.},\nmonth = {oct},\npages = {171–186},\nnumpages = {16},\nkeywords = {Gini index, AUC, error rate, ROC curve, receiver operating characteristic}\n}\n\n\n@article{scikit-learn,\ntitle={Scikit-learn: Machine Learning in {P}ython},\nauthor={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\njournal={Journal of Machine Learning Research},\nvolume={12},\npages={2825--2830},\nyear={2011}\n}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class ROCAUC(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'prediction_scores': datasets.Sequence(datasets.Value('float')), 'references': datasets.Value('int32')} if self.config_name == 'multiclass' else {'references': datasets.Sequence(datasets.Value('int32')), 'prediction_scores': datasets.Sequence(datasets.Value('float'))} if self.config_name == 'multilabel' else {'references': datasets.Value('int32'), 'prediction_scores': datasets.Value('float')}), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html']) + + def _compute(self, references, prediction_scores, average='macro', sample_weight=None, max_fpr=None, multi_class='raise', labels=None): + return {'roc_auc': roc_auc_score(references, prediction_scores, average=average, sample_weight=sample_weight, max_fpr=max_fpr, multi_class=multi_class, labels=labels)} + +# File: evaluate-main/metrics/rouge/rouge.py +"""""" +import absl +import datasets +import nltk +import numpy +import six +from rouge_score import rouge_scorer, scoring +import evaluate +_CITATION = '@inproceedings{lin-2004-rouge,\n title = "{ROUGE}: A Package for Automatic Evaluation of Summaries",\n author = "Lin, Chin-Yew",\n booktitle = "Text Summarization Branches Out",\n month = jul,\n year = "2004",\n address = "Barcelona, Spain",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/W04-1013",\n pages = "74--81",\n}\n' +_DESCRIPTION = 'ROUGE, or Recall-Oriented Understudy for Gisting Evaluation, is a set of metrics and a software package used for\nevaluating automatic summarization and machine translation software in natural language processing.\nThe metrics compare an automatically produced summary or translation against a reference or a set of references (human-produced) summary or translation.\n\nNote that ROUGE is case insensitive, meaning that upper case letters are treated the same way as lower case letters.\n\nThis metrics is a wrapper around Google Research reimplementation of ROUGE:\nhttps://github.com/google-research/google-research/tree/master/rouge\n' +_KWARGS_DESCRIPTION = '\nCalculates average rouge scores for a list of hypotheses and references\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n rouge_types: A list of rouge types to calculate.\n Valid names:\n `"rouge{n}"` (e.g. `"rouge1"`, `"rouge2"`) where: {n} is the n-gram based scoring,\n `"rougeL"`: Longest common subsequence based scoring.\n `"rougeLsum"`: rougeLsum splits text using `"\n"`.\n See details in https://github.com/huggingface/datasets/issues/617\n use_stemmer: Bool indicating whether Porter stemmer should be used to strip word suffixes.\n use_aggregator: Return aggregates if this is set to True\nReturns:\n rouge1: rouge_1 (f1),\n rouge2: rouge_2 (f1),\n rougeL: rouge_l (f1),\n rougeLsum: rouge_lsum (f1)\nExamples:\n\n >>> rouge = evaluate.load(\'rouge\')\n >>> predictions = ["hello there", "general kenobi"]\n >>> references = ["hello there", "general kenobi"]\n >>> results = rouge.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'rouge1\': 1.0, \'rouge2\': 1.0, \'rougeL\': 1.0, \'rougeLsum\': 1.0}\n' + +class Tokenizer: + + def __init__(self, tokenizer_func): + self.tokenizer_func = tokenizer_func + + def tokenize(self, text): + return self.tokenizer_func(text) + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Rouge(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'))}), datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')})], codebase_urls=['https://github.com/google-research/google-research/tree/master/rouge'], reference_urls=['https://en.wikipedia.org/wiki/ROUGE_(metric)', 'https://github.com/google-research/google-research/tree/master/rouge']) + + def _compute(self, predictions, references, rouge_types=None, use_aggregator=True, use_stemmer=False, tokenizer=None): + if rouge_types is None: + rouge_types = ['rouge1', 'rouge2', 'rougeL', 'rougeLsum'] + multi_ref = isinstance(references[0], list) + if tokenizer is not None: + tokenizer = Tokenizer(tokenizer) + scorer = rouge_scorer.RougeScorer(rouge_types=rouge_types, use_stemmer=use_stemmer, tokenizer=tokenizer) + if use_aggregator: + aggregator = scoring.BootstrapAggregator() + else: + scores = [] + for (ref, pred) in zip(references, predictions): + if multi_ref: + score = scorer.score_multi(ref, pred) + else: + score = scorer.score(ref, pred) + if use_aggregator: + aggregator.add_scores(score) + else: + scores.append(score) + if use_aggregator: + result = aggregator.aggregate() + for key in result: + result[key] = result[key].mid.fmeasure + else: + result = {} + for key in scores[0]: + result[key] = list((score[key].fmeasure for score in scores)) + return result + +# File: evaluate-main/metrics/sacrebleu/sacrebleu.py +"""""" +import datasets +import sacrebleu as scb +from packaging import version +import evaluate +_CITATION = '@inproceedings{post-2018-call,\n title = "A Call for Clarity in Reporting {BLEU} Scores",\n author = "Post, Matt",\n booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n month = oct,\n year = "2018",\n address = "Belgium, Brussels",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/W18-6319",\n pages = "186--191",\n}\n' +_DESCRIPTION = "SacreBLEU provides hassle-free computation of shareable, comparable, and reproducible BLEU scores.\nInspired by Rico Sennrich's `multi-bleu-detok.perl`, it produces the official WMT scores but works with plain text.\nIt also knows all the standard test sets and handles downloading, processing, and tokenization for you.\n\nSee the [README.md] file at https://github.com/mjpost/sacreBLEU for more information.\n" +_KWARGS_DESCRIPTION = '\nProduces BLEU scores along with its sufficient statistics\nfrom a source against one or more references.\n\nArgs:\n predictions (`list` of `str`): list of translations to score. Each translation should be tokenized into a list of tokens.\n references (`list` of `list` of `str`): A list of lists of references. The contents of the first sub-list are the references for the first prediction, the contents of the second sub-list are for the second prediction, etc. Note that there must be the same number of references for each prediction (i.e. all sub-lists must be of the same length).\n smooth_method (`str`): The smoothing method to use, defaults to `\'exp\'`. Possible values are:\n - `\'none\'`: no smoothing\n - `\'floor\'`: increment zero counts\n - `\'add-k\'`: increment num/denom by k for n>1\n - `\'exp\'`: exponential decay\n smooth_value (`float`): The smoothing value. Only valid when `smooth_method=\'floor\'` (in which case `smooth_value` defaults to `0.1`) or `smooth_method=\'add-k\'` (in which case `smooth_value` defaults to `1`).\n tokenize (`str`): Tokenization method to use for BLEU. If not provided, defaults to `\'zh\'` for Chinese, `\'ja-mecab\'` for Japanese and `\'13a\'` (mteval) otherwise. Possible values are:\n - `\'none\'`: No tokenization.\n - `\'zh\'`: Chinese tokenization.\n - `\'13a\'`: mimics the `mteval-v13a` script from Moses.\n - `\'intl\'`: International tokenization, mimics the `mteval-v14` script from Moses\n - `\'char\'`: Language-agnostic character-level tokenization.\n - `\'ja-mecab\'`: Japanese tokenization. Uses the [MeCab tokenizer](https://pypi.org/project/mecab-python3).\n lowercase (`bool`): If `True`, lowercases the input, enabling case-insensitivity. Defaults to `False`.\n force (`bool`): If `True`, insists that your tokenized input is actually detokenized. Defaults to `False`.\n use_effective_order (`bool`): If `True`, stops including n-gram orders for which precision is 0. This should be `True`, if sentence-level BLEU will be computed. Defaults to `False`.\n\nReturns:\n \'score\': BLEU score,\n \'counts\': Counts,\n \'totals\': Totals,\n \'precisions\': Precisions,\n \'bp\': Brevity penalty,\n \'sys_len\': predictions length,\n \'ref_len\': reference length,\n\nExamples:\n\n Example 1:\n >>> predictions = ["hello there general kenobi", "foo bar foobar"]\n >>> references = [["hello there general kenobi", "hello there !"], ["foo bar foobar", "foo bar foobar"]]\n >>> sacrebleu = evaluate.load("sacrebleu")\n >>> results = sacrebleu.compute(predictions=predictions, references=references)\n >>> print(list(results.keys()))\n [\'score\', \'counts\', \'totals\', \'precisions\', \'bp\', \'sys_len\', \'ref_len\']\n >>> print(round(results["score"], 1))\n 100.0\n\n Example 2:\n >>> predictions = ["hello there general kenobi",\n ... "on our way to ankh morpork"]\n >>> references = [["hello there general kenobi", "hello there !"],\n ... ["goodbye ankh morpork", "ankh morpork"]]\n >>> sacrebleu = evaluate.load("sacrebleu")\n >>> results = sacrebleu.compute(predictions=predictions,\n ... references=references)\n >>> print(list(results.keys()))\n [\'score\', \'counts\', \'totals\', \'precisions\', \'bp\', \'sys_len\', \'ref_len\']\n >>> print(round(results["score"], 1))\n 39.8\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Sacrebleu(evaluate.Metric): + + def _info(self): + 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.\nYou can install it with `pip install "sacrebleu>=1.4.12"`.') + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, homepage='https://github.com/mjpost/sacreBLEU', inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'), id='references')}), datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')})], codebase_urls=['https://github.com/mjpost/sacreBLEU'], reference_urls=['https://github.com/mjpost/sacreBLEU', 'https://en.wikipedia.org/wiki/BLEU', 'https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213']) + + def _compute(self, predictions, references, smooth_method='exp', smooth_value=None, force=False, lowercase=False, tokenize=None, use_effective_order=False): + if isinstance(references[0], str): + references = [[ref] for ref in references] + references_per_prediction = len(references[0]) + if any((len(refs) != references_per_prediction for refs in references)): + raise ValueError('Sacrebleu requires the same number of references for each prediction') + transformed_references = [[refs[i] for refs in references] for i in range(references_per_prediction)] + output = scb.corpus_bleu(predictions, transformed_references, smooth_method=smooth_method, smooth_value=smooth_value, force=force, lowercase=lowercase, use_effective_order=use_effective_order, **dict(tokenize=tokenize) if tokenize else {}) + output_dict = {'score': output.score, 'counts': output.counts, 'totals': output.totals, 'precisions': output.precisions, 'bp': output.bp, 'sys_len': output.sys_len, 'ref_len': output.ref_len} + return output_dict + +# File: evaluate-main/metrics/sari/sari.py +"""""" +from collections import Counter +import datasets +import sacrebleu +import sacremoses +from packaging import version +import evaluate +_CITATION = '@inproceedings{xu-etal-2016-optimizing,\ntitle = {Optimizing Statistical Machine Translation for Text Simplification},\nauthors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\njournal = {Transactions of the Association for Computational Linguistics},\nvolume = {4},\nyear={2016},\nurl = {https://www.aclweb.org/anthology/Q16-1029},\npages = {401--415},\n}\n' +_DESCRIPTION = "SARI is a metric used for evaluating automatic text simplification systems.\nThe metric compares the predicted simplified sentences against the reference\nand the source sentences. It explicitly measures the goodness of words that are\nadded, deleted and kept by the system.\nSari = (F1_add + F1_keep + P_del) / 3\nwhere\nF1_add: n-gram F1 score for add operation\nF1_keep: n-gram F1 score for keep operation\nP_del: n-gram precision score for delete operation\nn = 4, as in the original paper.\n\nThis implementation is adapted from Tensorflow's tensor2tensor implementation [3].\nIt has two differences with the original GitHub [1] implementation:\n (1) Defines 0/0=1 instead of 0 to give higher scores for predictions that match\n a target exactly.\n (2) Fixes an alleged bug [2] in the keep score computation.\n[1] https://github.com/cocoxu/simplification/blob/master/SARI.py\n (commit 0210f15)\n[2] https://github.com/cocoxu/simplification/issues/6\n[3] https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py\n" +_KWARGS_DESCRIPTION = '\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences.\nArgs:\n sources: list of source sentences where each sentence should be a string.\n predictions: list of predicted sentences where each sentence should be a string.\n references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n sari: sari score\nExamples:\n >>> sources=["About 95 species are currently accepted ."]\n >>> predictions=["About 95 you now get in ."]\n >>> references=[["About 95 species are currently known .","About 95 species are now accepted .","95 species are now accepted ."]]\n >>> sari = evaluate.load("sari")\n >>> results = sari.compute(sources=sources, predictions=predictions, references=references)\n >>> print(results)\n {\'sari\': 26.953601953601954}\n' + +def SARIngram(sgrams, cgrams, rgramslist, numref): + rgramsall = [rgram for rgrams in rgramslist for rgram in rgrams] + rgramcounter = Counter(rgramsall) + sgramcounter = Counter(sgrams) + sgramcounter_rep = Counter() + for (sgram, scount) in sgramcounter.items(): + sgramcounter_rep[sgram] = scount * numref + cgramcounter = Counter(cgrams) + cgramcounter_rep = Counter() + for (cgram, ccount) in cgramcounter.items(): + cgramcounter_rep[cgram] = ccount * numref + keepgramcounter_rep = sgramcounter_rep & cgramcounter_rep + keepgramcountergood_rep = keepgramcounter_rep & rgramcounter + keepgramcounterall_rep = sgramcounter_rep & rgramcounter + keeptmpscore1 = 0 + keeptmpscore2 = 0 + for keepgram in keepgramcountergood_rep: + keeptmpscore1 += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram] + keeptmpscore2 += keepgramcountergood_rep[keepgram] + keepscore_precision = 1 + keepscore_recall = 1 + if len(keepgramcounter_rep) > 0: + keepscore_precision = keeptmpscore1 / len(keepgramcounter_rep) + if len(keepgramcounterall_rep) > 0: + keepscore_recall = keeptmpscore2 / sum(keepgramcounterall_rep.values()) + keepscore = 0 + if keepscore_precision > 0 or keepscore_recall > 0: + keepscore = 2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall) + delgramcounter_rep = sgramcounter_rep - cgramcounter_rep + delgramcountergood_rep = delgramcounter_rep - rgramcounter + delgramcounterall_rep = sgramcounter_rep - rgramcounter + deltmpscore1 = 0 + deltmpscore2 = 0 + for delgram in delgramcountergood_rep: + deltmpscore1 += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram] + deltmpscore2 += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram] + delscore_precision = 1 + if len(delgramcounter_rep) > 0: + delscore_precision = deltmpscore1 / len(delgramcounter_rep) + addgramcounter = set(cgramcounter) - set(sgramcounter) + addgramcountergood = set(addgramcounter) & set(rgramcounter) + addgramcounterall = set(rgramcounter) - set(sgramcounter) + addtmpscore = 0 + for addgram in addgramcountergood: + addtmpscore += 1 + addscore_precision = 1 + addscore_recall = 1 + if len(addgramcounter) > 0: + addscore_precision = addtmpscore / len(addgramcounter) + if len(addgramcounterall) > 0: + addscore_recall = addtmpscore / len(addgramcounterall) + addscore = 0 + if addscore_precision > 0 or addscore_recall > 0: + addscore = 2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall) + return (keepscore, delscore_precision, addscore) + +def SARIsent(ssent, csent, rsents): + numref = len(rsents) + s1grams = ssent.split(' ') + c1grams = csent.split(' ') + s2grams = [] + c2grams = [] + s3grams = [] + c3grams = [] + s4grams = [] + c4grams = [] + r1gramslist = [] + r2gramslist = [] + r3gramslist = [] + r4gramslist = [] + for rsent in rsents: + r1grams = rsent.split(' ') + r2grams = [] + r3grams = [] + r4grams = [] + r1gramslist.append(r1grams) + for i in range(0, len(r1grams) - 1): + if i < len(r1grams) - 1: + r2gram = r1grams[i] + ' ' + r1grams[i + 1] + r2grams.append(r2gram) + if i < len(r1grams) - 2: + r3gram = r1grams[i] + ' ' + r1grams[i + 1] + ' ' + r1grams[i + 2] + r3grams.append(r3gram) + if i < len(r1grams) - 3: + r4gram = r1grams[i] + ' ' + r1grams[i + 1] + ' ' + r1grams[i + 2] + ' ' + r1grams[i + 3] + r4grams.append(r4gram) + r2gramslist.append(r2grams) + r3gramslist.append(r3grams) + r4gramslist.append(r4grams) + for i in range(0, len(s1grams) - 1): + if i < len(s1grams) - 1: + s2gram = s1grams[i] + ' ' + s1grams[i + 1] + s2grams.append(s2gram) + if i < len(s1grams) - 2: + s3gram = s1grams[i] + ' ' + s1grams[i + 1] + ' ' + s1grams[i + 2] + s3grams.append(s3gram) + if i < len(s1grams) - 3: + s4gram = s1grams[i] + ' ' + s1grams[i + 1] + ' ' + s1grams[i + 2] + ' ' + s1grams[i + 3] + s4grams.append(s4gram) + for i in range(0, len(c1grams) - 1): + if i < len(c1grams) - 1: + c2gram = c1grams[i] + ' ' + c1grams[i + 1] + c2grams.append(c2gram) + if i < len(c1grams) - 2: + c3gram = c1grams[i] + ' ' + c1grams[i + 1] + ' ' + c1grams[i + 2] + c3grams.append(c3gram) + if i < len(c1grams) - 3: + c4gram = c1grams[i] + ' ' + c1grams[i + 1] + ' ' + c1grams[i + 2] + ' ' + c1grams[i + 3] + c4grams.append(c4gram) + (keep1score, del1score, add1score) = SARIngram(s1grams, c1grams, r1gramslist, numref) + (keep2score, del2score, add2score) = SARIngram(s2grams, c2grams, r2gramslist, numref) + (keep3score, del3score, add3score) = SARIngram(s3grams, c3grams, r3gramslist, numref) + (keep4score, del4score, add4score) = SARIngram(s4grams, c4grams, r4gramslist, numref) + avgkeepscore = sum([keep1score, keep2score, keep3score, keep4score]) / 4 + avgdelscore = sum([del1score, del2score, del3score, del4score]) / 4 + avgaddscore = sum([add1score, add2score, add3score, add4score]) / 4 + finalscore = (avgkeepscore + avgdelscore + avgaddscore) / 3 + return finalscore + +def normalize(sentence, lowercase: bool=True, tokenizer: str='13a', return_str: bool=True): + if lowercase: + sentence = sentence.lower() + if tokenizer in ['13a', 'intl']: + if version.parse(sacrebleu.__version__).major >= 2: + normalized_sent = sacrebleu.metrics.bleu._get_tokenizer(tokenizer)()(sentence) + else: + normalized_sent = sacrebleu.TOKENIZERS[tokenizer]()(sentence) + elif tokenizer == 'moses': + normalized_sent = sacremoses.MosesTokenizer().tokenize(sentence, return_str=True, escape=False) + elif tokenizer == 'penn': + normalized_sent = sacremoses.MosesTokenizer().penn_tokenize(sentence, return_str=True) + else: + normalized_sent = sentence + if not return_str: + normalized_sent = normalized_sent.split() + return normalized_sent + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Sari(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'sources': datasets.Value('string', id='sequence'), 'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'), id='references')}), codebase_urls=['https://github.com/cocoxu/simplification/blob/master/SARI.py', 'https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py'], reference_urls=['https://www.aclweb.org/anthology/Q16-1029.pdf']) + + def _compute(self, sources, predictions, references): + if not len(sources) == len(predictions) == len(references): + raise ValueError('Sources length must match predictions and references lengths.') + sari_score = 0 + for (src, pred, refs) in zip(sources, predictions, references): + sari_score += SARIsent(normalize(src), normalize(pred), [normalize(sent) for sent in refs]) + sari_score = sari_score / len(predictions) + return {'sari': 100 * sari_score} + +# File: evaluate-main/metrics/seqeval/seqeval.py +"""""" +import importlib +from typing import List, Optional, Union +import datasets +from seqeval.metrics import accuracy_score, classification_report +import evaluate +_CITATION = '@inproceedings{ramshaw-marcus-1995-text,\n title = "Text Chunking using Transformation-Based Learning",\n author = "Ramshaw, Lance and\n Marcus, Mitch",\n booktitle = "Third Workshop on Very Large Corpora",\n year = "1995",\n url = "https://www.aclweb.org/anthology/W95-0107",\n}\n@misc{seqeval,\n title={{seqeval}: A Python framework for sequence labeling evaluation},\n url={https://github.com/chakki-works/seqeval},\n note={Software available from https://github.com/chakki-works/seqeval},\n author={Hiroki Nakayama},\n year={2018},\n}\n' +_DESCRIPTION = 'seqeval is a Python framework for sequence labeling evaluation.\nseqeval can evaluate the performance of chunking tasks such as named-entity recognition, part-of-speech tagging, semantic role labeling and so on.\n\nThis is well-tested by using the Perl script conlleval, which can be used for\nmeasuring the performance of a system that has processed the CoNLL-2000 shared task data.\n\nseqeval supports following formats:\nIOB1\nIOB2\nIOE1\nIOE2\nIOBES\n\nSee the [README.md] file at https://github.com/chakki-works/seqeval for more information.\n' +_KWARGS_DESCRIPTION = '\nProduces labelling scores along with its sufficient statistics\nfrom a source against one or more references.\n\nArgs:\n predictions: List of List of predicted labels (Estimated targets as returned by a tagger)\n references: List of List of reference labels (Ground truth (correct) target values)\n suffix: True if the IOB prefix is after type, False otherwise. default: False\n scheme: Specify target tagging scheme. Should be one of ["IOB1", "IOB2", "IOE1", "IOE2", "IOBES", "BILOU"].\n default: None\n mode: Whether to count correct entity labels with incorrect I/B tags as true positives or not.\n If you want to only count exact matches, pass mode="strict". default: None.\n sample_weight: Array-like of shape (n_samples,), weights for individual samples. default: None\n zero_division: Which value to substitute as a metric value when encountering zero division. Should be on of 0, 1,\n "warn". "warn" acts as 0, but the warning is raised.\n\nReturns:\n \'scores\': dict. Summary of the scores for overall and per type\n Overall:\n \'accuracy\': accuracy,\n \'precision\': precision,\n \'recall\': recall,\n \'f1\': F1 score, also known as balanced F-score or F-measure,\n Per type:\n \'precision\': precision,\n \'recall\': recall,\n \'f1\': F1 score, also known as balanced F-score or F-measure\nExamples:\n\n >>> predictions = [[\'O\', \'O\', \'B-MISC\', \'I-MISC\', \'I-MISC\', \'I-MISC\', \'O\'], [\'B-PER\', \'I-PER\', \'O\']]\n >>> references = [[\'O\', \'O\', \'O\', \'B-MISC\', \'I-MISC\', \'I-MISC\', \'O\'], [\'B-PER\', \'I-PER\', \'O\']]\n >>> seqeval = evaluate.load("seqeval")\n >>> results = seqeval.compute(predictions=predictions, references=references)\n >>> print(list(results.keys()))\n [\'MISC\', \'PER\', \'overall_precision\', \'overall_recall\', \'overall_f1\', \'overall_accuracy\']\n >>> print(results["overall_f1"])\n 0.5\n >>> print(results["PER"]["f1"])\n 1.0\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Seqeval(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, homepage='https://github.com/chakki-works/seqeval', inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Sequence(datasets.Value('string', id='label'), id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='label'), id='sequence')}), codebase_urls=['https://github.com/chakki-works/seqeval'], reference_urls=['https://github.com/chakki-works/seqeval']) + + def _compute(self, predictions, references, suffix: bool=False, scheme: Optional[str]=None, mode: Optional[str]=None, sample_weight: Optional[List[int]]=None, zero_division: Union[str, int]='warn'): + if scheme is not None: + try: + scheme_module = importlib.import_module('seqeval.scheme') + scheme = getattr(scheme_module, scheme) + except AttributeError: + raise ValueError(f'Scheme should be one of [IOB1, IOB2, IOE1, IOE2, IOBES, BILOU], got {scheme}') + report = classification_report(y_true=references, y_pred=predictions, suffix=suffix, output_dict=True, scheme=scheme, mode=mode, sample_weight=sample_weight, zero_division=zero_division) + report.pop('macro avg') + report.pop('weighted avg') + overall_score = report.pop('micro avg') + scores = {type_name: {'precision': score['precision'], 'recall': score['recall'], 'f1': score['f1-score'], 'number': score['support']} for (type_name, score) in report.items()} + scores['overall_precision'] = overall_score['precision'] + scores['overall_recall'] = overall_score['recall'] + scores['overall_f1'] = overall_score['f1-score'] + scores['overall_accuracy'] = accuracy_score(y_true=references, y_pred=predictions) + return scores + +# File: evaluate-main/metrics/smape/smape.py +"""""" +import datasets +import numpy as np +from sklearn.metrics._regression import _check_reg_targets +from sklearn.utils.validation import check_consistent_length +import evaluate +_CITATION = '@article{article,\n author = {Chen, Zhuo and Yang, Yuhong},\n year = {2004},\n month = {04},\n pages = {},\n title = {Assessing forecast accuracy measures}\n}\n' +_DESCRIPTION = 'Symmetric Mean Absolute Percentage Error (sMAPE) is the symmetric mean percentage error\ndifference between the predicted and actual values as defined by Chen and Yang (2004),\nbased on the metric by Armstrong (1985) and Makridakis (1993).\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Estimated target values.\n references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n Ground truth (correct) target values.\n sample_weight: array-like of shape (n_samples,), default=None\n Sample weights.\n multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n "raw_values" : Returns a full set of errors in case of multioutput input.\n\n "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\nReturns:\n smape : symmetric mean absolute percentage error.\n If multioutput is "raw_values", then symmetric mean absolute percentage error is returned for each output separately. If multioutput is "uniform_average" or an ndarray of weights, then the weighted average of all output errors is returned.\n sMAPE output is non-negative floating point in the range (0, 2). The best value is 0.0.\nExamples:\n\n >>> smape_metric = evaluate.load("smape")\n >>> predictions = [2.5, 0.0, 2, 8]\n >>> references = [3, -0.5, 2, 7]\n >>> results = smape_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'smape\': 0.5787878787878785}\n\n If you\'re using multi-dimensional lists, then set the config as follows :\n\n >>> smape_metric = evaluate.load("smape", "multilist")\n >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n >>> references = [[0.1, 2], [-1, 2], [8, -5]]\n >>> results = smape_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'smape\': 0.49696969558995985}\n >>> results = smape_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n >>> print(results)\n {\'smape\': array([0.48888889, 0.50505051])}\n' + +def symmetric_mean_absolute_percentage_error(y_true, y_pred, *, sample_weight=None, multioutput='uniform_average'): + (y_type, y_true, y_pred, multioutput) = _check_reg_targets(y_true, y_pred, multioutput) + check_consistent_length(y_true, y_pred, sample_weight) + epsilon = np.finfo(np.float64).eps + smape = 2 * np.abs(y_pred - y_true) / (np.maximum(np.abs(y_true), epsilon) + np.maximum(np.abs(y_pred), epsilon)) + output_errors = np.average(smape, weights=sample_weight, axis=0) + if isinstance(multioutput, str): + if multioutput == 'raw_values': + return output_errors + elif multioutput == 'uniform_average': + multioutput = None + return np.average(output_errors, weights=multioutput) + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Smape(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features(self._get_feature_types()), reference_urls=['https://robjhyndman.com/hyndsight/smape/']) + + def _get_feature_types(self): + if self.config_name == 'multilist': + return {'predictions': datasets.Sequence(datasets.Value('float')), 'references': datasets.Sequence(datasets.Value('float'))} + else: + return {'predictions': datasets.Value('float'), 'references': datasets.Value('float')} + + def _compute(self, predictions, references, sample_weight=None, multioutput='uniform_average'): + smape_score = symmetric_mean_absolute_percentage_error(references, predictions, sample_weight=sample_weight, multioutput=multioutput) + return {'smape': smape_score} + +# File: evaluate-main/metrics/spearmanr/spearmanr.py +"""""" +import datasets +from scipy.stats import spearmanr +import evaluate +_DESCRIPTION = '\nThe Spearman rank-order correlation coefficient is a measure of the\nrelationship between two datasets. Like other correlation coefficients,\nthis one varies between -1 and +1 with 0 implying no correlation.\nPositive correlations imply that as data in dataset x increases, so\ndoes data in dataset y. Negative correlations imply that as x increases,\ny decreases. Correlations of -1 or +1 imply an exact monotonic relationship.\n\nUnlike the Pearson correlation, the Spearman correlation does not\nassume that both datasets are normally distributed.\n\nThe p-value roughly indicates the probability of an uncorrelated system\nproducing datasets that have a Spearman correlation at least as extreme\nas the one computed from these datasets. The p-values are not entirely\nreliable but are probably reasonable for datasets larger than 500 or so.\n' +_KWARGS_DESCRIPTION = '\nArgs:\n predictions (`List[float]`): Predicted labels, as returned by a model.\n references (`List[float]`): Ground truth labels.\n return_pvalue (`bool`): If `True`, returns the p-value. If `False`, returns\n only the spearmanr score. Defaults to `False`.\nReturns:\n spearmanr (`float`): Spearman correlation coefficient.\n p-value (`float`): p-value. **Note**: is only returned if `return_pvalue=True` is input.\nExamples:\n Example 1:\n >>> spearmanr_metric = evaluate.load("spearmanr")\n >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5], predictions=[10, 9, 2.5, 6, 4])\n >>> print(results)\n {\'spearmanr\': -0.7}\n\n Example 2:\n >>> spearmanr_metric = evaluate.load("spearmanr")\n >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5],\n ... predictions=[10, 9, 2.5, 6, 4],\n ... return_pvalue=True)\n >>> print(results[\'spearmanr\'])\n -0.7\n >>> print(round(results[\'spearmanr_pvalue\'], 2))\n 0.19\n' +_CITATION = "\\\n@book{kokoska2000crc,\n title={CRC standard probability and statistics tables and formulae},\n author={Kokoska, Stephen and Zwillinger, Daniel},\n year={2000},\n publisher={Crc Press}\n}\n@article{2020SciPy-NMeth,\n author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n Bright, Jonathan and {van der Walt}, St{\\'e}fan J. and\n Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n Kern, Robert and Larson, Eric and Carey, C J and\n Polat, {\\.I}lhan and Feng, Yu and Moore, Eric W. and\n {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n Harris, Charles R. and Archibald, Anne M. and\n Ribeiro, Ant{\\^o}nio H. and Pedregosa, Fabian and\n {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\n title = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n Computing in Python}},\n journal = {Nature Methods},\n year = {2020},\n volume = {17},\n pages = {261--272},\n adsurl = {https://rdcu.be/b08Wh},\n doi = {10.1038/s41592-019-0686-2},\n}\n" + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Spearmanr(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('float'), 'references': datasets.Value('float')}), reference_urls=['https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html']) + + def _compute(self, predictions, references, return_pvalue=False): + results = spearmanr(references, predictions) + if return_pvalue: + return {'spearmanr': results[0], 'spearmanr_pvalue': results[1]} + else: + return {'spearmanr': results[0]} + +# File: evaluate-main/metrics/squad/compute_score.py +"""""" +import argparse +import json +import re +import string +import sys +from collections import Counter + +def normalize_answer(s): + + def remove_articles(text): + return re.sub('\\b(a|an|the)\\b', ' ', text) + + def white_space_fix(text): + return ' '.join(text.split()) + + def remove_punc(text): + exclude = set(string.punctuation) + return ''.join((ch for ch in text if ch not in exclude)) + + def lower(text): + return text.lower() + return white_space_fix(remove_articles(remove_punc(lower(s)))) + +def f1_score(prediction, ground_truth): + prediction_tokens = normalize_answer(prediction).split() + ground_truth_tokens = normalize_answer(ground_truth).split() + common = Counter(prediction_tokens) & Counter(ground_truth_tokens) + num_same = sum(common.values()) + if num_same == 0: + return 0 + precision = 1.0 * num_same / len(prediction_tokens) + recall = 1.0 * num_same / len(ground_truth_tokens) + f1 = 2 * precision * recall / (precision + recall) + return f1 + +def exact_match_score(prediction, ground_truth): + return normalize_answer(prediction) == normalize_answer(ground_truth) + +def metric_max_over_ground_truths(metric_fn, prediction, ground_truths): + scores_for_ground_truths = [] + for ground_truth in ground_truths: + score = metric_fn(prediction, ground_truth) + scores_for_ground_truths.append(score) + return max(scores_for_ground_truths) + +def compute_score(dataset, predictions): + f1 = exact_match = total = 0 + for article in dataset: + for paragraph in article['paragraphs']: + for qa in paragraph['qas']: + total += 1 + if qa['id'] not in predictions: + message = 'Unanswered question ' + qa['id'] + ' will receive score 0.' + print(message, file=sys.stderr) + continue + ground_truths = list(map(lambda x: x['text'], qa['answers'])) + prediction = predictions[qa['id']] + exact_match += metric_max_over_ground_truths(exact_match_score, prediction, ground_truths) + f1 += metric_max_over_ground_truths(f1_score, prediction, ground_truths) + exact_match = 100.0 * exact_match / total + f1 = 100.0 * f1 / total + return {'exact_match': exact_match, 'f1': f1} +if __name__ == '__main__': + expected_version = '1.1' + parser = argparse.ArgumentParser(description='Evaluation for SQuAD ' + expected_version) + parser.add_argument('dataset_file', help='Dataset file') + parser.add_argument('prediction_file', help='Prediction File') + args = parser.parse_args() + with open(args.dataset_file) as dataset_file: + dataset_json = json.load(dataset_file) + if dataset_json['version'] != expected_version: + print('Evaluation expects v-' + expected_version + ', but got dataset with v-' + dataset_json['version'], file=sys.stderr) + dataset = dataset_json['data'] + with open(args.prediction_file) as prediction_file: + predictions = json.load(prediction_file) + print(json.dumps(compute_score(dataset, predictions))) + +# File: evaluate-main/metrics/squad/squad.py +"""""" +import datasets +import evaluate +from .compute_score import compute_score +_CITATION = '@inproceedings{Rajpurkar2016SQuAD10,\n title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},\n author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},\n booktitle={EMNLP},\n year={2016}\n}\n' +_DESCRIPTION = '\nThis metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n' +_KWARGS_DESCRIPTION = '\nComputes SQuAD scores (F1 and EM).\nArgs:\n predictions: List of question-answers dictionaries with the following key-values:\n - \'id\': id of the question-answer pair as given in the references (see below)\n - \'prediction_text\': the text of the answer\n references: List of question-answers dictionaries with the following key-values:\n - \'id\': id of the question-answer pair (see above),\n - \'answers\': a Dict in the SQuAD dataset format\n {\n \'text\': list of possible texts for the answer, as a list of strings\n \'answer_start\': list of start positions for the answer, as a list of ints\n }\n Note that answer_start values are not taken into account to compute the metric.\nReturns:\n \'exact_match\': Exact match (the normalized answer exactly match the gold answer)\n \'f1\': The F-score of predicted tokens versus the gold answer\nExamples:\n\n >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\'}]\n >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]\n >>> squad_metric = evaluate.load("squad")\n >>> results = squad_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'exact_match\': 100.0, \'f1\': 100.0}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Squad(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': {'id': datasets.Value('string'), 'prediction_text': datasets.Value('string')}, 'references': {'id': datasets.Value('string'), 'answers': datasets.features.Sequence({'text': datasets.Value('string'), 'answer_start': datasets.Value('int32')})}}), codebase_urls=['https://rajpurkar.github.io/SQuAD-explorer/'], reference_urls=['https://rajpurkar.github.io/SQuAD-explorer/']) + + def _compute(self, predictions, references): + pred_dict = {prediction['id']: prediction['prediction_text'] for prediction in predictions} + dataset = [{'paragraphs': [{'qas': [{'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id']} for ref in references]}]}] + score = compute_score(dataset=dataset, predictions=pred_dict) + return score + +# File: evaluate-main/metrics/squad_v2/compute_score.py +"""""" +import argparse +import collections +import json +import os +import re +import string +import sys +import numpy as np +ARTICLES_REGEX = re.compile('\\b(a|an|the)\\b', re.UNICODE) +OPTS = None + +def parse_args(): + parser = argparse.ArgumentParser('Official evaluation script for SQuAD version 2.0.') + parser.add_argument('data_file', metavar='data.json', help='Input data JSON file.') + parser.add_argument('pred_file', metavar='pred.json', help='Model predictions.') + parser.add_argument('--out-file', '-o', metavar='eval.json', help='Write accuracy metrics to file (default is stdout).') + parser.add_argument('--na-prob-file', '-n', metavar='na_prob.json', help='Model estimates of probability of no answer.') + parser.add_argument('--na-prob-thresh', '-t', type=float, default=1.0, help='Predict "" if no-answer probability exceeds this (default = 1.0).') + parser.add_argument('--out-image-dir', '-p', metavar='out_images', default=None, help='Save precision-recall curves to directory.') + parser.add_argument('--verbose', '-v', action='store_true') + if len(sys.argv) == 1: + parser.print_help() + sys.exit(1) + return parser.parse_args() + +def make_qid_to_has_ans(dataset): + qid_to_has_ans = {} + for article in dataset: + for p in article['paragraphs']: + for qa in p['qas']: + qid_to_has_ans[qa['id']] = bool(qa['answers']['text']) + return qid_to_has_ans + +def normalize_answer(s): + + def remove_articles(text): + return ARTICLES_REGEX.sub(' ', text) + + def white_space_fix(text): + return ' '.join(text.split()) + + def remove_punc(text): + exclude = set(string.punctuation) + return ''.join((ch for ch in text if ch not in exclude)) + + def lower(text): + return text.lower() + return white_space_fix(remove_articles(remove_punc(lower(s)))) + +def get_tokens(s): + if not s: + return [] + return normalize_answer(s).split() + +def compute_exact(a_gold, a_pred): + return int(normalize_answer(a_gold) == normalize_answer(a_pred)) + +def compute_f1(a_gold, a_pred): + gold_toks = get_tokens(a_gold) + pred_toks = get_tokens(a_pred) + common = collections.Counter(gold_toks) & collections.Counter(pred_toks) + num_same = sum(common.values()) + if len(gold_toks) == 0 or len(pred_toks) == 0: + return int(gold_toks == pred_toks) + if num_same == 0: + return 0 + precision = 1.0 * num_same / len(pred_toks) + recall = 1.0 * num_same / len(gold_toks) + f1 = 2 * precision * recall / (precision + recall) + return f1 + +def get_raw_scores(dataset, preds): + exact_scores = {} + f1_scores = {} + for article in dataset: + for p in article['paragraphs']: + for qa in p['qas']: + qid = qa['id'] + gold_answers = [t for t in qa['answers']['text'] if normalize_answer(t)] + if not gold_answers: + gold_answers = [''] + if qid not in preds: + print(f'Missing prediction for {qid}') + continue + a_pred = preds[qid] + exact_scores[qid] = max((compute_exact(a, a_pred) for a in gold_answers)) + f1_scores[qid] = max((compute_f1(a, a_pred) for a in gold_answers)) + return (exact_scores, f1_scores) + +def apply_no_ans_threshold(scores, na_probs, qid_to_has_ans, na_prob_thresh): + new_scores = {} + for (qid, s) in scores.items(): + pred_na = na_probs[qid] > na_prob_thresh + if pred_na: + new_scores[qid] = float(not qid_to_has_ans[qid]) + else: + new_scores[qid] = s + return new_scores + +def make_eval_dict(exact_scores, f1_scores, qid_list=None): + if not qid_list: + total = len(exact_scores) + return collections.OrderedDict([('exact', 100.0 * sum(exact_scores.values()) / total), ('f1', 100.0 * sum(f1_scores.values()) / total), ('total', total)]) + else: + total = len(qid_list) + return collections.OrderedDict([('exact', 100.0 * sum((exact_scores[k] for k in qid_list)) / total), ('f1', 100.0 * sum((f1_scores[k] for k in qid_list)) / total), ('total', total)]) + +def merge_eval(main_eval, new_eval, prefix): + for k in new_eval: + main_eval[f'{prefix}_{k}'] = new_eval[k] + +def plot_pr_curve(precisions, recalls, out_image, title): + plt.step(recalls, precisions, color='b', alpha=0.2, where='post') + plt.fill_between(recalls, precisions, step='post', alpha=0.2, color='b') + plt.xlabel('Recall') + plt.ylabel('Precision') + plt.xlim([0.0, 1.05]) + plt.ylim([0.0, 1.05]) + plt.title(title) + plt.savefig(out_image) + plt.clf() + +def make_precision_recall_eval(scores, na_probs, num_true_pos, qid_to_has_ans, out_image=None, title=None): + qid_list = sorted(na_probs, key=lambda k: na_probs[k]) + true_pos = 0.0 + cur_p = 1.0 + cur_r = 0.0 + precisions = [1.0] + recalls = [0.0] + avg_prec = 0.0 + for (i, qid) in enumerate(qid_list): + if qid_to_has_ans[qid]: + true_pos += scores[qid] + cur_p = true_pos / float(i + 1) + cur_r = true_pos / float(num_true_pos) + if i == len(qid_list) - 1 or na_probs[qid] != na_probs[qid_list[i + 1]]: + avg_prec += cur_p * (cur_r - recalls[-1]) + precisions.append(cur_p) + recalls.append(cur_r) + if out_image: + plot_pr_curve(precisions, recalls, out_image, title) + return {'ap': 100.0 * avg_prec} + +def run_precision_recall_analysis(main_eval, exact_raw, f1_raw, na_probs, qid_to_has_ans, out_image_dir): + if out_image_dir and (not os.path.exists(out_image_dir)): + os.makedirs(out_image_dir) + num_true_pos = sum((1 for v in qid_to_has_ans.values() if v)) + if num_true_pos == 0: + return + pr_exact = make_precision_recall_eval(exact_raw, na_probs, num_true_pos, qid_to_has_ans, out_image=os.path.join(out_image_dir, 'pr_exact.png'), title='Precision-Recall curve for Exact Match score') + pr_f1 = make_precision_recall_eval(f1_raw, na_probs, num_true_pos, qid_to_has_ans, out_image=os.path.join(out_image_dir, 'pr_f1.png'), title='Precision-Recall curve for F1 score') + oracle_scores = {k: float(v) for (k, v) in qid_to_has_ans.items()} + pr_oracle = make_precision_recall_eval(oracle_scores, na_probs, num_true_pos, qid_to_has_ans, out_image=os.path.join(out_image_dir, 'pr_oracle.png'), title='Oracle Precision-Recall curve (binary task of HasAns vs. NoAns)') + merge_eval(main_eval, pr_exact, 'pr_exact') + merge_eval(main_eval, pr_f1, 'pr_f1') + merge_eval(main_eval, pr_oracle, 'pr_oracle') + +def histogram_na_prob(na_probs, qid_list, image_dir, name): + if not qid_list: + return + x = [na_probs[k] for k in qid_list] + weights = np.ones_like(x) / float(len(x)) + plt.hist(x, weights=weights, bins=20, range=(0.0, 1.0)) + plt.xlabel('Model probability of no-answer') + plt.ylabel('Proportion of dataset') + plt.title(f'Histogram of no-answer probability: {name}') + plt.savefig(os.path.join(image_dir, f'na_prob_hist_{name}.png')) + plt.clf() + +def find_best_thresh(preds, scores, na_probs, qid_to_has_ans): + num_no_ans = sum((1 for k in qid_to_has_ans if not qid_to_has_ans[k])) + cur_score = num_no_ans + best_score = cur_score + best_thresh = 0.0 + qid_list = sorted(na_probs, key=lambda k: na_probs[k]) + for (i, qid) in enumerate(qid_list): + if qid not in scores: + continue + if qid_to_has_ans[qid]: + diff = scores[qid] + elif preds[qid]: + diff = -1 + else: + diff = 0 + cur_score += diff + if cur_score > best_score: + best_score = cur_score + best_thresh = na_probs[qid] + return (100.0 * best_score / len(scores), best_thresh) + +def find_all_best_thresh(main_eval, preds, exact_raw, f1_raw, na_probs, qid_to_has_ans): + (best_exact, exact_thresh) = find_best_thresh(preds, exact_raw, na_probs, qid_to_has_ans) + (best_f1, f1_thresh) = find_best_thresh(preds, f1_raw, na_probs, qid_to_has_ans) + main_eval['best_exact'] = best_exact + main_eval['best_exact_thresh'] = exact_thresh + main_eval['best_f1'] = best_f1 + main_eval['best_f1_thresh'] = f1_thresh + +def main(): + with open(OPTS.data_file) as f: + dataset_json = json.load(f) + dataset = dataset_json['data'] + with open(OPTS.pred_file) as f: + preds = json.load(f) + if OPTS.na_prob_file: + with open(OPTS.na_prob_file) as f: + na_probs = json.load(f) + else: + na_probs = {k: 0.0 for k in preds} + qid_to_has_ans = make_qid_to_has_ans(dataset) + has_ans_qids = [k for (k, v) in qid_to_has_ans.items() if v] + no_ans_qids = [k for (k, v) in qid_to_has_ans.items() if not v] + (exact_raw, f1_raw) = get_raw_scores(dataset, preds) + exact_thresh = apply_no_ans_threshold(exact_raw, na_probs, qid_to_has_ans, OPTS.na_prob_thresh) + f1_thresh = apply_no_ans_threshold(f1_raw, na_probs, qid_to_has_ans, OPTS.na_prob_thresh) + out_eval = make_eval_dict(exact_thresh, f1_thresh) + if has_ans_qids: + has_ans_eval = make_eval_dict(exact_thresh, f1_thresh, qid_list=has_ans_qids) + merge_eval(out_eval, has_ans_eval, 'HasAns') + if no_ans_qids: + no_ans_eval = make_eval_dict(exact_thresh, f1_thresh, qid_list=no_ans_qids) + merge_eval(out_eval, no_ans_eval, 'NoAns') + if OPTS.na_prob_file: + find_all_best_thresh(out_eval, preds, exact_raw, f1_raw, na_probs, qid_to_has_ans) + if OPTS.na_prob_file and OPTS.out_image_dir: + run_precision_recall_analysis(out_eval, exact_raw, f1_raw, na_probs, qid_to_has_ans, OPTS.out_image_dir) + histogram_na_prob(na_probs, has_ans_qids, OPTS.out_image_dir, 'hasAns') + histogram_na_prob(na_probs, no_ans_qids, OPTS.out_image_dir, 'noAns') + if OPTS.out_file: + with open(OPTS.out_file, 'w') as f: + json.dump(out_eval, f) + else: + print(json.dumps(out_eval, indent=2)) +if __name__ == '__main__': + OPTS = parse_args() + if OPTS.out_image_dir: + import matplotlib + matplotlib.use('Agg') + import matplotlib.pyplot as plt + main() + +# File: evaluate-main/metrics/squad_v2/squad_v2.py +"""""" +import datasets +import evaluate +from .compute_score import apply_no_ans_threshold, find_all_best_thresh, get_raw_scores, make_eval_dict, make_qid_to_has_ans, merge_eval +_CITATION = '@inproceedings{Rajpurkar2016SQuAD10,\n title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},\n author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},\n booktitle={EMNLP},\n year={2016}\n}\n' +_DESCRIPTION = '\nThis metric wrap the official scoring script for version 2 of the Stanford Question\nAnswering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n\nSQuAD2.0 combines the 100,000 questions in SQuAD1.1 with over 50,000 unanswerable questions\nwritten adversarially by crowdworkers to look similar to answerable ones.\nTo do well on SQuAD2.0, systems must not only answer questions when possible, but also\ndetermine when no answer is supported by the paragraph and abstain from answering.\n' +_KWARGS_DESCRIPTION = '\nComputes SQuAD v2 scores (F1 and EM).\nArgs:\n predictions: List of triple for question-answers to score with the following elements:\n - the question-answer \'id\' field as given in the references (see below)\n - the text of the answer\n - the probability that the question has no answer\n references: List of question-answers dictionaries with the following key-values:\n - \'id\': id of the question-answer pair (see above),\n - \'answers\': a list of Dict {\'text\': text of the answer as a string}\n no_answer_threshold: float\n Probability threshold to decide that a question has no answer.\nReturns:\n \'exact\': Exact match (the normalized answer exactly match the gold answer)\n \'f1\': The F-score of predicted tokens versus the gold answer\n \'total\': Number of score considered\n \'HasAns_exact\': Exact match (the normalized answer exactly match the gold answer)\n \'HasAns_f1\': The F-score of predicted tokens versus the gold answer\n \'HasAns_total\': Number of score considered\n \'NoAns_exact\': Exact match (the normalized answer exactly match the gold answer)\n \'NoAns_f1\': The F-score of predicted tokens versus the gold answer\n \'NoAns_total\': Number of score considered\n \'best_exact\': Best exact match (with varying threshold)\n \'best_exact_thresh\': No-answer probability threshold associated to the best exact match\n \'best_f1\': Best F1 (with varying threshold)\n \'best_f1_thresh\': No-answer probability threshold associated to the best F1\nExamples:\n\n >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\', \'no_answer_probability\': 0.}]\n >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]\n >>> squad_v2_metric = evaluate.load("squad_v2")\n >>> results = squad_v2_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'exact\': 100.0, \'f1\': 100.0, \'total\': 1, \'HasAns_exact\': 100.0, \'HasAns_f1\': 100.0, \'HasAns_total\': 1, \'best_exact\': 100.0, \'best_exact_thresh\': 0.0, \'best_f1\': 100.0, \'best_f1_thresh\': 0.0}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class SquadV2(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': {'id': datasets.Value('string'), 'prediction_text': datasets.Value('string'), 'no_answer_probability': datasets.Value('float32')}, 'references': {'id': datasets.Value('string'), 'answers': datasets.features.Sequence({'text': datasets.Value('string'), 'answer_start': datasets.Value('int32')})}}), codebase_urls=['https://rajpurkar.github.io/SQuAD-explorer/'], reference_urls=['https://rajpurkar.github.io/SQuAD-explorer/']) + + def _compute(self, predictions, references, no_answer_threshold=1.0): + no_answer_probabilities = {p['id']: p['no_answer_probability'] for p in predictions} + dataset = [{'paragraphs': [{'qas': references}]}] + predictions = {p['id']: p['prediction_text'] for p in predictions} + qid_to_has_ans = make_qid_to_has_ans(dataset) + has_ans_qids = [k for (k, v) in qid_to_has_ans.items() if v] + no_ans_qids = [k for (k, v) in qid_to_has_ans.items() if not v] + (exact_raw, f1_raw) = get_raw_scores(dataset, predictions) + exact_thresh = apply_no_ans_threshold(exact_raw, no_answer_probabilities, qid_to_has_ans, no_answer_threshold) + f1_thresh = apply_no_ans_threshold(f1_raw, no_answer_probabilities, qid_to_has_ans, no_answer_threshold) + out_eval = make_eval_dict(exact_thresh, f1_thresh) + if has_ans_qids: + has_ans_eval = make_eval_dict(exact_thresh, f1_thresh, qid_list=has_ans_qids) + merge_eval(out_eval, has_ans_eval, 'HasAns') + if no_ans_qids: + no_ans_eval = make_eval_dict(exact_thresh, f1_thresh, qid_list=no_ans_qids) + merge_eval(out_eval, no_ans_eval, 'NoAns') + find_all_best_thresh(out_eval, predictions, exact_raw, f1_raw, no_answer_probabilities, qid_to_has_ans) + return dict(out_eval) + +# File: evaluate-main/metrics/super_glue/record_evaluation.py +"""""" +import argparse +import json +import re +import string +import sys +from collections import Counter + +def normalize_answer(s): + + def remove_articles(text): + return re.sub('\\b(a|an|the)\\b', ' ', text) + + def white_space_fix(text): + return ' '.join(text.split()) + + def remove_punc(text): + exclude = set(string.punctuation) + return ''.join((ch for ch in text if ch not in exclude)) + + def lower(text): + return text.lower() + return white_space_fix(remove_articles(remove_punc(lower(s)))) + +def f1_score(prediction, ground_truth): + prediction_tokens = normalize_answer(prediction).split() + ground_truth_tokens = normalize_answer(ground_truth).split() + common = Counter(prediction_tokens) & Counter(ground_truth_tokens) + num_same = sum(common.values()) + if num_same == 0: + return 0 + precision = 1.0 * num_same / len(prediction_tokens) + recall = 1.0 * num_same / len(ground_truth_tokens) + f1 = 2 * precision * recall / (precision + recall) + return f1 + +def exact_match_score(prediction, ground_truth): + return normalize_answer(prediction) == normalize_answer(ground_truth) + +def metric_max_over_ground_truths(metric_fn, prediction, ground_truths): + scores_for_ground_truths = [] + for ground_truth in ground_truths: + score = metric_fn(prediction, ground_truth) + scores_for_ground_truths.append(score) + return max(scores_for_ground_truths) + +def evaluate(dataset, predictions): + f1 = exact_match = total = 0 + correct_ids = [] + for passage in dataset: + for qa in passage['qas']: + total += 1 + if qa['id'] not in predictions: + message = f"Unanswered question {qa['id']} will receive score 0." + print(message, file=sys.stderr) + continue + ground_truths = list(map(lambda x: x['text'], qa['answers'])) + prediction = predictions[qa['id']] + _exact_match = metric_max_over_ground_truths(exact_match_score, prediction, ground_truths) + if int(_exact_match) == 1: + correct_ids.append(qa['id']) + exact_match += _exact_match + f1 += metric_max_over_ground_truths(f1_score, prediction, ground_truths) + exact_match = exact_match / total + f1 = f1 / total + return ({'exact_match': exact_match, 'f1': f1}, correct_ids) +if __name__ == '__main__': + expected_version = '1.0' + parser = argparse.ArgumentParser('Official evaluation script for ReCoRD v1.0.') + parser.add_argument('data_file', help='The dataset file in JSON format.') + parser.add_argument('pred_file', help='The model prediction file in JSON format.') + parser.add_argument('--output_correct_ids', action='store_true', help='Output the correctly answered query IDs.') + args = parser.parse_args() + with open(args.data_file) as data_file: + dataset_json = json.load(data_file) + if dataset_json['version'] != expected_version: + print(f"Evaluation expects v-{expected_version}, but got dataset with v-{dataset_json['version']}", file=sys.stderr) + dataset = dataset_json['data'] + with open(args.pred_file) as pred_file: + predictions = json.load(pred_file) + (metrics, correct_ids) = evaluate(dataset, predictions) + if args.output_correct_ids: + print(f'Output {len(correct_ids)} correctly answered question IDs.') + with open('correct_ids.json', 'w') as f: + json.dump(correct_ids, f) + +# File: evaluate-main/metrics/super_glue/super_glue.py +"""""" +import datasets +from sklearn.metrics import f1_score, matthews_corrcoef +import evaluate +from .record_evaluation import evaluate as evaluate_record +_CITATION = '@article{wang2019superglue,\n title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},\n author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R},\n journal={arXiv preprint arXiv:1905.00537},\n year={2019}\n}\n' +_DESCRIPTION = 'SuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after\nGLUE with a new set of more difficult language understanding tasks, improved\nresources, and a new public leaderboard.\n' +_KWARGS_DESCRIPTION = '\nCompute SuperGLUE evaluation metric associated to each SuperGLUE dataset.\nArgs:\n predictions: list of predictions to score. Depending on the SuperGlUE subset:\n - for \'record\': list of question-answer dictionaries with the following keys:\n - \'idx\': index of the question as specified by the dataset\n - \'prediction_text\': the predicted answer text\n - for \'multirc\': list of question-answer dictionaries with the following keys:\n - \'idx\': index of the question-answer pair as specified by the dataset\n - \'prediction\': the predicted answer label\n - otherwise: list of predicted labels\n references: list of reference labels. Depending on the SuperGLUE subset:\n - for \'record\': list of question-answers dictionaries with the following keys:\n - \'idx\': index of the question as specified by the dataset\n - \'answers\': list of possible answers\n - otherwise: list of reference labels\nReturns: depending on the SuperGLUE subset:\n - for \'record\':\n - \'exact_match\': Exact match between answer and gold answer\n - \'f1\': F1 score\n - for \'multirc\':\n - \'exact_match\': Exact match between answer and gold answer\n - \'f1_m\': Per-question macro-F1 score\n - \'f1_a\': Average F1 score over all answers\n - for \'axb\':\n \'matthews_correlation\': Matthew Correlation\n - for \'cb\':\n - \'accuracy\': Accuracy\n - \'f1\': F1 score\n - for all others:\n - \'accuracy\': Accuracy\nExamples:\n\n >>> super_glue_metric = evaluate.load(\'super_glue\', \'copa\') # any of ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]\n >>> predictions = [0, 1]\n >>> references = [0, 1]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'accuracy\': 1.0}\n\n >>> super_glue_metric = evaluate.load(\'super_glue\', \'cb\')\n >>> predictions = [0, 1]\n >>> references = [0, 1]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'accuracy\': 1.0, \'f1\': 1.0}\n\n >>> super_glue_metric = evaluate.load(\'super_glue\', \'record\')\n >>> predictions = [{\'idx\': {\'passage\': 0, \'query\': 0}, \'prediction_text\': \'answer\'}]\n >>> references = [{\'idx\': {\'passage\': 0, \'query\': 0}, \'answers\': [\'answer\', \'another_answer\']}]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'exact_match\': 1.0, \'f1\': 1.0}\n\n >>> super_glue_metric = evaluate.load(\'super_glue\', \'multirc\')\n >>> predictions = [{\'idx\': {\'answer\': 0, \'paragraph\': 0, \'question\': 0}, \'prediction\': 0}, {\'idx\': {\'answer\': 1, \'paragraph\': 2, \'question\': 3}, \'prediction\': 1}]\n >>> references = [0, 1]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'exact_match\': 1.0, \'f1_m\': 1.0, \'f1_a\': 1.0}\n\n >>> super_glue_metric = evaluate.load(\'super_glue\', \'axb\')\n >>> references = [0, 1]\n >>> predictions = [0, 1]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'matthews_correlation\': 1.0}\n' + +def simple_accuracy(preds, labels): + return float((preds == labels).mean()) + +def acc_and_f1(preds, labels, f1_avg='binary'): + acc = simple_accuracy(preds, labels) + f1 = float(f1_score(y_true=labels, y_pred=preds, average=f1_avg)) + return {'accuracy': acc, 'f1': f1} + +def evaluate_multirc(ids_preds, labels): + question_map = {} + for (id_pred, label) in zip(ids_preds, labels): + question_id = f"{id_pred['idx']['paragraph']}-{id_pred['idx']['question']}" + pred = id_pred['prediction'] + if question_id in question_map: + question_map[question_id].append((pred, label)) + else: + question_map[question_id] = [(pred, label)] + (f1s, ems) = ([], []) + for (question, preds_labels) in question_map.items(): + (question_preds, question_labels) = zip(*preds_labels) + f1 = f1_score(y_true=question_labels, y_pred=question_preds, average='macro') + f1s.append(f1) + em = int(sum((p == l for (p, l) in preds_labels)) == len(preds_labels)) + ems.append(em) + f1_m = float(sum(f1s) / len(f1s)) + em = sum(ems) / len(ems) + f1_a = float(f1_score(y_true=labels, y_pred=[id_pred['prediction'] for id_pred in ids_preds])) + return {'exact_match': em, 'f1_m': f1_m, 'f1_a': f1_a} + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class SuperGlue(evaluate.Metric): + + def _info(self): + if self.config_name not in ['boolq', 'cb', 'copa', 'multirc', 'record', 'rte', 'wic', 'wsc', 'wsc.fixed', 'axb', 'axg']: + raise KeyError('You should supply a configuration name selected in ["boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg",]') + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features(self._get_feature_types()), codebase_urls=[], reference_urls=[], format='numpy' if not self.config_name == 'record' and (not self.config_name == 'multirc') else None) + + def _get_feature_types(self): + if self.config_name == 'record': + return {'predictions': {'idx': {'passage': datasets.Value('int64'), 'query': datasets.Value('int64')}, 'prediction_text': datasets.Value('string')}, 'references': {'idx': {'passage': datasets.Value('int64'), 'query': datasets.Value('int64')}, 'answers': datasets.Sequence(datasets.Value('string'))}} + elif self.config_name == 'multirc': + return {'predictions': {'idx': {'answer': datasets.Value('int64'), 'paragraph': datasets.Value('int64'), 'question': datasets.Value('int64')}, 'prediction': datasets.Value('int64')}, 'references': datasets.Value('int64')} + else: + return {'predictions': datasets.Value('int64'), 'references': datasets.Value('int64')} + + def _compute(self, predictions, references): + if self.config_name == 'axb': + return {'matthews_correlation': matthews_corrcoef(references, predictions)} + elif self.config_name == 'cb': + return acc_and_f1(predictions, references, f1_avg='macro') + elif self.config_name == 'record': + dataset = [{'qas': [{'id': ref['idx']['query'], 'answers': [{'text': ans} for ans in ref['answers']]} for ref in references]}] + predictions = {pred['idx']['query']: pred['prediction_text'] for pred in predictions} + return evaluate_record(dataset, predictions)[0] + elif self.config_name == 'multirc': + return evaluate_multirc(predictions, references) + elif self.config_name in ['copa', 'rte', 'wic', 'wsc', 'wsc.fixed', 'boolq', 'axg']: + return {'accuracy': simple_accuracy(predictions, references)} + else: + raise KeyError('You should supply a configuration name selected in ["boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg",]') + +# File: evaluate-main/metrics/ter/ter.py +"""""" +import datasets +import sacrebleu as scb +from packaging import version +from sacrebleu import TER +import evaluate +_CITATION = '@inproceedings{snover-etal-2006-study,\n title = "A Study of Translation Edit Rate with Targeted Human Annotation",\n author = "Snover, Matthew and\n Dorr, Bonnie and\n Schwartz, Rich and\n Micciulla, Linnea and\n Makhoul, John",\n booktitle = "Proceedings of the 7th Conference of the Association for Machine Translation in the Americas: Technical Papers",\n month = aug # " 8-12",\n year = "2006",\n address = "Cambridge, Massachusetts, USA",\n publisher = "Association for Machine Translation in the Americas",\n url = "https://aclanthology.org/2006.amta-papers.25",\n pages = "223--231",\n}\n@inproceedings{post-2018-call,\n title = "A Call for Clarity in Reporting {BLEU} Scores",\n author = "Post, Matt",\n booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n month = oct,\n year = "2018",\n address = "Belgium, Brussels",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/W18-6319",\n pages = "186--191",\n}\n' +_DESCRIPTION = "TER (Translation Edit Rate, also called Translation Error Rate) is a metric to quantify the edit operations that a\nhypothesis requires to match a reference translation. We use the implementation that is already present in sacrebleu\n(https://github.com/mjpost/sacreBLEU#ter), which in turn is inspired by the TERCOM implementation, which can be found\nhere: https://github.com/jhclark/tercom.\n\nThe implementation here is slightly different from sacrebleu in terms of the required input format. The length of\nthe references and hypotheses lists need to be the same, so you may need to transpose your references compared to\nsacrebleu's required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534\n\nSee the README.md file at https://github.com/mjpost/sacreBLEU#ter for more information.\n" +_KWARGS_DESCRIPTION = '\nProduces TER scores alongside the number of edits and reference length.\n\nArgs:\n predictions (list of str): The system stream (a sequence of segments).\n references (list of list of str): A list of one or more reference streams (each a sequence of segments).\n normalized (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.\n ignore_punct (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.\n support_zh_ja_chars (boolean): If `True`, tokenization/normalization supports processing of Chinese characters,\n as well as Japanese Kanji, Hiragana, Katakana, and Phonetic Extensions of Katakana.\n Only applies if `normalized = True`. Defaults to `False`.\n case_sensitive (boolean): If `False`, makes all predictions and references lowercase to ignore differences in case. Defaults to `False`.\n\nReturns:\n \'score\' (float): TER score (num_edits / sum_ref_lengths * 100)\n \'num_edits\' (int): The cumulative number of edits\n \'ref_length\' (float): The cumulative average reference length\n\nExamples:\n Example 1:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?",\n ... "What did the TER metric user say to the developer?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"],\n ... ["Your jokes are...", "...TERrible"]]\n >>> ter = evaluate.load("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... case_sensitive=True)\n >>> print(results)\n {\'score\': 150.0, \'num_edits\': 15, \'ref_length\': 10.0}\n\n Example 2:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"]]\n >>> ter = evaluate.load("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... case_sensitive=True)\n >>> print(results)\n {\'score\': 62.5, \'num_edits\': 5, \'ref_length\': 8.0}\n\n Example 3:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"]]\n >>> ter = evaluate.load("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... normalized=True,\n ... case_sensitive=True)\n >>> print(results)\n {\'score\': 57.14285714285714, \'num_edits\': 6, \'ref_length\': 10.5}\n\n Example 4:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"]]\n >>> ter = evaluate.load("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... ignore_punct=True,\n ... case_sensitive=False)\n >>> print(results)\n {\'score\': 0.0, \'num_edits\': 0, \'ref_length\': 8.0}\n\n Example 5:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?",\n ... "What did the TER metric user say to the developer?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"],\n ... ["Your jokes are...", "...TERrible"]]\n >>> ter = evaluate.load("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... ignore_punct=True,\n ... case_sensitive=False)\n >>> print(results)\n {\'score\': 100.0, \'num_edits\': 10, \'ref_length\': 10.0}\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Ter(evaluate.Metric): + + def _info(self): + 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.\nYou can install it with `pip install "sacrebleu>=1.4.12"`.') + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, homepage='http://www.cs.umd.edu/~snover/tercom/', inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'), id='references')}), datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')})], codebase_urls=['https://github.com/mjpost/sacreBLEU#ter'], reference_urls=['https://github.com/jhclark/tercom']) + + def _compute(self, predictions, references, normalized: bool=False, ignore_punct: bool=False, support_zh_ja_chars: bool=False, case_sensitive: bool=False): + if isinstance(references[0], str): + references = [[ref] for ref in references] + references_per_prediction = len(references[0]) + if any((len(refs) != references_per_prediction for refs in references)): + raise ValueError('Sacrebleu requires the same number of references for each prediction') + transformed_references = [[refs[i] for refs in references] for i in range(references_per_prediction)] + sb_ter = TER(normalized=normalized, no_punct=ignore_punct, asian_support=support_zh_ja_chars, case_sensitive=case_sensitive) + output = sb_ter.corpus_score(predictions, transformed_references) + return {'score': output.score, 'num_edits': output.num_edits, 'ref_length': output.ref_length} + +# File: evaluate-main/metrics/trec_eval/trec_eval.py +"""""" +import datasets +import pandas as pd +from trectools import TrecEval, TrecQrel, TrecRun +import evaluate +_CITATION = "@inproceedings{palotti2019,\n author = {Palotti, Joao and Scells, Harrisen and Zuccon, Guido},\n title = {TrecTools: an open-source Python library for Information Retrieval practitioners involved in TREC-like campaigns},\n series = {SIGIR'19},\n year = {2019},\n location = {Paris, France},\n publisher = {ACM}\n}\n" +_DESCRIPTION = 'The TREC Eval metric combines a number of information retrieval metrics such as precision and nDCG. It is used to score rankings of retrieved documents with reference values.' +_KWARGS_DESCRIPTION = '\nCalculates TREC evaluation scores based on a run and qrel.\nArgs:\n predictions: list containing a single run.\n references: list containing a single qrel.\nReturns:\n dict: TREC evaluation scores.\nExamples:\n >>> trec = evaluate.load("trec_eval")\n >>> qrel = {\n ... "query": [0],\n ... "q0": ["0"],\n ... "docid": ["doc_1"],\n ... "rel": [2]\n ... }\n >>> run = {\n ... "query": [0, 0],\n ... "q0": ["q0", "q0"],\n ... "docid": ["doc_2", "doc_1"],\n ... "rank": [0, 1],\n ... "score": [1.5, 1.2],\n ... "system": ["test", "test"]\n ... }\n >>> results = trec.compute(references=[qrel], predictions=[run])\n >>> print(results["P@5"])\n 0.2\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class TRECEval(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(module_type='metric', description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': {'query': datasets.Sequence(datasets.Value('int64')), 'q0': datasets.Sequence(datasets.Value('string')), 'docid': datasets.Sequence(datasets.Value('string')), 'rank': datasets.Sequence(datasets.Value('int64')), 'score': datasets.Sequence(datasets.Value('float')), 'system': datasets.Sequence(datasets.Value('string'))}, 'references': {'query': datasets.Sequence(datasets.Value('int64')), 'q0': datasets.Sequence(datasets.Value('string')), 'docid': datasets.Sequence(datasets.Value('string')), 'rel': datasets.Sequence(datasets.Value('int64'))}}), homepage='https://github.com/joaopalotti/trectools') + + def _compute(self, references, predictions): + if len(predictions) > 1 or len(references) > 1: + raise ValueError(f'You can only pass one prediction and reference per evaluation. You passed {len(predictions)} prediction(s) and {len(references)} reference(s).') + df_run = pd.DataFrame(predictions[0]) + df_qrel = pd.DataFrame(references[0]) + trec_run = TrecRun() + trec_run.filename = 'placeholder.file' + trec_run.run_data = df_run + trec_qrel = TrecQrel() + trec_qrel.filename = 'placeholder.file' + trec_qrel.qrels_data = df_qrel + trec_eval = TrecEval(trec_run, trec_qrel) + result = {} + result['runid'] = trec_eval.run.get_runid() + result['num_ret'] = trec_eval.get_retrieved_documents(per_query=False) + result['num_rel'] = trec_eval.get_relevant_documents(per_query=False) + result['num_rel_ret'] = trec_eval.get_relevant_retrieved_documents(per_query=False) + result['num_q'] = len(trec_eval.run.topics()) + result['map'] = trec_eval.get_map(depth=10000, per_query=False, trec_eval=True) + result['gm_map'] = trec_eval.get_geometric_map(depth=10000, trec_eval=True) + result['bpref'] = trec_eval.get_bpref(depth=1000, per_query=False, trec_eval=True) + result['Rprec'] = trec_eval.get_rprec(depth=1000, per_query=False, trec_eval=True) + result['recip_rank'] = trec_eval.get_reciprocal_rank(depth=1000, per_query=False, trec_eval=True) + for v in [5, 10, 15, 20, 30, 100, 200, 500, 1000]: + result[f'P@{v}'] = trec_eval.get_precision(depth=v, per_query=False, trec_eval=True) + for v in [5, 10, 15, 20, 30, 100, 200, 500, 1000]: + result[f'NDCG@{v}'] = trec_eval.get_ndcg(depth=v, per_query=False, trec_eval=True) + return result + +# File: evaluate-main/metrics/wer/wer.py +"""""" +import datasets +from jiwer import compute_measures +import evaluate +_CITATION = '@inproceedings{inproceedings,\n author = {Morris, Andrew and Maier, Viktoria and Green, Phil},\n year = {2004},\n month = {01},\n pages = {},\n title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}\n}\n' +_DESCRIPTION = 'Word error rate (WER) is a common metric of the performance of an automatic speech recognition system.\n\nThe general difficulty of measuring performance lies in the fact that the recognized word sequence can have a different length from the reference word sequence (supposedly the correct one). The WER is derived from the Levenshtein distance, working at the word level instead of the phoneme level. The WER is a valuable tool for comparing different systems as well as for evaluating improvements within one system. This kind of measurement, however, provides no details on the nature of translation errors and further work is therefore required to identify the main source(s) of error and to focus any research effort.\n\nThis problem is solved by first aligning the recognized word sequence with the reference (spoken) word sequence using dynamic string alignment. Examination of this issue is seen through a theory called the power law that states the correlation between perplexity and word error rate.\n\nWord error rate can then be computed as:\n\nWER = (S + D + I) / N = (S + D + I) / (S + D + C)\n\nwhere\n\nS is the number of substitutions,\nD is the number of deletions,\nI is the number of insertions,\nC is the number of correct words,\nN is the number of words in the reference (N=S+D+C).\n\nThis value indicates the average number of errors per reference word. The lower the value, the better the\nperformance of the ASR system with a WER of 0 being a perfect score.\n' +_KWARGS_DESCRIPTION = '\nCompute WER score of transcribed segments against references.\n\nArgs:\n references: List of references for each speech input.\n predictions: List of transcriptions to score.\n concatenate_texts (bool, default=False): Whether to concatenate all input texts or compute WER iteratively.\n\nReturns:\n (float): the word error rate\n\nExamples:\n\n >>> predictions = ["this is the prediction", "there is an other sample"]\n >>> references = ["this is the reference", "there is another one"]\n >>> wer = evaluate.load("wer")\n >>> wer_score = wer.compute(predictions=predictions, references=references)\n >>> print(wer_score)\n 0.5\n' + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class WER(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')}), codebase_urls=['https://github.com/jitsi/jiwer/'], reference_urls=['https://en.wikipedia.org/wiki/Word_error_rate']) + + def _compute(self, predictions=None, references=None, concatenate_texts=False): + if concatenate_texts: + return compute_measures(references, predictions)['wer'] + else: + incorrect = 0 + total = 0 + for (prediction, reference) in zip(predictions, references): + measures = compute_measures(reference, prediction) + incorrect += measures['substitutions'] + measures['deletions'] + measures['insertions'] + total += measures['substitutions'] + measures['deletions'] + measures['hits'] + return incorrect / total + +# File: evaluate-main/metrics/wiki_split/wiki_split.py +"""""" +import re +import string +from collections import Counter +import datasets +import sacrebleu +import sacremoses +from packaging import version +import evaluate +_CITATION = '\n@inproceedings{xu-etal-2016-optimizing,\n title = {Optimizing Statistical Machine Translation for Text Simplification},\n authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\n journal = {Transactions of the Association for Computational Linguistics},\n volume = {4},\n year={2016},\n url = {https://www.aclweb.org/anthology/Q16-1029},\n pages = {401--415\n},\n@inproceedings{post-2018-call,\n title = "A Call for Clarity in Reporting {BLEU} Scores",\n author = "Post, Matt",\n booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n month = oct,\n year = "2018",\n address = "Belgium, Brussels",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/W18-6319",\n pages = "186--191",\n}\n' +_DESCRIPTION = 'WIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU\nIt can be used to evaluate the quality of machine-generated texts.\n' +_KWARGS_DESCRIPTION = '\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.\nArgs:\n sources: list of source sentences where each sentence should be a string.\n predictions: list of predicted sentences where each sentence should be a string.\n references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n sari: sari score\n sacrebleu: sacrebleu score\n exact: exact score\n\nExamples:\n >>> sources=["About 95 species are currently accepted ."]\n >>> predictions=["About 95 you now get in ."]\n >>> references=[["About 95 species are currently known ."]]\n >>> wiki_split = evaluate.load("wiki_split")\n >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)\n >>> print(results)\n {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}\n' + +def normalize_answer(s): + + def remove_articles(text): + regex = re.compile('\\b(a|an|the)\\b', re.UNICODE) + return re.sub(regex, ' ', text) + + def white_space_fix(text): + return ' '.join(text.split()) + + def remove_punc(text): + exclude = set(string.punctuation) + return ''.join((ch for ch in text if ch not in exclude)) + + def lower(text): + return text.lower() + return white_space_fix(remove_articles(remove_punc(lower(s)))) + +def compute_exact(a_gold, a_pred): + return int(normalize_answer(a_gold) == normalize_answer(a_pred)) + +def compute_em(predictions, references): + scores = [any([compute_exact(ref, pred) for ref in refs]) for (pred, refs) in zip(predictions, references)] + return sum(scores) / len(scores) * 100 + +def SARIngram(sgrams, cgrams, rgramslist, numref): + rgramsall = [rgram for rgrams in rgramslist for rgram in rgrams] + rgramcounter = Counter(rgramsall) + sgramcounter = Counter(sgrams) + sgramcounter_rep = Counter() + for (sgram, scount) in sgramcounter.items(): + sgramcounter_rep[sgram] = scount * numref + cgramcounter = Counter(cgrams) + cgramcounter_rep = Counter() + for (cgram, ccount) in cgramcounter.items(): + cgramcounter_rep[cgram] = ccount * numref + keepgramcounter_rep = sgramcounter_rep & cgramcounter_rep + keepgramcountergood_rep = keepgramcounter_rep & rgramcounter + keepgramcounterall_rep = sgramcounter_rep & rgramcounter + keeptmpscore1 = 0 + keeptmpscore2 = 0 + for keepgram in keepgramcountergood_rep: + keeptmpscore1 += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram] + keeptmpscore2 += keepgramcountergood_rep[keepgram] + keepscore_precision = 1 + keepscore_recall = 1 + if len(keepgramcounter_rep) > 0: + keepscore_precision = keeptmpscore1 / len(keepgramcounter_rep) + if len(keepgramcounterall_rep) > 0: + keepscore_recall = keeptmpscore2 / sum(keepgramcounterall_rep.values()) + keepscore = 0 + if keepscore_precision > 0 or keepscore_recall > 0: + keepscore = 2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall) + delgramcounter_rep = sgramcounter_rep - cgramcounter_rep + delgramcountergood_rep = delgramcounter_rep - rgramcounter + delgramcounterall_rep = sgramcounter_rep - rgramcounter + deltmpscore1 = 0 + deltmpscore2 = 0 + for delgram in delgramcountergood_rep: + deltmpscore1 += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram] + deltmpscore2 += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram] + delscore_precision = 1 + if len(delgramcounter_rep) > 0: + delscore_precision = deltmpscore1 / len(delgramcounter_rep) + addgramcounter = set(cgramcounter) - set(sgramcounter) + addgramcountergood = set(addgramcounter) & set(rgramcounter) + addgramcounterall = set(rgramcounter) - set(sgramcounter) + addtmpscore = 0 + for addgram in addgramcountergood: + addtmpscore += 1 + addscore_precision = 1 + addscore_recall = 1 + if len(addgramcounter) > 0: + addscore_precision = addtmpscore / len(addgramcounter) + if len(addgramcounterall) > 0: + addscore_recall = addtmpscore / len(addgramcounterall) + addscore = 0 + if addscore_precision > 0 or addscore_recall > 0: + addscore = 2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall) + return (keepscore, delscore_precision, addscore) + +def SARIsent(ssent, csent, rsents): + numref = len(rsents) + s1grams = ssent.split(' ') + c1grams = csent.split(' ') + s2grams = [] + c2grams = [] + s3grams = [] + c3grams = [] + s4grams = [] + c4grams = [] + r1gramslist = [] + r2gramslist = [] + r3gramslist = [] + r4gramslist = [] + for rsent in rsents: + r1grams = rsent.split(' ') + r2grams = [] + r3grams = [] + r4grams = [] + r1gramslist.append(r1grams) + for i in range(0, len(r1grams) - 1): + if i < len(r1grams) - 1: + r2gram = r1grams[i] + ' ' + r1grams[i + 1] + r2grams.append(r2gram) + if i < len(r1grams) - 2: + r3gram = r1grams[i] + ' ' + r1grams[i + 1] + ' ' + r1grams[i + 2] + r3grams.append(r3gram) + if i < len(r1grams) - 3: + r4gram = r1grams[i] + ' ' + r1grams[i + 1] + ' ' + r1grams[i + 2] + ' ' + r1grams[i + 3] + r4grams.append(r4gram) + r2gramslist.append(r2grams) + r3gramslist.append(r3grams) + r4gramslist.append(r4grams) + for i in range(0, len(s1grams) - 1): + if i < len(s1grams) - 1: + s2gram = s1grams[i] + ' ' + s1grams[i + 1] + s2grams.append(s2gram) + if i < len(s1grams) - 2: + s3gram = s1grams[i] + ' ' + s1grams[i + 1] + ' ' + s1grams[i + 2] + s3grams.append(s3gram) + if i < len(s1grams) - 3: + s4gram = s1grams[i] + ' ' + s1grams[i + 1] + ' ' + s1grams[i + 2] + ' ' + s1grams[i + 3] + s4grams.append(s4gram) + for i in range(0, len(c1grams) - 1): + if i < len(c1grams) - 1: + c2gram = c1grams[i] + ' ' + c1grams[i + 1] + c2grams.append(c2gram) + if i < len(c1grams) - 2: + c3gram = c1grams[i] + ' ' + c1grams[i + 1] + ' ' + c1grams[i + 2] + c3grams.append(c3gram) + if i < len(c1grams) - 3: + c4gram = c1grams[i] + ' ' + c1grams[i + 1] + ' ' + c1grams[i + 2] + ' ' + c1grams[i + 3] + c4grams.append(c4gram) + (keep1score, del1score, add1score) = SARIngram(s1grams, c1grams, r1gramslist, numref) + (keep2score, del2score, add2score) = SARIngram(s2grams, c2grams, r2gramslist, numref) + (keep3score, del3score, add3score) = SARIngram(s3grams, c3grams, r3gramslist, numref) + (keep4score, del4score, add4score) = SARIngram(s4grams, c4grams, r4gramslist, numref) + avgkeepscore = sum([keep1score, keep2score, keep3score, keep4score]) / 4 + avgdelscore = sum([del1score, del2score, del3score, del4score]) / 4 + avgaddscore = sum([add1score, add2score, add3score, add4score]) / 4 + finalscore = (avgkeepscore + avgdelscore + avgaddscore) / 3 + return finalscore + +def normalize(sentence, lowercase: bool=True, tokenizer: str='13a', return_str: bool=True): + if lowercase: + sentence = sentence.lower() + if tokenizer in ['13a', 'intl']: + if version.parse(sacrebleu.__version__).major >= 2: + normalized_sent = sacrebleu.metrics.bleu._get_tokenizer(tokenizer)()(sentence) + else: + normalized_sent = sacrebleu.TOKENIZERS[tokenizer]()(sentence) + elif tokenizer == 'moses': + normalized_sent = sacremoses.MosesTokenizer().tokenize(sentence, return_str=True, escape=False) + elif tokenizer == 'penn': + normalized_sent = sacremoses.MosesTokenizer().penn_tokenize(sentence, return_str=True) + else: + normalized_sent = sentence + if not return_str: + normalized_sent = normalized_sent.split() + return normalized_sent + +def compute_sari(sources, predictions, references): + if not len(sources) == len(predictions) == len(references): + raise ValueError('Sources length must match predictions and references lengths.') + sari_score = 0 + for (src, pred, refs) in zip(sources, predictions, references): + sari_score += SARIsent(normalize(src), normalize(pred), [normalize(sent) for sent in refs]) + sari_score = sari_score / len(predictions) + return 100 * sari_score + +def compute_sacrebleu(predictions, references, smooth_method='exp', smooth_value=None, force=False, lowercase=False, use_effective_order=False): + references_per_prediction = len(references[0]) + if any((len(refs) != references_per_prediction for refs in references)): + raise ValueError('Sacrebleu requires the same number of references for each prediction') + transformed_references = [[refs[i] for refs in references] for i in range(references_per_prediction)] + output = sacrebleu.corpus_bleu(predictions, transformed_references, smooth_method=smooth_method, smooth_value=smooth_value, force=force, lowercase=lowercase, use_effective_order=use_effective_order) + return output.score + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class WikiSplit(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=[datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Sequence(datasets.Value('string', id='sequence'), id='references')}), datasets.Features({'predictions': datasets.Value('string', id='sequence'), 'references': datasets.Value('string', id='sequence')})], codebase_urls=['https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py', 'https://github.com/cocoxu/simplification/blob/master/SARI.py', 'https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py', 'https://github.com/mjpost/sacreBLEU'], reference_urls=['https://www.aclweb.org/anthology/Q16-1029.pdf', 'https://github.com/mjpost/sacreBLEU', 'https://en.wikipedia.org/wiki/BLEU', 'https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213']) + + def _compute(self, sources, predictions, references): + if isinstance(references[0], str): + references = [[ref] for ref in references] + result = {} + result.update({'sari': compute_sari(sources=sources, predictions=predictions, references=references)}) + result.update({'sacrebleu': compute_sacrebleu(predictions=predictions, references=references)}) + result.update({'exact': compute_em(predictions=predictions, references=references)}) + return result + +# File: evaluate-main/metrics/xnli/xnli.py +"""""" +import datasets +import evaluate +_CITATION = '@InProceedings{conneau2018xnli,\n author = "Conneau, Alexis\n and Rinott, Ruty\n and Lample, Guillaume\n and Williams, Adina\n and Bowman, Samuel R.\n and Schwenk, Holger\n and Stoyanov, Veselin",\n title = "XNLI: Evaluating Cross-lingual Sentence Representations",\n booktitle = "Proceedings of the 2018 Conference on Empirical Methods\n in Natural Language Processing",\n year = "2018",\n publisher = "Association for Computational Linguistics",\n location = "Brussels, Belgium",\n}\n' +_DESCRIPTION = 'XNLI is a subset of a few thousand examples from MNLI which has been translated\ninto a 14 different languages (some low-ish resource). As with MNLI, the goal is\nto predict textual entailment (does sentence A imply/contradict/neither sentence\nB) and is a classification task (given two sentences, predict one of three\nlabels).\n' +_KWARGS_DESCRIPTION = '\nComputes XNLI score which is just simple accuracy.\nArgs:\n predictions: Predicted labels.\n references: Ground truth labels.\nReturns:\n \'accuracy\': accuracy\nExamples:\n\n >>> predictions = [0, 1]\n >>> references = [0, 1]\n >>> xnli_metric = evaluate.load("xnli")\n >>> results = xnli_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'accuracy\': 1.0}\n' + +def simple_accuracy(preds, labels): + return (preds == labels).mean() + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Xnli(evaluate.Metric): + + def _info(self): + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'), 'references': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32')}), codebase_urls=[], reference_urls=[], format='numpy') + + def _compute(self, predictions, references): + return {'accuracy': simple_accuracy(predictions, references)} + +# File: evaluate-main/metrics/xtreme_s/xtreme_s.py +"""""" +from typing import List +import datasets +from datasets.config import PY_VERSION +from packaging import version +from sklearn.metrics import f1_score +import evaluate +if PY_VERSION < version.parse('3.8'): + import importlib_metadata +else: + import importlib.metadata as importlib_metadata +_CITATION = '' +_DESCRIPTION = ' 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' +_KWARGS_DESCRIPTION = '\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 = evaluate.load(\'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 = evaluate.load(\'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 = evaluate.load(\'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 = evaluate.load(\'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' +_CONFIG_NAMES = ['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14'] +SENTENCE_DELIMITER = '' +try: + from jiwer import transforms as tr + _jiwer_available = True +except ImportError: + _jiwer_available = False +if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'): + + class SentencesToListOfCharacters(tr.AbstractTransform): + + def __init__(self, sentence_delimiter: str=' '): + self.sentence_delimiter = sentence_delimiter + + def process_string(self, s: str): + return list(s) + + def process_list(self, inp: List[str]): + chars = [] + for (sent_idx, sentence) in enumerate(inp): + chars.extend(self.process_string(sentence)) + if self.sentence_delimiter is not None and self.sentence_delimiter != '' and (sent_idx < len(inp) - 1): + chars.append(self.sentence_delimiter) + return chars + cer_transform = tr.Compose([tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]) +elif _jiwer_available: + cer_transform = tr.Compose([tr.RemoveMultipleSpaces(), tr.Strip(), tr.ReduceToSingleSentence(SENTENCE_DELIMITER), tr.ReduceToListOfListOfChars()]) +else: + cer_transform = None + +def simple_accuracy(preds, labels): + return float((preds == labels).mean()) + +def f1_and_simple_accuracy(preds, labels): + return {'f1': float(f1_score(y_true=labels, y_pred=preds, average='macro')), 'accuracy': simple_accuracy(preds, labels)} + +def bleu(preds, labels, smooth_method='exp', smooth_value=None, force=False, lowercase=False, tokenize=None, use_effective_order=False): + labels = [[label] for label in labels] + preds = list(preds) + 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.\nYou can install it with `pip install "sacrebleu>=1.4.12"`.') + references_per_prediction = len(labels[0]) + if any((len(refs) != references_per_prediction for refs in labels)): + raise ValueError('Sacrebleu requires the same number of references for each prediction') + transformed_references = [[refs[i] for refs in labels] for i in range(references_per_prediction)] + output = scb.corpus_bleu(preds, transformed_references, smooth_method=smooth_method, smooth_value=smooth_value, force=force, lowercase=lowercase, use_effective_order=use_effective_order, **dict(tokenize=tokenize) if tokenize else {}) + return {'bleu': output.score} + +def wer_and_cer(preds, labels, concatenate_texts, config_name): + 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: + wer = compute_measures(labels, preds)['wer'] + cer = compute_measures(labels, preds, truth_transform=cer_transform, hypothesis_transform=cer_transform)['wer'] + return {'wer': wer, 'cer': cer} + else: + + def compute_score(preds, labels, score_type='wer'): + incorrect = 0 + total = 0 + for (prediction, reference) in zip(preds, labels): + if score_type == 'wer': + measures = compute_measures(reference, prediction) + elif score_type == 'cer': + measures = compute_measures(reference, prediction, truth_transform=cer_transform, hypothesis_transform=cer_transform) + incorrect += measures['substitutions'] + measures['deletions'] + measures['insertions'] + total += measures['substitutions'] + measures['deletions'] + measures['hits'] + return incorrect / total + return {'wer': compute_score(preds, labels, 'wer'), 'cer': compute_score(preds, labels, 'cer')} + +@evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class XtremeS(evaluate.Metric): + + def _info(self): + if self.config_name not in _CONFIG_NAMES: + raise KeyError(f'You should supply a configuration name selected in {_CONFIG_NAMES}') + pred_type = 'int64' if self.config_name in ['fleurs-lang_id', 'minds14'] else 'string' + return evaluate.MetricInfo(description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features({'predictions': datasets.Value(pred_type), 'references': datasets.Value(pred_type)}), codebase_urls=[], reference_urls=[], format='numpy') + + def _compute(self, predictions, references, bleu_kwargs=None, wer_kwargs=None): + bleu_kwargs = bleu_kwargs if bleu_kwargs is not None else {} + wer_kwargs = wer_kwargs if wer_kwargs is not None else {} + if self.config_name == 'fleurs-lang_id': + return {'accuracy': simple_accuracy(predictions, references)} + elif self.config_name == 'minds14': + return f1_and_simple_accuracy(predictions, references) + elif self.config_name == 'covost2': + smooth_method = bleu_kwargs.pop('smooth_method', 'exp') + smooth_value = bleu_kwargs.pop('smooth_value', None) + force = bleu_kwargs.pop('force', False) + lowercase = bleu_kwargs.pop('lowercase', False) + tokenize = bleu_kwargs.pop('tokenize', None) + use_effective_order = bleu_kwargs.pop('use_effective_order', False) + return bleu(preds=predictions, labels=references, smooth_method=smooth_method, smooth_value=smooth_value, force=force, lowercase=lowercase, tokenize=tokenize, use_effective_order=use_effective_order) + elif self.config_name in ['fleurs-asr', 'mls', 'voxpopuli', 'babel']: + concatenate_texts = wer_kwargs.pop('concatenate_texts', False) + return wer_and_cer(predictions, references, concatenate_texts, self.config_name) + else: + raise KeyError(f'You should supply a configuration name selected in {_CONFIG_NAMES}') + +# File: evaluate-main/src/evaluate/__init__.py +__version__ = '0.4.4.dev0' +from packaging import version +SCRIPTS_VERSION = 'main' if version.parse(__version__).is_devrelease else __version__ +del version +from .evaluation_suite import EvaluationSuite +from .evaluator import AudioClassificationEvaluator, AutomaticSpeechRecognitionEvaluator, Evaluator, ImageClassificationEvaluator, QuestionAnsweringEvaluator, SummarizationEvaluator, Text2TextGenerationEvaluator, TextClassificationEvaluator, TextGenerationEvaluator, TokenClassificationEvaluator, TranslationEvaluator, evaluator +from .hub import push_to_hub +from .info import ComparisonInfo, EvaluationModuleInfo, MeasurementInfo, MetricInfo +from .inspect import inspect_evaluation_module, list_evaluation_modules +from .loading import load +from .module import CombinedEvaluations, Comparison, EvaluationModule, Measurement, Metric, combine +from .saving import save +from .utils import * +from .utils import gradio, logging + +# File: evaluate-main/src/evaluate/commands/evaluate_cli.py +import argparse +import os +import subprocess +from pathlib import Path +from cookiecutter.main import cookiecutter +from huggingface_hub import HfApi, Repository, create_repo +from evaluate.utils.logging import get_logger +logger = get_logger(__name__) +INSTRUCTIONS = 'A new repository for your module "{module_name}" of type "{module_type}" has been created at {output_dir} and pushed to the Hugging Face Hub: {repo_url}.\n\nHere are the next steps:\n- implement the module logic in {module_slug}/{module_slug}.py\n- document your module in {module_slug}/README.md\n- add test cases for your module in {module_slug}/tests.py\n- if your module has any dependencies update them in {module_slug}/requirements.txt\n\nYou can test your module\'s widget locally by running:\n\n```\npython {output_dir}/{module_slug}/app.py\n```\n\nWhen you are happy with your changes you can push your changes with the following commands to the Hugging Face Hub:\n\n```\ncd {output_dir}/{module_slug}\ngit add .\ngit commit -m "Updating module"\ngit push\n```\n\nYou should then see the update widget on the Hugging Face Hub: {repo_url}\nAnd you can load your module in Python with the following code:\n\n```\nfrom evaluate import load\nmodule = load("{namespace}/{module_slug}")\n```\n' + +def main(): + parser = argparse.ArgumentParser('HuggingFace Evaluate CLI tool', usage='evaluate-cli []') + subparsers = parser.add_subparsers() + parser_create = subparsers.add_parser('create', help='Create new evaluation module.') + parser_create.add_argument('module_name', type=str, help='Pretty name of new evaluation module, e.g. "Recall" or "Exact Match".') + parser_create.add_argument('--module_type', default='metric', type=str, help='Type of module, has to be one of [metric|comparison|measurement].') + parser_create.add_argument('--dataset_name', default='', type=str, help='Name of dataset if evaluation module is dataset specific.') + parser_create.add_argument('--module_description', type=str, help='Short description of evaluation module.') + parser_create.add_argument('--output_dir', default=Path.cwd(), type=str, help='Path to output directory.') + parser_create.add_argument('--organization', default=None, type=str, help='Organization on the Hub to push evaluation module to.') + parser_create.add_argument('--private', action='store_true', help='Sets evaluation module repository to private.') + args = vars(parser.parse_args()) + if args['module_type'] not in ['metric', 'comparison', 'measurement']: + raise ValueError('The module_type needs to be one of metric, comparison, or measurement') + if '-' in args['module_name']: + raise ValueError("Hyphens ('-') are not allowed in module names.") + output_dir = Path(args['output_dir']) + organization = args['organization'] + module_slug = args['module_name'].lower().replace(' ', '_') + if organization is None: + hfapi = HfApi() + namespace = hfapi.whoami()['name'] + else: + namespace = organization + args['namespace'] = namespace + repo_url = f'https://huggingface.co/spaces/{namespace}/{module_slug}' + try: + create_repo(namespace + '/' + module_slug, repo_type='space', space_sdk='gradio', private=args['private']) + except Exception as exception: + logger.error(f'Could not create Space for module at hf.co/spaces/{namespace}/{module_slug}. Make sure this space does not exist already.') + raise exception + subprocess.run(f'git clone {repo_url}'.split(), stderr=subprocess.PIPE, stdout=subprocess.PIPE, check=True, encoding='utf-8', cwd=output_dir, env=os.environ.copy()) + repo = Repository(local_dir=output_dir / module_slug) + cookiecutter('https://github.com/huggingface/evaluate/', directory='templates', no_input=True, extra_context=args, output_dir=output_dir, overwrite_if_exists=True) + repo.git_add() + repo.git_commit('add module default template') + repo.git_push() + print(INSTRUCTIONS.format(module_name=args['module_name'], module_type=args['module_type'], module_slug=module_slug, namespace=namespace, repo_url=repo_url, output_dir=output_dir)) +if __name__ == '__main__': + main() + +# File: evaluate-main/src/evaluate/config.py +import importlib +import os +import platform +from pathlib import Path +from packaging import version +from .utils.logging import get_logger +logger = get_logger(__name__) +S3_METRICS_BUCKET_PREFIX = 'https://s3.amazonaws.com/datasets.huggingface.co/datasets/metrics' +CLOUDFRONT_METRICS_DISTRIB_PREFIX = 'https://cdn-datasets.huggingface.co/datasets/metric' +REPO_METRICS_URL = 'https://raw.githubusercontent.com/huggingface/evaluate/{revision}/metrics/{path}/{name}' +REPO_MEASUREMENTS_URL = 'https://raw.githubusercontent.com/huggingface/evaluate/{revision}/measurements/{path}/{name}' +REPO_COMPARISONS_URL = 'https://raw.githubusercontent.com/huggingface/evaluate/{revision}/comparisons/{path}/{name}' +EVALUATION_MODULE_TYPES = ['metric', 'comparison', 'measurement'] +HF_ENDPOINT = os.environ.get('HF_ENDPOINT', 'https://huggingface.co') +HF_LIST_ENDPOINT = HF_ENDPOINT + '/api/spaces?filter={type}' +HUB_EVALUATE_URL = HF_ENDPOINT + '/spaces/{path}/resolve/{revision}/{name}' +HUB_DEFAULT_VERSION = 'main' +PY_VERSION = version.parse(platform.python_version()) +if PY_VERSION < version.parse('3.8'): + import importlib_metadata +else: + import importlib.metadata as importlib_metadata +ENV_VARS_TRUE_VALUES = {'1', 'ON', 'YES', 'TRUE'} +ENV_VARS_TRUE_AND_AUTO_VALUES = ENV_VARS_TRUE_VALUES.union({'AUTO'}) +PANDAS_VERSION = version.parse(importlib_metadata.version('pandas')) +PYARROW_VERSION = version.parse(importlib_metadata.version('pyarrow')) +USE_TF = os.environ.get('USE_TF', 'AUTO').upper() +USE_TORCH = os.environ.get('USE_TORCH', 'AUTO').upper() +USE_JAX = os.environ.get('USE_JAX', 'AUTO').upper() +TORCH_VERSION = 'N/A' +TORCH_AVAILABLE = False +if USE_TORCH in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TF not in ENV_VARS_TRUE_VALUES: + TORCH_AVAILABLE = importlib.util.find_spec('torch') is not None + if TORCH_AVAILABLE: + try: + TORCH_VERSION = version.parse(importlib_metadata.version('torch')) + logger.info(f'PyTorch version {TORCH_VERSION} available.') + except importlib_metadata.PackageNotFoundError: + pass +else: + logger.info('Disabling PyTorch because USE_TF is set') +TF_VERSION = 'N/A' +TF_AVAILABLE = False +if USE_TF in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TORCH not in ENV_VARS_TRUE_VALUES: + TF_AVAILABLE = importlib.util.find_spec('tensorflow') is not None + if TF_AVAILABLE: + for package in ['tensorflow', 'tensorflow-cpu', 'tensorflow-gpu', 'tf-nightly', 'tf-nightly-cpu', 'tf-nightly-gpu', 'intel-tensorflow', 'tensorflow-rocm', 'tensorflow-macos']: + try: + TF_VERSION = version.parse(importlib_metadata.version(package)) + except importlib_metadata.PackageNotFoundError: + continue + else: + break + else: + TF_AVAILABLE = False + if TF_AVAILABLE: + if TF_VERSION.major < 2: + logger.info(f'TensorFlow found but with version {TF_VERSION}. `datasets` requires version 2 minimum.') + TF_AVAILABLE = False + else: + logger.info(f'TensorFlow version {TF_VERSION} available.') +else: + logger.info('Disabling Tensorflow because USE_TORCH is set') +JAX_VERSION = 'N/A' +JAX_AVAILABLE = False +if USE_JAX in ENV_VARS_TRUE_AND_AUTO_VALUES: + JAX_AVAILABLE = importlib.util.find_spec('jax') is not None + if JAX_AVAILABLE: + try: + JAX_VERSION = version.parse(importlib_metadata.version('jax')) + logger.info(f'JAX version {JAX_VERSION} available.') + except importlib_metadata.PackageNotFoundError: + pass +else: + logger.info('Disabling JAX because USE_JAX is set to False') +DEFAULT_XDG_CACHE_HOME = '~/.cache' +XDG_CACHE_HOME = os.getenv('XDG_CACHE_HOME', DEFAULT_XDG_CACHE_HOME) +DEFAULT_HF_CACHE_HOME = os.path.join(XDG_CACHE_HOME, 'huggingface') +HF_CACHE_HOME = os.path.expanduser(os.getenv('HF_HOME', DEFAULT_HF_CACHE_HOME)) +DEFAULT_HF_EVALUATE_CACHE = os.path.join(HF_CACHE_HOME, 'evaluate') +HF_EVALUATE_CACHE = Path(os.getenv('HF_EVALUATE_CACHE', DEFAULT_HF_EVALUATE_CACHE)) +DEFAULT_HF_METRICS_CACHE = os.path.join(HF_CACHE_HOME, 'metrics') +HF_METRICS_CACHE = Path(os.getenv('HF_METRICS_CACHE', DEFAULT_HF_METRICS_CACHE)) +DEFAULT_HF_MODULES_CACHE = os.path.join(HF_CACHE_HOME, 'modules') +HF_MODULES_CACHE = Path(os.getenv('HF_MODULES_CACHE', DEFAULT_HF_MODULES_CACHE)) +DOWNLOADED_DATASETS_DIR = 'downloads' +DEFAULT_DOWNLOADED_EVALUATE_PATH = os.path.join(HF_EVALUATE_CACHE, DOWNLOADED_DATASETS_DIR) +DOWNLOADED_EVALUATE_PATH = Path(os.getenv('HF_DATASETS_DOWNLOADED_EVALUATE_PATH', DEFAULT_DOWNLOADED_EVALUATE_PATH)) +EXTRACTED_EVALUATE_DIR = 'extracted' +DEFAULT_EXTRACTED_EVALUATE_PATH = os.path.join(DEFAULT_DOWNLOADED_EVALUATE_PATH, EXTRACTED_EVALUATE_DIR) +EXTRACTED_EVALUATE_PATH = Path(os.getenv('HF_DATASETS_EXTRACTED_EVALUATE_PATH', DEFAULT_EXTRACTED_EVALUATE_PATH)) +HF_UPDATE_DOWNLOAD_COUNTS = os.environ.get('HF_UPDATE_DOWNLOAD_COUNTS', 'AUTO').upper() in ENV_VARS_TRUE_AND_AUTO_VALUES +HF_EVALUATE_OFFLINE = os.environ.get('HF_EVALUATE_OFFLINE', 'AUTO').upper() in ENV_VARS_TRUE_VALUES +LICENSE_FILENAME = 'LICENSE' +METRIC_INFO_FILENAME = 'metric_info.json' +DATASETDICT_JSON_FILENAME = 'dataset_dict.json' +MODULE_NAME_FOR_DYNAMIC_MODULES = 'evaluate_modules' +HF_HUB_ALLOWED_TASKS = ['image-classification', 'translation', 'image-segmentation', 'fill-mask', 'automatic-speech-recognition', 'token-classification', 'sentence-similarity', 'audio-classification', 'question-answering', 'summarization', 'zero-shot-classification', 'table-to-text', 'feature-extraction', 'other', 'multiple-choice', 'text-classification', 'text-to-image', 'text2text-generation', 'zero-shot-image-classification', 'tabular-classification', 'tabular-regression', 'image-to-image', 'tabular-to-text', 'unconditional-image-generation', 'text-retrieval', 'text-to-speech', 'object-detection', 'audio-to-audio', 'text-generation', 'conversational', 'table-question-answering', 'visual-question-answering', 'image-to-text', 'reinforcement-learning', 'voice-activity-detection', 'time-series-forecasting', 'document-question-answering'] + +# File: evaluate-main/src/evaluate/evaluation_suite/__init__.py +import importlib +import inspect +from dataclasses import dataclass +from pathlib import Path +from typing import Callable, Dict, Optional, Union +from datasets import Dataset, DownloadConfig, DownloadMode, load_dataset +from datasets.utils.version import Version +from ..evaluator import evaluator +from ..loading import evaluation_module_factory +from ..utils.logging import get_logger +logger = get_logger(__name__) + +@dataclass +class SubTask: + task_type: str + data: Optional[Union[str, Dataset]] = None + subset: Optional[str] = None + split: Optional[str] = None + data_preprocessor: Optional[Callable] = None + args_for_task: Optional[dict] = None + + def __post_init__(self): + if type(self.task_type) is not str: + raise ValueError(f"'task_type' must be type 'str', got {type(self.task_type)}") + if type(self.data) not in [Dataset, str]: + raise ValueError(f"'data' must be an already-instantiated Dataset object or type 'str', got {type(self.data)}") + if self.subset and type(self.subset) is not str: + raise ValueError(f"'subset' must be type 'str', got {type(self.subset)}") + if self.split and type(self.split) is not str: + raise ValueError(f"'split' must be type 'str', got {type(self.split)}") + if self.data_preprocessor and (not callable(self.data_preprocessor)): + raise ValueError(f"'data_preprocessor' must be a Callable', got {self.data_preprocessor}") + if self.args_for_task and type(self.args_for_task) is not dict: + raise ValueError(f"'args_for_task' must be type 'dict', got {type(self.args_for_task)}") + +def import_main_class(module_path): + module = importlib.import_module(module_path) + module_main_cls = None + for (name, obj) in module.__dict__.items(): + if isinstance(obj, type) and obj.__name__ == 'Suite': + if inspect.isabstract(obj): + continue + module_main_cls = obj + break + return module_main_cls + +class EvaluationSuite: + + def __init__(self, name): + self.name = name + + @staticmethod + def load(path: str, download_mode: Optional[DownloadMode]=None, revision: Optional[Union[str, Version]]=None, download_config: Optional[DownloadConfig]=None): + download_mode = DownloadMode(download_mode or DownloadMode.REUSE_DATASET_IF_EXISTS) + evaluation_module = evaluation_module_factory(path, module_type=None, revision=revision, download_config=download_config, download_mode=download_mode) + name = Path(path).stem + evaluation_cls = import_main_class(evaluation_module.module_path) + evaluation_instance = evaluation_cls(name) + return evaluation_instance + + def __repr__(self): + self.tasks = [str(task) for task in self.suite] + return f'EvaluationSuite name: "{self.name}", Tasks: {self.tasks})' + + def assert_suite_nonempty(self): + if not self.suite: + raise ValueError('No evaluation tasks found. The EvaluationSuite must include at least one SubTask definition.') + + def run(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']) -> Dict[str, float]: + self.assert_suite_nonempty() + results_all = [] + for task in self.suite: + task_name = task.data + if task.data_preprocessor: + ds = load_dataset(task.data, name=task.subset, split=task.split) + task.data = ds.map(task.data_preprocessor) + task_evaluator = evaluator(task.task_type) + args_for_task = task.args_for_task + args_for_task['model_or_pipeline'] = model_or_pipeline + args_for_task['data'] = task.data + args_for_task['subset'] = task.subset + args_for_task['split'] = task.split + results = task_evaluator.compute(**args_for_task) + results['task_name'] = task_name + '/' + task.subset if task.subset else task_name + results['data_preprocessor'] = str(task.data_preprocessor) if task.data_preprocessor is not None else None + results_all.append(results) + return results_all + +# File: evaluate-main/src/evaluate/evaluator/__init__.py +try: + from transformers.pipelines import SUPPORTED_TASKS as SUPPORTED_PIPELINE_TASKS + from transformers.pipelines import TASK_ALIASES + from transformers.pipelines import check_task as check_pipeline_task + TRANSFORMERS_AVAILABLE = True +except ImportError: + TRANSFORMERS_AVAILABLE = False +from typing import Dict, List +from .audio_classification import AudioClassificationEvaluator +from .automatic_speech_recognition import AutomaticSpeechRecognitionEvaluator +from .base import Evaluator +from .image_classification import ImageClassificationEvaluator +from .question_answering import QuestionAnsweringEvaluator +from .text2text_generation import SummarizationEvaluator, Text2TextGenerationEvaluator, TranslationEvaluator +from .text_classification import TextClassificationEvaluator +from .text_generation import TextGenerationEvaluator +from .token_classification import TokenClassificationEvaluator +SUPPORTED_EVALUATOR_TASKS = {'text-classification': {'implementation': TextClassificationEvaluator, 'default_metric_name': 'accuracy'}, 'image-classification': {'implementation': ImageClassificationEvaluator, 'default_metric_name': 'accuracy'}, 'question-answering': {'implementation': QuestionAnsweringEvaluator, 'default_metric_name': 'squad'}, 'token-classification': {'implementation': TokenClassificationEvaluator, 'default_metric_name': 'seqeval'}, 'text-generation': {'implementation': TextGenerationEvaluator, 'default_metric_name': 'word_count'}, 'text2text-generation': {'implementation': Text2TextGenerationEvaluator, 'default_metric_name': 'bleu'}, 'summarization': {'implementation': SummarizationEvaluator, 'default_metric_name': 'rouge'}, 'translation': {'implementation': TranslationEvaluator, 'default_metric_name': 'bleu'}, 'automatic-speech-recognition': {'implementation': AutomaticSpeechRecognitionEvaluator, 'default_metric_name': 'wer'}, 'audio-classification': {'implementation': AudioClassificationEvaluator, 'default_metric_name': 'accuracy'}} + +def get_supported_tasks() -> List[str]: + return list(SUPPORTED_EVALUATOR_TASKS.keys()) + +def check_task(task: str) -> Dict: + if task in TASK_ALIASES: + task = TASK_ALIASES[task] + if not check_pipeline_task(task): + raise KeyError(f'Unknown task {task}, available tasks are: {get_supported_tasks()}.') + if task in SUPPORTED_EVALUATOR_TASKS.keys() and task in SUPPORTED_PIPELINE_TASKS.keys(): + return SUPPORTED_EVALUATOR_TASKS[task] + raise KeyError(f'Unknown task {task}, available tasks are: {get_supported_tasks()}.') + +def evaluator(task: str=None) -> Evaluator: + if not TRANSFORMERS_AVAILABLE: + raise ImportError('If you want to use the `Evaluator` you need `transformers`. Run `pip install evaluate[transformers]`.') + targeted_task = check_task(task) + evaluator_class = targeted_task['implementation'] + default_metric_name = targeted_task['default_metric_name'] + return evaluator_class(task=task, default_metric_name=default_metric_name) + +# File: evaluate-main/src/evaluate/evaluator/audio_classification.py +from numbers import Number +from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple, Union +from datasets import Dataset +from typing_extensions import Literal +from ..module import EvaluationModule +from ..utils.file_utils import add_end_docstrings, add_start_docstrings +from .base import EVALUATOR_COMPUTE_RETURN_DOCSTRING, EVALUTOR_COMPUTE_START_DOCSTRING, Evaluator +if TYPE_CHECKING: + from transformers import FeatureExtractionMixin, Pipeline, PreTrainedModel, PreTrainedTokenizer, TFPreTrainedModel +TASK_DOCUMENTATION = '\n Examples:\n\n \n\n Remember that, in order to process audio files, you need ffmpeg installed (https://ffmpeg.org/download.html)\n\n \n\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n\n >>> task_evaluator = evaluator("audio-classification")\n >>> data = load_dataset("superb", \'ks\', split="test[:40]")\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline=""superb/wav2vec2-base-superb-ks"",\n >>> data=data,\n >>> label_column="label",\n >>> input_column="file",\n >>> metric="accuracy",\n >>> label_mapping={0: "yes", 1: "no", 2: "up", 3: "down"}\n >>> )\n ```\n\n \n\n The evaluator supports raw audio data as well, in the form of a numpy array. However, be aware that calling\n the audio column automatically decodes and resamples the audio files, which can be slow for large datasets.\n\n \n\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n\n >>> task_evaluator = evaluator("audio-classification")\n >>> data = load_dataset("superb", \'ks\', split="test[:40]")\n >>> data = data.map(lambda example: {"audio": example["audio"]["array"]})\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline=""superb/wav2vec2-base-superb-ks"",\n >>> data=data,\n >>> label_column="label",\n >>> input_column="audio",\n >>> metric="accuracy",\n >>> label_mapping={0: "yes", 1: "no", 2: "up", 3: "down"}\n >>> )\n ```\n' + +class AudioClassificationEvaluator(Evaluator): + PIPELINE_KWARGS = {} + + def __init__(self, task='audio-classification', default_metric_name=None): + super().__init__(task, default_metric_name=default_metric_name) + + def predictions_processor(self, predictions, label_mapping): + pred_label = [max(pred, key=lambda x: x['score'])['label'] for pred in predictions] + pred_label = [label_mapping[pred] if label_mapping is not None else pred for pred in pred_label] + return {'predictions': pred_label} + + @add_start_docstrings(EVALUTOR_COMPUTE_START_DOCSTRING) + @add_end_docstrings(EVALUATOR_COMPUTE_RETURN_DOCSTRING, TASK_DOCUMENTATION) + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: Optional[str]=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, feature_extractor: Optional[Union[str, 'FeatureExtractionMixin']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: int=None, random_state: Optional[int]=None, input_column: str='file', label_column: str='label', label_mapping: Optional[Dict[str, Number]]=None) -> Tuple[Dict[str, float], Any]: + result = super().compute(model_or_pipeline=model_or_pipeline, data=data, subset=subset, split=split, metric=metric, tokenizer=tokenizer, feature_extractor=feature_extractor, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, device=device, random_state=random_state, input_column=input_column, label_column=label_column, label_mapping=label_mapping) + return result + +# File: evaluate-main/src/evaluate/evaluator/automatic_speech_recognition.py +from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple, Union +from datasets import Dataset +from typing_extensions import Literal +from ..module import EvaluationModule +from ..utils.file_utils import add_end_docstrings, add_start_docstrings +from .base import EVALUATOR_COMPUTE_RETURN_DOCSTRING, EVALUTOR_COMPUTE_START_DOCSTRING, Evaluator +if TYPE_CHECKING: + from transformers import Pipeline, PreTrainedModel, PreTrainedTokenizer, TFPreTrainedModel +TASK_DOCUMENTATION = '\n Examples:\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n >>> task_evaluator = evaluator("automatic-speech-recognition")\n >>> data = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="validation[:40]")\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline="https://huggingface.co/openai/whisper-tiny.en",\n >>> data=data,\n >>> input_column="path",\n >>> label_column="sentence",\n >>> metric="wer",\n >>> )\n ```\n' + +class AutomaticSpeechRecognitionEvaluator(Evaluator): + PIPELINE_KWARGS = {'truncation': True} + + def __init__(self, task='automatic-speech-recognition', default_metric_name=None): + super().__init__(task, default_metric_name=default_metric_name) + + def predictions_processor(self, predictions, label_mapping): + return {'predictions': [pred['text'] for pred in predictions]} + + @add_start_docstrings(EVALUTOR_COMPUTE_START_DOCSTRING) + @add_end_docstrings(EVALUATOR_COMPUTE_RETURN_DOCSTRING, TASK_DOCUMENTATION) + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: Optional[str]=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: int=None, random_state: Optional[int]=None, input_column: str='path', label_column: str='sentence', generation_kwargs: dict=None) -> Tuple[Dict[str, float], Any]: + if generation_kwargs is not None: + self.PIPELINE_KWARGS.update(generation_kwargs) + result = super().compute(model_or_pipeline=model_or_pipeline, data=data, subset=subset, split=split, metric=metric, tokenizer=tokenizer, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, device=device, random_state=random_state, input_column=input_column, label_column=label_column) + return result + +# File: evaluate-main/src/evaluate/evaluator/base.py +from abc import ABC, abstractmethod +from numbers import Number +from typing import Any, Callable, Dict, List, Optional, Union +from datasets import Dataset, load_dataset +from evaluate.evaluator.utils import choose_split +try: + from scipy.stats import bootstrap + SCIPY_AVAILABLE = True +except ImportError: + SCIPY_AVAILABLE = False +try: + import transformers + from transformers import Pipeline, pipeline + TRANSFORMERS_AVAILABLE = True +except ImportError: + TRANSFORMERS_AVAILABLE = False +from time import perf_counter +from typing_extensions import Literal +from ..loading import load +from ..module import EvaluationModule +from ..utils.logging import get_logger +from .utils import DatasetColumn +logger = get_logger(__name__) +EVALUTOR_COMPUTE_START_DOCSTRING = '\n Compute the metric for a given pipeline and dataset combination.\n Args:\n model_or_pipeline (`str` or `Pipeline` or `Callable` or `PreTrainedModel` or `TFPreTrainedModel`, defaults to `None`):\n If the argument in not specified, we initialize the default pipeline for the task (in this case\n `text-classification` or its alias - `sentiment-analysis`). If the argument is of the type `str` or\n is a model instance, we use it to initialize a new `Pipeline` with the given model. Otherwise we assume the\n argument specifies a pre-initialized pipeline.\n data (`str` or `Dataset`, defaults to `None`):\n Specifies the dataset we will run evaluation on. If it is of type `str`, we treat it as the dataset\n name, and load it. Otherwise we assume it represents a pre-loaded dataset.\n subset (`str`, defaults to `None`):\n Defines which dataset subset to load. If `None` is passed the default subset is loaded.\n split (`str`, defaults to `None`):\n Defines which dataset split to load. If `None` is passed, infers based on the `choose_split` function.\n metric (`str` or `EvaluationModule`, defaults to `None`):\n Specifies the metric we use in evaluator. If it is of type `str`, we treat it as the metric name, and\n load it. Otherwise we assume it represents a pre-loaded metric.\n tokenizer (`str` or `PreTrainedTokenizer`, *optional*, defaults to `None`):\n Argument can be used to overwrite a default tokenizer if `model_or_pipeline` represents a model for\n which we build a pipeline. If `model_or_pipeline` is `None` or a pre-initialized pipeline, we ignore\n this argument.\n strategy (`Literal["simple", "bootstrap"]`, defaults to "simple"):\n specifies the evaluation strategy. Possible values are:\n - `"simple"` - we evaluate the metric and return the scores.\n - `"bootstrap"` - on top of computing the metric scores, we calculate the confidence interval for each\n of the returned metric keys, using `scipy`\'s `bootstrap` method\n https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html.\n confidence_level (`float`, defaults to `0.95`):\n The `confidence_level` value passed to `bootstrap` if `"bootstrap"` strategy is chosen.\n n_resamples (`int`, defaults to `9999`):\n The `n_resamples` value passed to `bootstrap` if `"bootstrap"` strategy is chosen.\n device (`int`, defaults to `None`):\n Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive\n integer will run the model on the associated CUDA device ID. If `None` is provided it will be inferred and\n CUDA:0 used if available, CPU otherwise.\n random_state (`int`, *optional*, defaults to `None`):\n The `random_state` value passed to `bootstrap` if `"bootstrap"` strategy is chosen. Useful for\n debugging.\n' +EVALUATOR_COMPUTE_RETURN_DOCSTRING = '\n Return:\n A `Dict`. The keys represent metric keys calculated for the `metric` spefied in function arguments. For the\n `"simple"` strategy, the value is the metric score. For the `"bootstrap"` strategy, the value is a `Dict`\n containing the score, the confidence interval and the standard error calculated for each metric key.\n' + +class Evaluator(ABC): + PIPELINE_KWARGS = {} + METRIC_KWARGS = {} + + def __init__(self, task: str, default_metric_name: str=None): + if not TRANSFORMERS_AVAILABLE: + raise ImportError('If you want to use the `Evaluator` you need `transformers`. Run `pip install evaluate[evaluator]`.') + if not SCIPY_AVAILABLE: + raise ImportError('If you want to use the `Evaluator` you need `scipy>=1.7.1`. Run `pip install evaluate[evaluator]`.') + self.task = task + self.default_metric_name = default_metric_name + + @staticmethod + def _compute_confidence_interval(metric, metric_inputs, metric_keys: List[str], confidence_level: float=0.95, n_resamples: int=9999, random_state: Optional[int]=None) -> Dict[str, Any]: + + def build_args_metric(metric, key, **kwargs): + + def args_metric(*args): + return metric.compute(**{k: v for (k, v) in zip(kwargs.keys(), args)})[key] + return args_metric + bootstrap_dict = {} + for key in metric_keys: + bs = bootstrap(data=list(metric_inputs.values()), statistic=build_args_metric(metric, key, **metric_inputs), paired=True, vectorized=False, confidence_level=confidence_level, n_resamples=n_resamples, random_state=random_state) + bootstrap_dict[key] = {'confidence_interval': (bs.confidence_interval.low, bs.confidence_interval.high), 'standard_error': bs.standard_error} + return bootstrap_dict + + @staticmethod + def _compute_time_perf(start_time: float, end_time: float, num_samples: int) -> Dict[str, Any]: + latency = end_time - start_time + throughput = num_samples / latency + latency_sample = 1.0 / throughput + return {'total_time_in_seconds': latency, 'samples_per_second': throughput, 'latency_in_seconds': latency_sample} + + @staticmethod + def _infer_device() -> int: + try: + import torch + if torch.cuda.is_available(): + device = 0 + else: + device = -1 + except ImportError: + try: + import tensorflow as tf + if len(tf.config.list_physical_devices('GPU')) > 0: + device = 0 + else: + device = -1 + except ImportError: + device = -1 + if device == -1: + logger.info('No GPU found. The default device for pipeline inference is set to CPU.') + else: + logger.info('GPU found. The default device for pipeline inference is set to GPU (CUDA:0).') + return device + + @abstractmethod + def predictions_processor(self, *args, **kwargs): + raise NotImplementedError() + + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: Optional[str]=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, feature_extractor: Optional[Union[str, 'FeatureExtractionMixin']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: int=None, random_state: Optional[int]=None, input_column: str='text', label_column: str='label', label_mapping: Optional[Dict[str, Number]]=None) -> Dict[str, float]: + result = {} + self.check_for_mismatch_in_device_setup(device, model_or_pipeline) + data = self.load_data(data=data, subset=subset, split=split) + (metric_inputs, pipe_inputs) = self.prepare_data(data=data, input_column=input_column, label_column=label_column) + pipe = self.prepare_pipeline(model_or_pipeline=model_or_pipeline, tokenizer=tokenizer, feature_extractor=feature_extractor, device=device) + metric = self.prepare_metric(metric) + (predictions, perf_results) = self.call_pipeline(pipe, pipe_inputs) + predictions = self.predictions_processor(predictions, label_mapping) + metric_inputs.update(predictions) + metric_results = self.compute_metric(metric=metric, metric_inputs=metric_inputs, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, random_state=random_state) + if type(metric_results) is float: + metric_results = {metric.name: metric_results} + result.update(metric_results) + result.update(perf_results) + return result + + @staticmethod + def check_for_mismatch_in_device_setup(device, model_or_pipeline): + if device is not None and device != -1 and isinstance(model_or_pipeline, Pipeline): + if model_or_pipeline.device.type == 'cpu': + raise ValueError('The value of the `device` kwarg passed to `compute` suggests that this pipe should be run on an accelerator, but the pipe was instantiated on CPU. Pass `device` to the pipeline during initialization to use an accelerator, or pass `device=None` to `compute`. ') + elif device != model_or_pipeline.device.index: + raise ValueError(f'This pipeline was instantiated on device {model_or_pipeline.device.index} but device={device} was passed to `compute`.') + + def check_required_columns(self, data: Union[str, Dataset], columns_names: Dict[str, str]): + for (input_name, column_name) in columns_names.items(): + if column_name not in data.column_names: + raise ValueError(f'Invalid `{input_name}` {column_name} specified. The dataset contains the following columns: {data.column_names}.') + + @staticmethod + def get_dataset_split(data, subset=None, split=None): + if split is None: + split = choose_split(data, subset) + logger.warning(f'Dataset split not defined! Automatically evaluating with split: {split.upper()}') + return split + + def load_data(self, data: Union[str, Dataset], subset: str=None, split: str=None): + if isinstance(data, str): + split = self.get_dataset_split(data, subset, split) + data = load_dataset(data, name=subset, split=split) + return data + elif isinstance(data, Dataset): + if split is not None or subset is not None: + logger.warning('`data` is a preloaded Dataset! Ignoring `subset` and `split`.') + return data + else: + raise ValueError('Please specify a valid `data` object - either a `str` with a name or a `Dataset` object.') + + def prepare_data(self, data: Dataset, input_column: str, label_column: str, *args, **kwargs): + self.check_required_columns(data, {'input_column': input_column, 'label_column': label_column}) + return ({'references': data[label_column]}, DatasetColumn(data, input_column)) + + def prepare_pipeline(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel'], tokenizer: Union['PreTrainedTokenizerBase', 'FeatureExtractionMixin']=None, feature_extractor: Union['PreTrainedTokenizerBase', 'FeatureExtractionMixin']=None, device: int=None): + if device is None: + device = self._infer_device() + if isinstance(model_or_pipeline, str) or isinstance(model_or_pipeline, transformers.PreTrainedModel) or isinstance(model_or_pipeline, transformers.TFPreTrainedModel): + pipe = pipeline(self.task, model=model_or_pipeline, tokenizer=tokenizer, feature_extractor=feature_extractor, device=device) + else: + if model_or_pipeline is None: + pipe = pipeline(self.task, device=device) + else: + pipe = model_or_pipeline + if tokenizer is not None and feature_extractor is not None: + logger.warning('Ignoring the value of the preprocessor argument (`tokenizer` or `feature_extractor`).') + if pipe.task != self.task and (not (self.task == 'translation' and pipe.task.startswith('translation'))): + raise ValueError(f'Incompatible `model_or_pipeline`. Please specify `model_or_pipeline` compatible with the `{self.task}` task.') + return pipe + + def prepare_metric(self, metric: Union[str, EvaluationModule]): + if metric is None: + if self.default_metric_name is None: + raise ValueError("`Evaluator` doesn't specify a default metric. Please specify a valid `metric` argument.") + metric = load(self.default_metric_name) + elif isinstance(metric, str): + metric = load(metric) + return metric + + def call_pipeline(self, pipe, *args, **kwargs): + start_time = perf_counter() + pipe_output = pipe(*args, **kwargs, **self.PIPELINE_KWARGS) + end_time = perf_counter() + return (pipe_output, self._compute_time_perf(start_time, end_time, len(pipe_output))) + + def compute_metric(self, metric: EvaluationModule, metric_inputs: Dict, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, random_state: Optional[int]=None): + result = metric.compute(**metric_inputs, **self.METRIC_KWARGS) + if strategy == 'bootstrap': + metric_keys = result.keys() + bootstrap_dict = self._compute_confidence_interval(metric, metric_inputs, metric_keys, confidence_level, n_resamples, random_state) + for key in metric_keys: + bootstrap_dict[key]['score'] = result[key] + return bootstrap_dict + return result + +# File: evaluate-main/src/evaluate/evaluator/image_classification.py +from numbers import Number +from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple, Union +from datasets import Dataset +from typing_extensions import Literal +from ..module import EvaluationModule +from ..utils.file_utils import add_end_docstrings, add_start_docstrings +from .base import EVALUATOR_COMPUTE_RETURN_DOCSTRING, EVALUTOR_COMPUTE_START_DOCSTRING, Evaluator +if TYPE_CHECKING: + from transformers import FeatureExtractionMixin, Pipeline, PreTrainedModel, PreTrainedTokenizer, TFPreTrainedModel +TASK_DOCUMENTATION = '\n Examples:\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n >>> task_evaluator = evaluator("image-classification")\n >>> data = load_dataset("beans", split="test[:40]")\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline="nateraw/vit-base-beans",\n >>> data=data,\n >>> label_column="labels",\n >>> metric="accuracy",\n >>> label_mapping={\'angular_leaf_spot\': 0, \'bean_rust\': 1, \'healthy\': 2},\n >>> strategy="bootstrap"\n >>> )\n ```\n' + +class ImageClassificationEvaluator(Evaluator): + PIPELINE_KWARGS = {} + + def __init__(self, task='image-classification', default_metric_name=None): + super().__init__(task, default_metric_name=default_metric_name) + + def predictions_processor(self, predictions, label_mapping): + pred_label = [max(pred, key=lambda x: x['score'])['label'] for pred in predictions] + pred_label = [label_mapping[pred] if label_mapping is not None else pred for pred in pred_label] + return {'predictions': pred_label} + + @add_start_docstrings(EVALUTOR_COMPUTE_START_DOCSTRING) + @add_end_docstrings(EVALUATOR_COMPUTE_RETURN_DOCSTRING, TASK_DOCUMENTATION) + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: Optional[str]=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, feature_extractor: Optional[Union[str, 'FeatureExtractionMixin']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: int=None, random_state: Optional[int]=None, input_column: str='image', label_column: str='label', label_mapping: Optional[Dict[str, Number]]=None) -> Tuple[Dict[str, float], Any]: + result = super().compute(model_or_pipeline=model_or_pipeline, data=data, subset=subset, split=split, metric=metric, tokenizer=tokenizer, feature_extractor=feature_extractor, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, device=device, random_state=random_state, input_column=input_column, label_column=label_column, label_mapping=label_mapping) + return result + +# File: evaluate-main/src/evaluate/evaluator/question_answering.py +from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union +from datasets import Dataset +try: + TRANSFORMERS_AVAILABLE = True +except ImportError: + TRANSFORMERS_AVAILABLE = False +from typing_extensions import Literal +from ..module import EvaluationModule +from ..utils.file_utils import add_end_docstrings, add_start_docstrings +from ..utils.logging import get_logger +from .base import EVALUATOR_COMPUTE_RETURN_DOCSTRING, EVALUTOR_COMPUTE_START_DOCSTRING, Evaluator +from .utils import DatasetColumn +if TYPE_CHECKING: + from transformers import Pipeline, PreTrainedModel, PreTrainedTokenizer, TFPreTrainedModel +logger = get_logger(__name__) +TASK_DOCUMENTATION = '\n Examples:\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n >>> task_evaluator = evaluator("question-answering")\n >>> data = load_dataset("squad", split="validation[:2]")\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline="sshleifer/tiny-distilbert-base-cased-distilled-squad",\n >>> data=data,\n >>> metric="squad",\n >>> )\n ```\n\n \n\n Datasets where the answer may be missing in the context are supported, for example SQuAD v2 dataset. In this case, it is safer to pass `squad_v2_format=True` to\n the compute() call.\n\n \n\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n >>> task_evaluator = evaluator("question-answering")\n >>> data = load_dataset("squad_v2", split="validation[:2]")\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline="mrm8488/bert-tiny-finetuned-squadv2",\n >>> data=data,\n >>> metric="squad_v2",\n >>> squad_v2_format=True,\n >>> )\n ```\n' + +class QuestionAnsweringEvaluator(Evaluator): + PIPELINE_KWARGS = {} + + def __init__(self, task='question-answering', default_metric_name=None): + super().__init__(task, default_metric_name=default_metric_name) + + def prepare_data(self, data: Dataset, question_column: str, context_column: str, id_column: str, label_column: str): + if data is None: + raise ValueError('Please specify a valid `data` object - either a `str` with a name or a `Dataset` object.') + self.check_required_columns(data, {'question_column': question_column, 'context_column': context_column, 'id_column': id_column, 'label_column': label_column}) + metric_inputs = dict() + metric_inputs['references'] = [{'id': element[id_column], 'answers': element[label_column]} for element in data] + return (metric_inputs, {'question': DatasetColumn(data, question_column), 'context': DatasetColumn(data, context_column)}) + + def is_squad_v2_format(self, data: Dataset, label_column: str='answers'): + original_num_rows = data.num_rows + nonempty_num_rows = data.filter(lambda x: len(x[label_column]['text']) > 0, load_from_cache_file=False).num_rows + if original_num_rows > nonempty_num_rows: + return True + else: + return False + + def predictions_processor(self, predictions: List, squad_v2_format: bool, ids: List): + result = [] + for i in range(len(predictions)): + pred = {'prediction_text': predictions[i]['answer'], 'id': ids[i]} + if squad_v2_format: + pred['no_answer_probability'] = predictions[i]['score'] + result.append(pred) + return {'predictions': result} + + @add_start_docstrings(EVALUTOR_COMPUTE_START_DOCSTRING) + @add_end_docstrings(EVALUATOR_COMPUTE_RETURN_DOCSTRING, TASK_DOCUMENTATION) + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: Optional[str]=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: int=None, random_state: Optional[int]=None, question_column: str='question', context_column: str='context', id_column: str='id', label_column: str='answers', squad_v2_format: Optional[bool]=None) -> Tuple[Dict[str, float], Any]: + result = {} + self.check_for_mismatch_in_device_setup(device, model_or_pipeline) + data = self.load_data(data=data, subset=subset, split=split) + (metric_inputs, pipe_inputs) = self.prepare_data(data=data, question_column=question_column, context_column=context_column, id_column=id_column, label_column=label_column) + if squad_v2_format is None: + squad_v2_format = self.is_squad_v2_format(data=data, label_column=label_column) + logger.warning(f'`squad_v2_format` parameter not provided to QuestionAnsweringEvaluator.compute(). Automatically inferred `squad_v2_format` as {squad_v2_format}.') + pipe = self.prepare_pipeline(model_or_pipeline=model_or_pipeline, tokenizer=tokenizer, device=device) + metric = self.prepare_metric(metric) + if squad_v2_format and metric.name == 'squad': + logger.warning("The dataset has SQuAD v2 format but you are using the SQuAD metric. Consider passing the 'squad_v2' metric.") + if not squad_v2_format and metric.name == 'squad_v2': + logger.warning("The dataset has SQuAD v1 format but you are using the SQuAD v2 metric. Consider passing the 'squad' metric.") + if squad_v2_format: + self.PIPELINE_KWARGS['handle_impossible_answer'] = True + else: + self.PIPELINE_KWARGS['handle_impossible_answer'] = False + (predictions, perf_results) = self.call_pipeline(pipe, **pipe_inputs) + predictions = self.predictions_processor(predictions, squad_v2_format=squad_v2_format, ids=data[id_column]) + metric_inputs.update(predictions) + metric_results = self.compute_metric(metric=metric, metric_inputs=metric_inputs, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, random_state=random_state) + result.update(metric_results) + result.update(perf_results) + return result + +# File: evaluate-main/src/evaluate/evaluator/text2text_generation.py +from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple, Union +from datasets import Dataset +from typing_extensions import Literal +from ..module import EvaluationModule +from ..utils.file_utils import add_start_docstrings +from .base import EVALUATOR_COMPUTE_RETURN_DOCSTRING, EVALUTOR_COMPUTE_START_DOCSTRING, Evaluator +if TYPE_CHECKING: + from transformers import Pipeline, PreTrainedModel, PreTrainedTokenizer, TFPreTrainedModel +TASK_DOCUMENTATION_KWARGS = '\n input_column (`str`, defaults to `"text"`):\n the name of the column containing the input text in the dataset specified by `data`.\n label_column (`str`, defaults to `"label"`):\n the name of the column containing the labels in the dataset specified by `data`.\n generation_kwargs (`Dict`, *optional*, defaults to `None`):\n The generation kwargs are passed to the pipeline and set the text generation strategy.\n' +TEXT2TEXT_TASK_DOCSTRING_EXAMPLE = '\n Examples:\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n >>> task_evaluator = evaluator("text2text-generation")\n >>> data = load_dataset("cnn_dailymail", "3.0.0", split="validation[:40]")\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline="facebook/bart-large-cnn",\n >>> data=data,\n >>> input_column="article",\n >>> label_column="highlights",\n >>> metric="rouge",\n >>> )\n ```\n' +SUMMARIZATION_TASK_DOCSTRING_EXAMPLE = '\n Examples:\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n >>> task_evaluator = evaluator("summarization")\n >>> data = load_dataset("cnn_dailymail", "3.0.0", split="validation[:40]")\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline="facebook/bart-large-cnn",\n >>> data=data,\n >>> input_column="article",\n >>> label_column="highlights",\n >>> )\n ```\n' +TRANSLATION_TASK_DOCSTRING_EXAMPLE = '\n Examples:\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n >>> task_evaluator = evaluator("translation")\n >>> data = load_dataset("wmt19", "fr-de", split="validation[:40]")\n >>> data = data.map(lambda x: {"text": x["translation"]["de"], "label": x["translation"]["fr"]})\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline="Helsinki-NLP/opus-mt-de-fr",\n >>> data=data,\n >>> )\n ```\n' + +class Text2TextGenerationEvaluator(Evaluator): + PREDICTION_PREFIX = 'generated' + PIPELINE_KWARGS = {'truncation': True} + + def __init__(self, task='text2text-generation', default_metric_name=None): + super().__init__(task, default_metric_name=default_metric_name) + + def predictions_processor(self, predictions, label_mapping): + return {'predictions': [pred[f'{self.PREDICTION_PREFIX}_text'] for pred in predictions]} + + @add_start_docstrings(EVALUTOR_COMPUTE_START_DOCSTRING, TASK_DOCUMENTATION_KWARGS, EVALUATOR_COMPUTE_RETURN_DOCSTRING, TEXT2TEXT_TASK_DOCSTRING_EXAMPLE) + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: Optional[str]=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: int=None, random_state: Optional[int]=None, input_column: str='text', label_column: str='label', generation_kwargs: dict=None) -> Tuple[Dict[str, float], Any]: + if generation_kwargs is not None: + self.PIPELINE_KWARGS.update(generation_kwargs) + result = super().compute(model_or_pipeline=model_or_pipeline, data=data, subset=subset, split=split, metric=metric, tokenizer=tokenizer, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, device=device, random_state=random_state, input_column=input_column, label_column=label_column) + return result + +class SummarizationEvaluator(Text2TextGenerationEvaluator): + PREDICTION_PREFIX = 'summary' + PIPELINE_KWARGS = {'truncation': True} + + def __init__(self, task='summarization', default_metric_name=None): + super().__init__(task, default_metric_name=default_metric_name) + + @add_start_docstrings(EVALUTOR_COMPUTE_START_DOCSTRING, TASK_DOCUMENTATION_KWARGS, EVALUATOR_COMPUTE_RETURN_DOCSTRING, SUMMARIZATION_TASK_DOCSTRING_EXAMPLE) + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: Optional[str]=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: int=None, random_state: Optional[int]=None, input_column: str='text', label_column: str='label', generation_kwargs: dict=None) -> Tuple[Dict[str, float], Any]: + result = super().compute(model_or_pipeline=model_or_pipeline, data=data, subset=subset, split=split, metric=metric, tokenizer=tokenizer, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, device=device, random_state=random_state, input_column=input_column, label_column=label_column, generation_kwargs=generation_kwargs) + return result + +class TranslationEvaluator(Text2TextGenerationEvaluator): + PREDICTION_PREFIX = 'translation' + PIPELINE_KWARGS = {'truncation': True} + + def __init__(self, task='translation', default_metric_name=None): + super().__init__(task, default_metric_name=default_metric_name) + + @add_start_docstrings(EVALUTOR_COMPUTE_START_DOCSTRING, TASK_DOCUMENTATION_KWARGS, EVALUATOR_COMPUTE_RETURN_DOCSTRING, TRANSLATION_TASK_DOCSTRING_EXAMPLE) + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: Optional[str]=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: int=None, random_state: Optional[int]=None, input_column: str='text', label_column: str='label', generation_kwargs: dict=None) -> Tuple[Dict[str, float], Any]: + result = super().compute(model_or_pipeline=model_or_pipeline, data=data, subset=subset, split=split, metric=metric, tokenizer=tokenizer, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, device=device, random_state=random_state, input_column=input_column, label_column=label_column, generation_kwargs=generation_kwargs) + return result + +# File: evaluate-main/src/evaluate/evaluator/text_classification.py +from numbers import Number +from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple, Union +from datasets import Dataset, load_dataset +from typing_extensions import Literal +from ..module import EvaluationModule +from ..utils.file_utils import add_end_docstrings, add_start_docstrings +from .base import EVALUATOR_COMPUTE_RETURN_DOCSTRING, EVALUTOR_COMPUTE_START_DOCSTRING, Evaluator +from .utils import DatasetColumnPair +if TYPE_CHECKING: + from transformers import FeatureExtractionMixin, Pipeline, PreTrainedModel, PreTrainedTokenizer, TFPreTrainedModel +TASK_DOCUMENTATION = '\n Examples:\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n >>> task_evaluator = evaluator("text-classification")\n >>> data = load_dataset("imdb", split="test[:2]")\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline="huggingface/prunebert-base-uncased-6-finepruned-w-distil-mnli",\n >>> data=data,\n >>> metric="accuracy",\n >>> label_mapping={"LABEL_0": 0.0, "LABEL_1": 1.0},\n >>> strategy="bootstrap",\n >>> n_resamples=10,\n >>> random_state=0\n >>> )\n ```\n' + +class TextClassificationEvaluator(Evaluator): + PIPELINE_KWARGS = {'truncation': True} + + def __init__(self, task='text-classification', default_metric_name=None): + super().__init__(task, default_metric_name=default_metric_name) + + def prepare_data(self, data: Union[str, Dataset], input_column: str, second_input_column: str, label_column: str): + if data is None: + raise ValueError('Please specify a valid `data` object - either a `str` with a name or a `Dataset` object.') + self.check_required_columns(data, {'input_column': input_column, 'label_column': label_column}) + if second_input_column is not None: + self.check_required_columns(data, {'second_input_column': second_input_column}) + data = load_dataset(data) if isinstance(data, str) else data + return ({'references': data[label_column]}, DatasetColumnPair(data, input_column, second_input_column, 'text', 'text_pair')) + + def predictions_processor(self, predictions, label_mapping): + predictions = [label_mapping[element['label']] if label_mapping is not None else element['label'] for element in predictions] + return {'predictions': predictions} + + @add_start_docstrings(EVALUTOR_COMPUTE_START_DOCSTRING) + @add_end_docstrings(EVALUATOR_COMPUTE_RETURN_DOCSTRING, TASK_DOCUMENTATION) + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: Optional[str]=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, feature_extractor: Optional[Union[str, 'FeatureExtractionMixin']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: int=None, random_state: Optional[int]=None, input_column: str='text', second_input_column: Optional[str]=None, label_column: str='label', label_mapping: Optional[Dict[str, Number]]=None) -> Tuple[Dict[str, float], Any]: + result = {} + self.check_for_mismatch_in_device_setup(device, model_or_pipeline) + data = self.load_data(data=data, subset=subset, split=split) + (metric_inputs, pipe_inputs) = self.prepare_data(data=data, input_column=input_column, second_input_column=second_input_column, label_column=label_column) + pipe = self.prepare_pipeline(model_or_pipeline=model_or_pipeline, tokenizer=tokenizer, feature_extractor=feature_extractor, device=device) + metric = self.prepare_metric(metric) + (predictions, perf_results) = self.call_pipeline(pipe, pipe_inputs) + predictions = self.predictions_processor(predictions, label_mapping) + metric_inputs.update(predictions) + metric_results = self.compute_metric(metric=metric, metric_inputs=metric_inputs, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, random_state=random_state) + result.update(metric_results) + result.update(perf_results) + return result + +# File: evaluate-main/src/evaluate/evaluator/text_generation.py +from typing import Dict, Tuple +from datasets import Dataset +from .base import Evaluator +from .utils import DatasetColumn +TASK_DOCUMENTATION_KWARGS = '\n input_column (`str`, defaults to `"text"`):\n the name of the column containing the input text in the dataset specified by `data`.\n generation_kwargs (`Dict`, *optional*, defaults to `None`):\n The generation kwargs are passed to the pipeline and set the text generation strategy.\n' + +class TextGenerationEvaluator(Evaluator): + + def predictions_processor(self, predictions, *args, **kwargs): + return {'data': [pred[f'{self.predictions_prefix}_text'] for pred_list in predictions for pred in pred_list]} + + def __init__(self, task='text-generation', default_metric_name=None, predictions_prefix: str='generated'): + super().__init__(task=task, default_metric_name=default_metric_name) + self.predictions_prefix = predictions_prefix + + def prepare_data(self, data: Dataset, input_column: str, *args, **kwargs) -> Tuple[Dict, DatasetColumn]: + self.check_required_columns(data, {'input_column': input_column}) + return ({}, DatasetColumn(data, input_column)) + +# File: evaluate-main/src/evaluate/evaluator/token_classification.py +from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union +from datasets import ClassLabel, Dataset, Sequence +from typing_extensions import Literal +from ..module import EvaluationModule +from ..utils.file_utils import add_end_docstrings, add_start_docstrings +from .base import EVALUATOR_COMPUTE_RETURN_DOCSTRING, EVALUTOR_COMPUTE_START_DOCSTRING, Evaluator +from .utils import DatasetColumn +if TYPE_CHECKING: + from transformers import Pipeline, PreTrainedModel, PreTrainedTokenizer, TFPreTrainedModel +TASK_DOCUMENTATION = '\n The dataset input and label columns are expected to be formatted as a list of words and a list of labels respectively, following [conll2003 dataset](https://huggingface.co/datasets/conll2003). Datasets whose inputs are single strings, and labels are a list of offset are not supported.\n\n Examples:\n ```python\n >>> from evaluate import evaluator\n >>> from datasets import load_dataset\n >>> task_evaluator = evaluator("token-classification")\n >>> data = load_dataset("conll2003", split="validation[:2]")\n >>> results = task_evaluator.compute(\n >>> model_or_pipeline="elastic/distilbert-base-uncased-finetuned-conll03-english",\n >>> data=data,\n >>> metric="seqeval",\n >>> )\n ```\n\n \n\n For example, the following dataset format is accepted by the evaluator:\n\n ```python\n dataset = Dataset.from_dict(\n mapping={\n "tokens": [["New", "York", "is", "a", "city", "and", "Felix", "a", "person", "."]],\n "ner_tags": [[1, 2, 0, 0, 0, 0, 3, 0, 0, 0]],\n },\n features=Features({\n "tokens": Sequence(feature=Value(dtype="string")),\n "ner_tags": Sequence(feature=ClassLabel(names=["O", "B-LOC", "I-LOC", "B-PER", "I-PER"])),\n }),\n )\n ```\n\n \n\n \n\n For example, the following dataset format is **not** accepted by the evaluator:\n\n ```python\n dataset = Dataset.from_dict(\n mapping={\n "tokens": [["New York is a city and Felix a person."]],\n "starts": [[0, 23]],\n "ends": [[7, 27]],\n "ner_tags": [["LOC", "PER"]],\n },\n features=Features({\n "tokens": Value(dtype="string"),\n "starts": Sequence(feature=Value(dtype="int32")),\n "ends": Sequence(feature=Value(dtype="int32")),\n "ner_tags": Sequence(feature=Value(dtype="string")),\n }),\n )\n ```\n\n \n' + +class TokenClassificationEvaluator(Evaluator): + PIPELINE_KWARGS = {'ignore_labels': []} + + def __init__(self, task='token-classification', default_metric_name=None): + super().__init__(task, default_metric_name=default_metric_name) + + def predictions_processor(self, predictions: List[List[Dict]], words: List[List[str]], join_by: str): + preds = [] + for (i, prediction) in enumerate(predictions): + pred_processed = [] + words_offsets = self.words_to_offsets(words[i], join_by) + token_index = 0 + for word_offset in words_offsets: + while prediction[token_index]['start'] < word_offset[0]: + token_index += 1 + if prediction[token_index]['start'] > word_offset[0]: + pred_processed.append('O') + elif prediction[token_index]['start'] == word_offset[0]: + pred_processed.append(prediction[token_index]['entity']) + preds.append(pred_processed) + return {'predictions': preds} + + def words_to_offsets(self, words: List[str], join_by: str): + offsets = [] + start = 0 + for word in words: + end = start + len(word) - 1 + offsets.append((start, end)) + start = end + len(join_by) + 1 + return offsets + + def prepare_data(self, data: Union[str, Dataset], input_column: str, label_column: str, join_by: str): + super().prepare_data(data, input_column, label_column) + if not isinstance(data.features[input_column], Sequence) or not isinstance(data.features[label_column], Sequence): + raise ValueError('TokenClassificationEvaluator expects the input and label columns to be provided as lists.') + labels_are_int = isinstance(data.features[label_column].feature, ClassLabel) + if labels_are_int: + label_list = data.features[label_column].feature.names + id_to_label = {i: label for (i, label) in enumerate(label_list)} + references = [[id_to_label[label_id] for label_id in label_ids] for label_ids in data[label_column]] + elif data.features[label_column].feature.dtype.startswith('int'): + raise NotImplementedError('References provided as integers, but the reference column is not a Sequence of ClassLabels.') + else: + references = data[label_column] + metric_inputs = {'references': references} + data = data.map(lambda x: {input_column: join_by.join(x[input_column])}) + pipeline_inputs = DatasetColumn(data, input_column) + return (metric_inputs, pipeline_inputs) + + def prepare_pipeline(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel'], tokenizer: Union['PreTrainedTokenizerBase', 'FeatureExtractionMixin']=None, feature_extractor: Union['PreTrainedTokenizerBase', 'FeatureExtractionMixin']=None, device: int=None): + pipe = super().prepare_pipeline(model_or_pipeline, tokenizer, feature_extractor, device) + dummy_output = pipe(['2003 New York Gregory'], **self.PIPELINE_KWARGS) + if dummy_output[0][0]['start'] is None: + raise ValueError("TokenClassificationEvaluator supports only pipelines giving 'start' index as a pipeline output (got None). Transformers pipelines with a slow tokenizer will raise this error.") + return pipe + + @add_start_docstrings(EVALUTOR_COMPUTE_START_DOCSTRING) + @add_end_docstrings(EVALUATOR_COMPUTE_RETURN_DOCSTRING, TASK_DOCUMENTATION) + def compute(self, model_or_pipeline: Union[str, 'Pipeline', Callable, 'PreTrainedModel', 'TFPreTrainedModel']=None, data: Union[str, Dataset]=None, subset: Optional[str]=None, split: str=None, metric: Union[str, EvaluationModule]=None, tokenizer: Optional[Union[str, 'PreTrainedTokenizer']]=None, strategy: Literal['simple', 'bootstrap']='simple', confidence_level: float=0.95, n_resamples: int=9999, device: Optional[int]=None, random_state: Optional[int]=None, input_column: str='tokens', label_column: str='ner_tags', join_by: Optional[str]=' ') -> Tuple[Dict[str, float], Any]: + result = {} + self.check_for_mismatch_in_device_setup(device, model_or_pipeline) + data = self.load_data(data=data, subset=subset, split=split) + (metric_inputs, pipe_inputs) = self.prepare_data(data=data, input_column=input_column, label_column=label_column, join_by=join_by) + pipe = self.prepare_pipeline(model_or_pipeline=model_or_pipeline, tokenizer=tokenizer, device=device) + metric = self.prepare_metric(metric) + (predictions, perf_results) = self.call_pipeline(pipe, pipe_inputs) + predictions = self.predictions_processor(predictions, data[input_column], join_by) + metric_inputs.update(predictions) + metric_results = self.compute_metric(metric=metric, metric_inputs=metric_inputs, strategy=strategy, confidence_level=confidence_level, n_resamples=n_resamples, random_state=random_state) + result.update(metric_results) + result.update(perf_results) + return result + +# File: evaluate-main/src/evaluate/evaluator/utils.py +from datasets import Dataset, get_dataset_split_names + +class DatasetColumn(list): + + def __init__(self, dataset: Dataset, key: str): + self.dataset = dataset + self.key = key + + def __len__(self): + return len(self.dataset) + + def __getitem__(self, i): + return self.dataset[i][self.key] + + def __iter__(self): + return (self.dataset[i][self.key] for i in range(len(self))) + +def choose_split(data, subset=None): + available_splits = get_dataset_split_names(data, subset) + preferred_split_order = ['test', 'testing', 'eval', 'evaluation', 'validation', 'val', 'valid', 'dev', 'train', 'training'] + for split in preferred_split_order: + if split in available_splits: + return split + raise ValueError('No dataset split defined! Pass an explicit value to the `split` kwarg.') + +class DatasetColumnPair(list): + + def __init__(self, dataset: Dataset, first_col: str, second_col: str, first_key: str, second_key: str): + self.dataset = dataset + self.first_col = first_col + self.second_col = second_col + self.first_key = first_key + self.second_key = second_key + + def __len__(self): + return len(self.dataset) + + def __getitem__(self, i): + return {self.first_key: self.dataset[i][self.first_col], self.second_key: self.dataset[i][self.second_col] if self.second_col else None} + + def __iter__(self): + return ({self.first_key: self.dataset[i][self.first_col], self.second_key: self.dataset[i][self.second_col] if self.second_col else None} for i in range(len(self))) + +# File: evaluate-main/src/evaluate/hub.py +from typing import Dict +import requests +from huggingface_hub import dataset_info, model_info +from huggingface_hub.repocard import metadata_update +from .config import HF_HUB_ALLOWED_TASKS +from .utils.logging import get_logger +logger = get_logger(__name__) + +def push_to_hub(model_id: str, task_type: str, dataset_type: str, dataset_name: str, metric_type: str, metric_name: str, metric_value: float, task_name: str=None, dataset_config: str=None, dataset_split: str=None, dataset_revision: str=None, dataset_args: Dict[str, int]=None, metric_config: str=None, metric_args: Dict[str, int]=None, overwrite: bool=False): + if task_type not in HF_HUB_ALLOWED_TASKS: + raise ValueError(f'Task type not supported. Task has to be one of {HF_HUB_ALLOWED_TASKS}') + try: + dataset_info(dataset_type) + except requests.exceptions.HTTPError: + logger.warning(f'Dataset {dataset_type} not found on the Hub at hf.co/datasets/{dataset_type}') + try: + model_info(model_id) + except requests.exceptions.HTTPError: + raise ValueError(f'Model {model_id} not found on the Hub at hf.co/{model_id}') + result = {'task': {'type': task_type}, 'dataset': {'type': dataset_type, 'name': dataset_name}, 'metrics': [{'type': metric_type, 'value': metric_value}]} + if dataset_config is not None: + result['dataset']['config'] = dataset_config + if dataset_split is not None: + result['dataset']['split'] = dataset_split + if dataset_revision is not None: + result['dataset']['revision'] = dataset_revision + if dataset_args is not None: + result['dataset']['args'] = dataset_args + if task_name is not None: + result['task']['name'] = task_name + if metric_name is not None: + result['metrics'][0]['name'] = metric_name + if metric_config is not None: + result['metrics'][0]['config'] = metric_config + if metric_args is not None: + result['metrics'][0]['args'] = metric_args + metadata = {'model-index': [{'results': [result]}]} + return metadata_update(repo_id=model_id, metadata=metadata, overwrite=overwrite) + +# File: evaluate-main/src/evaluate/info.py +"""""" +import dataclasses +import json +import os +from dataclasses import asdict, dataclass, field +from typing import List, Optional, Union +from datasets.features import Features, Value +from . import config +from .utils.logging import get_logger +logger = get_logger(__name__) + +@dataclass +class EvaluationModuleInfo: + description: str + citation: str + features: Union[Features, List[Features]] + inputs_description: str = field(default_factory=str) + homepage: str = field(default_factory=str) + license: str = field(default_factory=str) + codebase_urls: List[str] = field(default_factory=list) + reference_urls: List[str] = field(default_factory=list) + streamable: bool = False + format: Optional[str] = None + module_type: str = 'metric' + module_name: Optional[str] = None + config_name: Optional[str] = None + experiment_id: Optional[str] = None + + def __post_init__(self): + if self.format is not None: + for (key, value) in self.features.items(): + if not isinstance(value, Value): + raise ValueError(f"When using 'numpy' format, all features should be a `datasets.Value` feature. Here {key} is an instance of {value.__class__.__name__}") + + def write_to_directory(self, metric_info_dir): + with open(os.path.join(metric_info_dir, config.METRIC_INFO_FILENAME), 'w', encoding='utf-8') as f: + json.dump(asdict(self), f) + with open(os.path.join(metric_info_dir, config.LICENSE_FILENAME), 'w', encoding='utf-8') as f: + f.write(self.license) + + @classmethod + def from_directory(cls, metric_info_dir) -> 'EvaluationModuleInfo': + logger.info(f'Loading Metric info from {metric_info_dir}') + if not metric_info_dir: + raise ValueError('Calling EvaluationModuleInfo.from_directory() with undefined metric_info_dir.') + with open(os.path.join(metric_info_dir, config.METRIC_INFO_FILENAME), encoding='utf-8') as f: + metric_info_dict = json.load(f) + return cls.from_dict(metric_info_dict) + + @classmethod + def from_dict(cls, metric_info_dict: dict) -> 'EvaluationModuleInfo': + field_names = {f.name for f in dataclasses.fields(cls)} + return cls(**{k: v for (k, v) in metric_info_dict.items() if k in field_names}) + +@dataclass +class MetricInfo(EvaluationModuleInfo): + module_type: str = 'metric' + +@dataclass +class ComparisonInfo(EvaluationModuleInfo): + module_type: str = 'comparison' + +@dataclass +class MeasurementInfo(EvaluationModuleInfo): + module_type: str = 'measurement' + +# File: evaluate-main/src/evaluate/inspect.py +"""""" +from typing import Optional +import requests +from datasets import DownloadConfig +from .config import EVALUATION_MODULE_TYPES, HF_LIST_ENDPOINT +from .loading import evaluation_module_factory +from .utils.logging import get_logger +logger = get_logger(__name__) + +class SplitsNotFoundError(ValueError): + pass + +def list_evaluation_modules(module_type=None, include_community=True, with_details=False): + if module_type is None: + evaluations_list = [] + for module_type in EVALUATION_MODULE_TYPES: + evaluations_list.extend(_list_evaluation_modules_type(module_type, include_community=include_community, with_details=with_details)) + else: + if module_type not in EVALUATION_MODULE_TYPES: + raise ValueError(f"Invalid module type '{module_type}'. Has to be one of {EVALUATION_MODULE_TYPES}.") + evaluations_list = _list_evaluation_modules_type(module_type, include_community=include_community, with_details=with_details) + return evaluations_list + +def _list_evaluation_modules_type(module_type, include_community=True, with_details=False): + r = requests.get(HF_LIST_ENDPOINT.format(type=module_type)) + r.raise_for_status() + d = r.json() + if not include_community: + d = [element for element in d if element['id'].split('/')[0] == f'evaluate-{module_type}'] + for element in d: + if element['id'].split('/')[0] == f'evaluate-{module_type}': + element['id'] = element['id'].split('/')[1] + element['community'] = False + else: + element['community'] = True + if with_details: + return [{'name': element['id'], 'type': module_type, 'community': element['community'], 'likes': element.get('likes', 0)} for element in d] + else: + return [element['id'] for element in d] + +def inspect_evaluation_module(path: str, local_path: str, download_config: Optional[DownloadConfig]=None, **download_kwargs): + evaluation_module = evaluation_module_factory(path, download_config=download_config, force_local_path=local_path, **download_kwargs) + print(f'The processing scripts for metric {path} can be inspected at {local_path}. The main class is in {evaluation_module.module_path}. You can modify this processing scripts and use it with `evaluate.load({local_path})`.') + +# File: evaluate-main/src/evaluate/loading.py +"""""" +import filecmp +import importlib +import inspect +import json +import os +import re +import shutil +import time +from dataclasses import dataclass +from pathlib import Path +from typing import List, Optional, Tuple, Type, Union +from urllib.parse import urlparse +from datasets import DownloadConfig, DownloadMode +from datasets.builder import DatasetBuilder +from datasets.packaged_modules import _EXTENSION_TO_MODULE, _hash_python_lines +from datasets.utils.filelock import FileLock +from datasets.utils.version import Version +from . import SCRIPTS_VERSION, config +from .module import EvaluationModule +from .utils.file_utils import cached_path, head_hf_s3, hf_hub_url, init_hf_modules, is_relative_path, relative_to_absolute_path, url_or_path_join +from .utils.logging import get_logger +logger = get_logger(__name__) +ALL_ALLOWED_EXTENSIONS = list(_EXTENSION_TO_MODULE.keys()) + ['zip'] + +def init_dynamic_modules(name: str=config.MODULE_NAME_FOR_DYNAMIC_MODULES, hf_modules_cache: Optional[Union[Path, str]]=None): + hf_modules_cache = init_hf_modules(hf_modules_cache) + dynamic_modules_path = os.path.join(hf_modules_cache, name) + os.makedirs(dynamic_modules_path, exist_ok=True) + if not os.path.exists(os.path.join(dynamic_modules_path, '__init__.py')): + with open(os.path.join(dynamic_modules_path, '__init__.py'), 'w'): + pass + return dynamic_modules_path + +def import_main_class(module_path) -> Optional[Union[Type[DatasetBuilder], Type[EvaluationModule]]]: + module = importlib.import_module(module_path) + main_cls_type = EvaluationModule + module_main_cls = None + for (name, obj) in module.__dict__.items(): + if isinstance(obj, type) and issubclass(obj, main_cls_type): + if inspect.isabstract(obj): + continue + module_main_cls = obj + break + return module_main_cls + +def files_to_hash(file_paths: List[str]) -> str: + to_use_files: List[Union[Path, str]] = [] + for file_path in file_paths: + if os.path.isdir(file_path): + to_use_files.extend(list(Path(file_path).rglob('*.[pP][yY]'))) + else: + to_use_files.append(file_path) + lines = [] + for file_path in to_use_files: + with open(file_path, encoding='utf-8') as f: + lines.extend(f.readlines()) + return _hash_python_lines(lines) + +def convert_github_url(url_path: str) -> Tuple[str, Optional[str]]: + parsed = urlparse(url_path) + sub_directory = None + if parsed.scheme in ('http', 'https', 's3') and parsed.netloc == 'github.com': + if 'blob' in url_path: + if not url_path.endswith('.py'): + raise ValueError(f"External import from github at {url_path} should point to a file ending with '.py'") + url_path = url_path.replace('blob', 'raw') + else: + github_path = parsed.path[1:] + (repo_info, branch) = github_path.split('/tree/') if '/tree/' in github_path else (github_path, 'master') + (repo_owner, repo_name) = repo_info.split('/') + url_path = f'https://github.com/{repo_owner}/{repo_name}/archive/{branch}.zip' + sub_directory = f'{repo_name}-{branch}' + return (url_path, sub_directory) + +def increase_load_count(name: str, resource_type: str): + if not config.HF_EVALUATE_OFFLINE and config.HF_UPDATE_DOWNLOAD_COUNTS: + try: + head_hf_s3(name, filename=name + '.py', dataset=resource_type == 'dataset') + except Exception: + pass + +def get_imports(file_path: str) -> Tuple[str, str, str, str]: + lines = [] + with open(file_path, encoding='utf-8') as f: + lines.extend(f.readlines()) + logger.debug(f'Checking {file_path} for additional imports.') + imports: List[Tuple[str, str, str, Optional[str]]] = [] + is_in_docstring = False + for line in lines: + docstr_start_match = re.findall('[\\s\\S]*?"""[\\s\\S]*?', line) + if len(docstr_start_match) == 1: + is_in_docstring = not is_in_docstring + if is_in_docstring: + continue + match = re.match('^import\\s+(\\.?)([^\\s\\.]+)[^#\\r\\n]*(?:#\\s+From:\\s+)?([^\\r\\n]*)', line, flags=re.MULTILINE) + if match is None: + match = re.match('^from\\s+(\\.?)([^\\s\\.]+)(?:[^\\s]*)\\s+import\\s+[^#\\r\\n]*(?:#\\s+From:\\s+)?([^\\r\\n]*)', line, flags=re.MULTILINE) + if match is None: + continue + if match.group(1): + if any((imp[1] == match.group(2) for imp in imports)): + continue + if match.group(3): + url_path = match.group(3) + (url_path, sub_directory) = convert_github_url(url_path) + imports.append(('external', match.group(2), url_path, sub_directory)) + elif match.group(2): + imports.append(('internal', match.group(2), match.group(2), None)) + elif match.group(3): + url_path = match.group(3) + imports.append(('library', match.group(2), url_path, None)) + else: + imports.append(('library', match.group(2), match.group(2), None)) + return imports + +def _download_additional_modules(name: str, base_path: str, imports: Tuple[str, str, str, str], download_config: Optional[DownloadConfig]) -> List[Tuple[str, str]]: + local_imports = [] + library_imports = [] + download_config = download_config.copy() + if download_config.download_desc is None: + download_config.download_desc = 'Downloading extra modules' + for (import_type, import_name, import_path, sub_directory) in imports: + if import_type == 'library': + library_imports.append((import_name, import_path)) + continue + if import_name == name: + raise ValueError(f"Error in the {name} script, importing relative {import_name} module but {import_name} is the name of the script. Please change relative import {import_name} to another name and add a '# From: URL_OR_PATH' comment pointing to the original relative import file path.") + if import_type == 'internal': + url_or_filename = url_or_path_join(base_path, import_path + '.py') + elif import_type == 'external': + url_or_filename = import_path + else: + raise ValueError('Wrong import_type') + local_import_path = cached_path(url_or_filename, download_config=download_config) + if sub_directory is not None: + local_import_path = os.path.join(local_import_path, sub_directory) + local_imports.append((import_name, local_import_path)) + needs_to_be_installed = set() + for (library_import_name, library_import_path) in library_imports: + try: + lib = importlib.import_module(library_import_name) + except ImportError: + library_import_name = 'scikit-learn' if library_import_name == 'sklearn' else library_import_name + needs_to_be_installed.add((library_import_name, library_import_path)) + if needs_to_be_installed: + raise ImportError(f"To be able to use {name}, you need to install the following dependencies{[lib_name for (lib_name, lib_path) in needs_to_be_installed]} using 'pip install {' '.join([lib_path for (lib_name, lib_path) in needs_to_be_installed])}' for instance'") + return local_imports + +def _copy_script_and_other_resources_in_importable_dir(name: str, importable_directory_path: str, subdirectory_name: str, original_local_path: str, local_imports: List[Tuple[str, str]], additional_files: List[Tuple[str, str]], download_mode: Optional[DownloadMode]) -> str: + importable_subdirectory = os.path.join(importable_directory_path, subdirectory_name) + importable_local_file = os.path.join(importable_subdirectory, name + '.py') + lock_path = importable_directory_path + '.lock' + with FileLock(lock_path): + if download_mode == DownloadMode.FORCE_REDOWNLOAD and os.path.exists(importable_directory_path): + shutil.rmtree(importable_directory_path) + os.makedirs(importable_directory_path, exist_ok=True) + init_file_path = os.path.join(importable_directory_path, '__init__.py') + if not os.path.exists(init_file_path): + with open(init_file_path, 'w'): + pass + os.makedirs(importable_subdirectory, exist_ok=True) + init_file_path = os.path.join(importable_subdirectory, '__init__.py') + if not os.path.exists(init_file_path): + with open(init_file_path, 'w'): + pass + if not os.path.exists(importable_local_file): + shutil.copyfile(original_local_path, importable_local_file) + meta_path = importable_local_file.split('.py')[0] + '.json' + if not os.path.exists(meta_path): + meta = {'original file path': original_local_path, 'local file path': importable_local_file} + with open(meta_path, 'w', encoding='utf-8') as meta_file: + json.dump(meta, meta_file) + for (import_name, import_path) in local_imports: + if os.path.isfile(import_path): + full_path_local_import = os.path.join(importable_subdirectory, import_name + '.py') + if not os.path.exists(full_path_local_import): + shutil.copyfile(import_path, full_path_local_import) + elif os.path.isdir(import_path): + full_path_local_import = os.path.join(importable_subdirectory, import_name) + if not os.path.exists(full_path_local_import): + shutil.copytree(import_path, full_path_local_import) + else: + raise OSError(f'Error with local import at {import_path}') + for (file_name, original_path) in additional_files: + destination_additional_path = os.path.join(importable_subdirectory, file_name) + if not os.path.exists(destination_additional_path) or not filecmp.cmp(original_path, destination_additional_path): + shutil.copyfile(original_path, destination_additional_path) + return importable_local_file + +def _create_importable_file(local_path: str, local_imports: List[Tuple[str, str]], additional_files: List[Tuple[str, str]], dynamic_modules_path: str, module_namespace: str, name: str, download_mode: DownloadMode) -> Tuple[str, str]: + importable_directory_path = os.path.join(dynamic_modules_path, module_namespace, name.replace('/', '--')) + Path(importable_directory_path).mkdir(parents=True, exist_ok=True) + (Path(importable_directory_path).parent / '__init__.py').touch(exist_ok=True) + hash = files_to_hash([local_path] + [loc[1] for loc in local_imports]) + importable_local_file = _copy_script_and_other_resources_in_importable_dir(name=name.split('/')[-1], importable_directory_path=importable_directory_path, subdirectory_name=hash, original_local_path=local_path, local_imports=local_imports, additional_files=additional_files, download_mode=download_mode) + logger.debug(f'Created importable dataset file at {importable_local_file}') + module_path = '.'.join([os.path.basename(dynamic_modules_path), module_namespace, name.replace('/', '--'), hash, name.split('/')[-1]]) + return (module_path, hash) + +@dataclass +class ImportableModule: + module_path: str + hash: str + +class _EvaluationModuleFactory: + + def get_module(self) -> ImportableModule: + raise NotImplementedError + +class LocalEvaluationModuleFactory(_EvaluationModuleFactory): + + def __init__(self, path: str, module_type: str='metrics', download_config: Optional[DownloadConfig]=None, download_mode: Optional[DownloadMode]=None, dynamic_modules_path: Optional[str]=None): + self.path = path + self.module_type = module_type + self.name = Path(path).stem + self.download_config = download_config or DownloadConfig() + self.download_mode = download_mode + self.dynamic_modules_path = dynamic_modules_path + + def get_module(self) -> ImportableModule: + imports = get_imports(self.path) + local_imports = _download_additional_modules(name=self.name, base_path=str(Path(self.path).parent), imports=imports, download_config=self.download_config) + dynamic_modules_path = self.dynamic_modules_path if self.dynamic_modules_path else init_dynamic_modules() + (module_path, hash) = _create_importable_file(local_path=self.path, local_imports=local_imports, additional_files=[], dynamic_modules_path=dynamic_modules_path, module_namespace=self.module_type, name=self.name, download_mode=self.download_mode) + importlib.invalidate_caches() + return ImportableModule(module_path, hash) + +class HubEvaluationModuleFactory(_EvaluationModuleFactory): + + def __init__(self, name: str, module_type: str='metrics', revision: Optional[Union[str, Version]]=None, download_config: Optional[DownloadConfig]=None, download_mode: Optional[DownloadMode]=None, dynamic_modules_path: Optional[str]=None): + self.name = name + self.module_type = module_type + self.revision = revision + self.download_config = download_config or DownloadConfig() + self.download_mode = download_mode + self.dynamic_modules_path = dynamic_modules_path + assert self.name.count('/') == 1 + increase_load_count(name, resource_type='metric') + + def download_loading_script(self, revision) -> str: + file_path = hf_hub_url(path=self.name, name=self.name.split('/')[1] + '.py', revision=revision) + download_config = self.download_config.copy() + if download_config.download_desc is None: + download_config.download_desc = 'Downloading builder script' + return cached_path(file_path, download_config=download_config) + + def get_module(self) -> ImportableModule: + revision = self.revision or os.getenv('HF_SCRIPTS_VERSION', SCRIPTS_VERSION) + if re.match('\\d*\\.\\d*\\.\\d*', revision): + revision = 'v' + revision + try: + local_path = self.download_loading_script(revision) + except FileNotFoundError as err: + if self.revision is None and os.getenv('HF_SCRIPTS_VERSION', SCRIPTS_VERSION) != 'main': + revision = 'main' + local_path = self.download_loading_script(revision) + else: + raise err + imports = get_imports(local_path) + local_imports = _download_additional_modules(name=self.name, base_path=hf_hub_url(path=self.name, name='', revision=revision), imports=imports, download_config=self.download_config) + dynamic_modules_path = self.dynamic_modules_path if self.dynamic_modules_path else init_dynamic_modules() + (module_path, hash) = _create_importable_file(local_path=local_path, local_imports=local_imports, additional_files=[], dynamic_modules_path=dynamic_modules_path, module_namespace=self.module_type, name=self.name, download_mode=self.download_mode) + importlib.invalidate_caches() + return ImportableModule(module_path, hash) + +class CachedEvaluationModuleFactory(_EvaluationModuleFactory): + + def __init__(self, name: str, module_type: str='metrics', dynamic_modules_path: Optional[str]=None): + self.name = name + self.module_type = module_type + self.dynamic_modules_path = dynamic_modules_path + assert self.name.count('/') == 0 + + def get_module(self) -> ImportableModule: + dynamic_modules_path = self.dynamic_modules_path if self.dynamic_modules_path else init_dynamic_modules() + importable_directory_path = os.path.join(dynamic_modules_path, self.module_type, self.name) + hashes = [h for h in os.listdir(importable_directory_path) if len(h) == 64] if os.path.isdir(importable_directory_path) else None + if not hashes: + raise FileNotFoundError(f'Metric {self.name} is not cached in {dynamic_modules_path}') + + def _get_modification_time(module_hash): + return (Path(importable_directory_path) / module_hash / (self.name.split('--')[-1] + '.py')).stat().st_mtime + hash = sorted(hashes, key=_get_modification_time)[-1] + logger.warning(f"Using the latest cached version of the module from {os.path.join(importable_directory_path, hash)} (last modified on {time.ctime(_get_modification_time(hash))}) since it couldn't be found locally at {self.name}, or remotely on the Hugging Face Hub.") + module_path = '.'.join([os.path.basename(dynamic_modules_path), self.module_type, self.name, hash, self.name.split('--')[-1]]) + importlib.invalidate_caches() + return ImportableModule(module_path, hash) + +def evaluation_module_factory(path: str, module_type: Optional[str]=None, revision: Optional[Union[str, Version]]=None, download_config: Optional[DownloadConfig]=None, download_mode: Optional[DownloadMode]=None, force_local_path: Optional[str]=None, dynamic_modules_path: Optional[str]=None, **download_kwargs) -> ImportableModule: + if download_config is None: + download_config = DownloadConfig(**download_kwargs) + download_mode = DownloadMode(download_mode or DownloadMode.REUSE_DATASET_IF_EXISTS) + download_config.extract_compressed_file = True + download_config.force_extract = True + filename = list(filter(lambda x: x, path.replace(os.sep, '/').split('/')))[-1] + if not filename.endswith('.py'): + filename = filename + '.py' + combined_path = os.path.join(path, filename) + if path.endswith(filename): + if os.path.isfile(path): + return LocalEvaluationModuleFactory(path, download_mode=download_mode, dynamic_modules_path=dynamic_modules_path).get_module() + else: + raise FileNotFoundError(f"Couldn't find a metric script at {relative_to_absolute_path(path)}") + elif os.path.isfile(combined_path): + return LocalEvaluationModuleFactory(combined_path, download_mode=download_mode, dynamic_modules_path=dynamic_modules_path).get_module() + elif is_relative_path(path) and path.count('/') <= 1 and (not force_local_path): + try: + if path.count('/') == 0: + if module_type is None: + for current_type in ['metric', 'comparison', 'measurement']: + try: + return HubEvaluationModuleFactory(f'evaluate-{current_type}/{path}', revision=revision, download_config=download_config, download_mode=download_mode, dynamic_modules_path=dynamic_modules_path).get_module() + except ConnectionError: + pass + raise FileNotFoundError + else: + return HubEvaluationModuleFactory(f'evaluate-{module_type}/{path}', revision=revision, download_config=download_config, download_mode=download_mode, dynamic_modules_path=dynamic_modules_path).get_module() + elif path.count('/') == 1: + return HubEvaluationModuleFactory(path, revision=revision, download_config=download_config, download_mode=download_mode, dynamic_modules_path=dynamic_modules_path).get_module() + except Exception as e1: + if path.count('/') == 0: + for current_type in ['metric', 'comparison', 'measurement']: + try: + return CachedEvaluationModuleFactory(f'evaluate-{current_type}--{path}', dynamic_modules_path=dynamic_modules_path).get_module() + except Exception as e2: + pass + elif path.count('/') == 1: + try: + return CachedEvaluationModuleFactory(path.replace('/', '--'), dynamic_modules_path=dynamic_modules_path).get_module() + except Exception as e2: + pass + if not isinstance(e1, (ConnectionError, FileNotFoundError)): + raise e1 from None + raise FileNotFoundError(f"Couldn't find a module script at {relative_to_absolute_path(combined_path)}. Module '{path}' doesn't exist on the Hugging Face Hub either.") from None + else: + raise FileNotFoundError(f"Couldn't find a module script at {relative_to_absolute_path(combined_path)}.") + +def load(path: str, config_name: Optional[str]=None, module_type: Optional[str]=None, process_id: int=0, num_process: int=1, cache_dir: Optional[str]=None, experiment_id: Optional[str]=None, keep_in_memory: bool=False, download_config: Optional[DownloadConfig]=None, download_mode: Optional[DownloadMode]=None, revision: Optional[Union[str, Version]]=None, **init_kwargs) -> EvaluationModule: + download_mode = DownloadMode(download_mode or DownloadMode.REUSE_DATASET_IF_EXISTS) + evaluation_module = evaluation_module_factory(path, module_type=module_type, revision=revision, download_config=download_config, download_mode=download_mode) + evaluation_cls = import_main_class(evaluation_module.module_path) + evaluation_instance = evaluation_cls(config_name=config_name, process_id=process_id, num_process=num_process, cache_dir=cache_dir, keep_in_memory=keep_in_memory, experiment_id=experiment_id, hash=evaluation_module.hash, **init_kwargs) + if module_type and module_type != evaluation_instance.module_type: + raise TypeError(f"No module of module type '{module_type}' not found for '{path}' locally, or on the Hugging Face Hub. Found module of module type '{evaluation_instance.module_type}' instead.") + evaluation_instance.download_and_prepare(download_config=download_config) + return evaluation_instance + +# File: evaluate-main/src/evaluate/module.py +"""""" +import collections +import itertools +import os +import types +import uuid +from typing import Any, Dict, List, Optional, Tuple, Union +import numpy as np +import pyarrow as pa +from datasets import DatasetInfo, DownloadConfig, DownloadManager +from datasets.arrow_dataset import Dataset +from datasets.arrow_reader import ArrowReader +from datasets.arrow_writer import ArrowWriter +from datasets.features import Features, Sequence, Value +from datasets.features.features import _check_non_null_non_empty_recursive +from datasets.utils.filelock import BaseFileLock, FileLock, Timeout +from datasets.utils.py_utils import copyfunc, temp_seed, zip_dict +from . import config +from .info import EvaluationModuleInfo +from .naming import camelcase_to_snakecase +from .utils.logging import get_logger +logger = get_logger(__name__) + +class FileFreeLock(BaseFileLock): + + def __init__(self, lock_file, *args, **kwargs): + self.filelock = FileLock(lock_file) + super().__init__(lock_file, *args, **kwargs) + self._lock_file_fd = None + + def _acquire(self): + try: + self.filelock.acquire(timeout=0.01, poll_interval=0.02) + except Timeout: + self._lock_file_fd = self.filelock.lock_file + else: + self.filelock.release() + self._lock_file_fd = None + + def _release(self): + self._lock_file_fd = None + + @property + def is_locked(self) -> bool: + return self._lock_file_fd is not None + +def summarize_if_long_list(obj): + if type(obj) is not list or len(obj) <= 6: + return f'{obj}' + + def format_chunk(chunk): + return ', '.join((repr(x) for x in chunk)) + return f'[{format_chunk(obj[:3])}, ..., {format_chunk(obj[-3:])}]' + +class EvaluationModuleInfoMixin: + + def __init__(self, info: EvaluationModuleInfo): + self._module_info = info + + @property + def info(self): + return self._module_info + + @property + def name(self) -> str: + return self._module_info.module_name + + @property + def experiment_id(self) -> Optional[str]: + return self._module_info.experiment_id + + @property + def description(self) -> str: + return self._module_info.description + + @property + def citation(self) -> str: + return self._module_info.citation + + @property + def features(self) -> Features: + return self._module_info.features + + @property + def inputs_description(self) -> str: + return self._module_info.inputs_description + + @property + def homepage(self) -> Optional[str]: + return self._module_info.homepage + + @property + def license(self) -> str: + return self._module_info.license + + @property + def codebase_urls(self) -> Optional[List[str]]: + return self._module_info.codebase_urls + + @property + def reference_urls(self) -> Optional[List[str]]: + return self._module_info.reference_urls + + @property + def streamable(self) -> bool: + return self._module_info.streamable + + @property + def format(self) -> Optional[str]: + return self._module_info.format + + @property + def module_type(self) -> str: + return self._module_info.module_type + +class EvaluationModule(EvaluationModuleInfoMixin): + + def __init__(self, config_name: Optional[str]=None, keep_in_memory: bool=False, cache_dir: Optional[str]=None, num_process: int=1, process_id: int=0, seed: Optional[int]=None, experiment_id: Optional[str]=None, hash: str=None, max_concurrent_cache_files: int=10000, timeout: Union[int, float]=100, **kwargs): + self.config_name = config_name or 'default' + info = self._info() + info.module_name = camelcase_to_snakecase(self.__class__.__name__) + info.config_name = self.config_name + info.experiment_id = experiment_id or 'default_experiment' + EvaluationModuleInfoMixin.__init__(self, info) + if not isinstance(process_id, int) or process_id < 0: + raise ValueError("'process_id' should be a number greater than 0") + if not isinstance(num_process, int) or num_process <= process_id: + raise ValueError("'num_process' should be a number greater than process_id") + if keep_in_memory and num_process != 1: + raise ValueError("Using 'keep_in_memory' is not possible in distributed setting (num_process > 1).") + self.num_process = num_process + self.process_id = process_id + self.max_concurrent_cache_files = max_concurrent_cache_files + self.keep_in_memory = keep_in_memory + self._data_dir_root = os.path.expanduser(cache_dir or config.HF_METRICS_CACHE) + self.data_dir = self._build_data_dir() + if seed is None: + (_, seed, pos, *_) = np.random.get_state() + self.seed: int = seed[pos] if pos < 624 else seed[0] + else: + self.seed: int = seed + self.timeout: Union[int, float] = timeout + self.compute = types.MethodType(copyfunc(self.compute), self) + self.add_batch = types.MethodType(copyfunc(self.add_batch), self) + self.add = types.MethodType(copyfunc(self.add), self) + self.compute.__func__.__doc__ += self.info.inputs_description + self.add_batch.__func__.__doc__ += self.info.inputs_description + self.add.__func__.__doc__ += self.info.inputs_description + self.selected_feature_format = None + self.buf_writer = None + self.writer = None + self.writer_batch_size = None + self.data = None + self.cache_file_name = None + self.filelock = None + self.rendez_vous_lock = None + self.file_paths = None + self.filelocks = None + self._hash = hash + + def __len__(self): + return 0 if self.writer is None else len(self.writer) + + def __repr__(self): + return f'EvaluationModule(name: "{self.name}", module_type: "{self.module_type}", features: {self.features}, usage: """{self.inputs_description}""", stored examples: {len(self)})' + + def _build_data_dir(self): + builder_data_dir = self._data_dir_root + builder_data_dir = os.path.join(builder_data_dir, self.name, self.config_name) + os.makedirs(builder_data_dir, exist_ok=True) + return builder_data_dir + + def _create_cache_file(self, timeout=1) -> Tuple[str, FileLock]: + file_path = os.path.join(self.data_dir, f'{self.experiment_id}-{self.num_process}-{self.process_id}.arrow') + filelock = None + for i in range(self.max_concurrent_cache_files): + filelock = FileLock(file_path + '.lock') + try: + filelock.acquire(timeout=timeout) + except Timeout: + if self.num_process != 1: + raise ValueError(f'Error in _create_cache_file: another evaluation module instance is already using the local cache file at {file_path}. Please specify an experiment_id (currently: {self.experiment_id}) to avoid collision between distributed evaluation module instances.') from None + if i == self.max_concurrent_cache_files - 1: + raise ValueError(f'Cannot acquire lock, too many evaluation module instance are operating concurrently on this file system.You should set a larger value of max_concurrent_cache_files when creating the evaluation module (current value is {self.max_concurrent_cache_files}).') from None + file_uuid = str(uuid.uuid4()) + file_path = os.path.join(self.data_dir, f'{self.experiment_id}-{file_uuid}-{self.num_process}-{self.process_id}.arrow') + else: + break + return (file_path, filelock) + + def _get_all_cache_files(self) -> Tuple[List[str], List[FileLock]]: + if self.num_process == 1: + if self.cache_file_name is None: + raise ValueError("Evaluation module cache file doesn't exist. Please make sure that you call `add` or `add_batch` at least once before calling `compute`.") + file_paths = [self.cache_file_name] + else: + file_paths = [os.path.join(self.data_dir, f'{self.experiment_id}-{self.num_process}-{process_id}.arrow') for process_id in range(self.num_process)] + filelocks = [] + for (process_id, file_path) in enumerate(file_paths): + if process_id == 0: + filelocks.append(self.filelock) + else: + filelock = FileLock(file_path + '.lock') + try: + filelock.acquire(timeout=self.timeout) + except Timeout: + raise ValueError(f'Cannot acquire lock on cached file {file_path} for process {process_id}.') from None + else: + filelocks.append(filelock) + return (file_paths, filelocks) + + def _check_all_processes_locks(self): + expected_lock_file_names = [os.path.join(self.data_dir, f'{self.experiment_id}-{self.num_process}-{process_id}.arrow.lock') for process_id in range(self.num_process)] + for expected_lock_file_name in expected_lock_file_names: + nofilelock = FileFreeLock(expected_lock_file_name) + try: + nofilelock.acquire(timeout=self.timeout) + except Timeout: + raise ValueError(f"Expected to find locked file {expected_lock_file_name} from process {self.process_id} but it doesn't exist.") from None + else: + nofilelock.release() + + def _check_rendez_vous(self): + expected_lock_file_name = os.path.join(self.data_dir, f'{self.experiment_id}-{self.num_process}-0.arrow.lock') + nofilelock = FileFreeLock(expected_lock_file_name) + try: + nofilelock.acquire(timeout=self.timeout) + except Timeout: + raise ValueError(f"Expected to find locked file {expected_lock_file_name} from process {self.process_id} but it doesn't exist.") from None + else: + nofilelock.release() + lock_file_name = os.path.join(self.data_dir, f'{self.experiment_id}-{self.num_process}-rdv.lock') + rendez_vous_lock = FileLock(lock_file_name) + try: + rendez_vous_lock.acquire(timeout=self.timeout) + except Timeout: + raise ValueError(f"Couldn't acquire lock on {lock_file_name} from process {self.process_id}.") from None + else: + rendez_vous_lock.release() + + def _finalize(self): + if self.writer is not None: + self.writer.finalize() + self.writer = None + if self.filelock is not None and self.process_id > 0: + self.filelock.release() + if self.keep_in_memory: + reader = ArrowReader(path=self.data_dir, info=DatasetInfo(features=self.selected_feature_format)) + self.data = Dataset.from_buffer(self.buf_writer.getvalue()) + elif self.process_id == 0: + (file_paths, filelocks) = self._get_all_cache_files() + try: + reader = ArrowReader(path='', info=DatasetInfo(features=self.selected_feature_format)) + self.data = Dataset(**reader.read_files([{'filename': f} for f in file_paths])) + except FileNotFoundError: + raise ValueError('Error in finalize: another evaluation module instance is already using the local cache file. Please specify an experiment_id to avoid collision between distributed evaluation module instances.') from None + self.file_paths = file_paths + self.filelocks = filelocks + + def compute(self, *, predictions=None, references=None, **kwargs) -> Optional[dict]: + all_kwargs = {'predictions': predictions, 'references': references, **kwargs} + if predictions is None and references is None: + missing_kwargs = {k: None for k in self._feature_names() if k not in all_kwargs} + all_kwargs.update(missing_kwargs) + else: + missing_inputs = [k for k in self._feature_names() if k not in all_kwargs] + if missing_inputs: + raise ValueError(f'Evaluation module inputs are missing: {missing_inputs}. All required inputs are {list(self._feature_names())}') + inputs = {input_name: all_kwargs[input_name] for input_name in self._feature_names()} + compute_kwargs = {k: kwargs[k] for k in kwargs if k not in self._feature_names()} + if any((v is not None for v in inputs.values())): + self.add_batch(**inputs) + self._finalize() + self.cache_file_name = None + self.filelock = None + self.selected_feature_format = None + if self.process_id == 0: + self.data.set_format(type=self.info.format) + inputs = {input_name: self.data[input_name] for input_name in self._feature_names()} + with temp_seed(self.seed): + output = self._compute(**inputs, **compute_kwargs) + if self.buf_writer is not None: + self.buf_writer = None + del self.data + self.data = None + else: + for (filelock, file_path) in reversed(list(zip(self.filelocks, self.file_paths))): + logger.info(f'Removing {file_path}') + del self.data + self.data = None + del self.writer + self.writer = None + os.remove(file_path) + filelock.release() + return output + else: + return None + + def add_batch(self, *, predictions=None, references=None, **kwargs): + bad_inputs = [input_name for input_name in kwargs if input_name not in self._feature_names()] + if bad_inputs: + raise ValueError(f'Bad inputs for evaluation module: {bad_inputs}. All required inputs are {list(self._feature_names())}') + batch = {'predictions': predictions, 'references': references, **kwargs} + batch = {input_name: batch[input_name] for input_name in self._feature_names()} + if self.writer is None: + self.selected_feature_format = self._infer_feature_from_batch(batch) + self._init_writer() + try: + for (key, column) in batch.items(): + if len(column) > 0: + self._enforce_nested_string_type(self.selected_feature_format[key], column[0]) + batch = self.selected_feature_format.encode_batch(batch) + self.writer.write_batch(batch) + except (pa.ArrowInvalid, TypeError): + if any((len(batch[c]) != len(next(iter(batch.values()))) for c in batch)): + col0 = next(iter(batch)) + bad_col = [c for c in batch if len(batch[c]) != len(batch[col0])][0] + error_msg = f'Mismatch in the number of {col0} ({len(batch[col0])}) and {bad_col} ({len(batch[bad_col])})' + elif set(self.selected_feature_format) != {'references', 'predictions'}: + error_msg = f"Module inputs don't match the expected format.\nExpected format: {self.selected_feature_format},\n" + error_msg_inputs = ',\n'.join((f'Input {input_name}: {summarize_if_long_list(batch[input_name])}' for input_name in self.selected_feature_format)) + error_msg += error_msg_inputs + else: + error_msg = f"Predictions and/or references don't match the expected format.\nExpected format: {self.selected_feature_format},\nInput predictions: {summarize_if_long_list(predictions)},\nInput references: {summarize_if_long_list(references)}" + raise ValueError(error_msg) from None + + def add(self, *, prediction=None, reference=None, **kwargs): + bad_inputs = [input_name for input_name in kwargs if input_name not in self._feature_names()] + if bad_inputs: + raise ValueError(f'Bad inputs for evaluation module: {bad_inputs}. All required inputs are {list(self._feature_names())}') + example = {'predictions': prediction, 'references': reference, **kwargs} + example = {input_name: example[input_name] for input_name in self._feature_names()} + if self.writer is None: + self.selected_feature_format = self._infer_feature_from_example(example) + self._init_writer() + try: + self._enforce_nested_string_type(self.selected_feature_format, example) + example = self.selected_feature_format.encode_example(example) + self.writer.write(example) + except (pa.ArrowInvalid, TypeError): + error_msg = f"Evaluation module inputs don't match the expected format.\nExpected format: {self.selected_feature_format},\n" + error_msg_inputs = ',\n'.join((f'Input {input_name}: {summarize_if_long_list(example[input_name])}' for input_name in self.selected_feature_format)) + error_msg += error_msg_inputs + raise ValueError(error_msg) from None + + def _infer_feature_from_batch(self, batch): + if isinstance(self.features, Features): + return self.features + else: + example = dict([(k, v[0]) for (k, v) in batch.items()]) + return self._infer_feature_from_example(example) + + def _infer_feature_from_example(self, example): + if isinstance(self.features, Features): + return self.features + else: + for features in self.features: + try: + self._enforce_nested_string_type(features, example) + features.encode_example(example) + return features + except (ValueError, TypeError): + continue + feature_strings = '\n'.join([f'Feature option {i}: {feature}' for (i, feature) in enumerate(self.features)]) + error_msg = f"Predictions and/or references don't match the expected format.\nExpected format:\n{feature_strings},\nInput predictions: {summarize_if_long_list(example['predictions'])},\nInput references: {summarize_if_long_list(example['references'])}" + raise ValueError(error_msg) from None + + def _feature_names(self): + if isinstance(self.features, list): + feature_names = list(self.features[0].keys()) + else: + feature_names = list(self.features.keys()) + return feature_names + + def _init_writer(self, timeout=1): + if self.num_process > 1: + if self.process_id == 0: + file_path = os.path.join(self.data_dir, f'{self.experiment_id}-{self.num_process}-rdv.lock') + self.rendez_vous_lock = FileLock(file_path) + try: + self.rendez_vous_lock.acquire(timeout=timeout) + except TimeoutError: + raise ValueError(f'Error in _init_writer: another evalution module instance is already using the local cache file at {file_path}. Please specify an experiment_id (currently: {self.experiment_id}) to avoid collision between distributed evaluation module instances.') from None + if self.keep_in_memory: + self.buf_writer = pa.BufferOutputStream() + self.writer = ArrowWriter(features=self.selected_feature_format, stream=self.buf_writer, writer_batch_size=self.writer_batch_size) + else: + self.buf_writer = None + if self.cache_file_name is None or self.filelock is None: + (cache_file_name, filelock) = self._create_cache_file() + self.cache_file_name = cache_file_name + self.filelock = filelock + self.writer = ArrowWriter(features=self.selected_feature_format, path=self.cache_file_name, writer_batch_size=self.writer_batch_size) + if self.num_process > 1: + if self.process_id == 0: + self._check_all_processes_locks() + self.rendez_vous_lock.release() + else: + self._check_rendez_vous() + + def _info(self) -> EvaluationModuleInfo: + raise NotImplementedError + + def download_and_prepare(self, download_config: Optional[DownloadConfig]=None, dl_manager: Optional[DownloadManager]=None): + if dl_manager is None: + if download_config is None: + download_config = DownloadConfig() + download_config.cache_dir = os.path.join(self.data_dir, 'downloads') + download_config.force_download = False + dl_manager = DownloadManager(dataset_name=self.name, download_config=download_config, data_dir=self.data_dir) + self._download_and_prepare(dl_manager) + + def _download_and_prepare(self, dl_manager): + return None + + def _compute(self, *, predictions=None, references=None, **kwargs) -> Dict[str, Any]: + raise NotImplementedError + + def __del__(self): + if hasattr(self, 'filelock') and self.filelock is not None: + self.filelock.release() + if hasattr(self, 'rendez_vous_lock') and self.rendez_vous_lock is not None: + self.rendez_vous_lock.release() + if hasattr(self, 'writer'): + del self.writer + if hasattr(self, 'data'): + del self.data + + def _enforce_nested_string_type(self, schema, obj): + if isinstance(schema, dict): + return [self._enforce_nested_string_type(sub_schema, o) for (k, (sub_schema, o)) in zip_dict(schema, obj)] + elif isinstance(schema, (list, tuple)): + sub_schema = schema[0] + return [self._enforce_nested_string_type(sub_schema, o) for o in obj] + elif isinstance(schema, Sequence): + if isinstance(schema.feature, dict): + if isinstance(obj, (list, tuple)): + for (k, dict_tuples) in zip_dict(schema.feature, *obj): + for sub_obj in dict_tuples[1:]: + if _check_non_null_non_empty_recursive(sub_obj, dict_tuples[0]): + self._enforce_nested_string_type(dict_tuples[0], sub_obj) + break + return None + else: + for (k, (sub_schema, sub_objs)) in zip_dict(schema.feature, obj): + for sub_obj in sub_objs: + if _check_non_null_non_empty_recursive(sub_obj, sub_schema): + self._enforce_nested_string_type(sub_schema, sub_obj) + break + return None + if isinstance(obj, str): + raise ValueError(f"Got a string but expected a list instead: '{obj}'") + if obj is None: + return None + elif len(obj) > 0: + for first_elmt in obj: + if _check_non_null_non_empty_recursive(first_elmt, schema.feature): + break + if not isinstance(first_elmt, list): + return self._enforce_nested_string_type(schema.feature, first_elmt) + elif isinstance(schema, Value): + if pa.types.is_string(schema.pa_type) and (not isinstance(obj, str)): + raise TypeError(f'Expected type str but got {type(obj)}.') + +class Metric(EvaluationModule): + +class Comparison(EvaluationModule): + +class Measurement(EvaluationModule): + +class CombinedEvaluations: + + def __init__(self, evaluation_modules, force_prefix=False): + from .loading import load + self.evaluation_module_names = None + if isinstance(evaluation_modules, list): + self.evaluation_modules = evaluation_modules + elif isinstance(evaluation_modules, dict): + self.evaluation_modules = list(evaluation_modules.values()) + self.evaluation_module_names = list(evaluation_modules.keys()) + loaded_modules = [] + for module in self.evaluation_modules: + if isinstance(module, str): + module = load(module) + loaded_modules.append(module) + self.evaluation_modules = loaded_modules + if self.evaluation_module_names is None: + self.evaluation_module_names = [module.name for module in self.evaluation_modules] + self.force_prefix = force_prefix + + def add(self, prediction=None, reference=None, **kwargs): + for evaluation_module in self.evaluation_modules: + batch = {'predictions': prediction, 'references': reference, **kwargs} + batch = {input_name: batch[input_name] for input_name in evaluation_module._feature_names()} + evaluation_module.add(**batch) + + def add_batch(self, predictions=None, references=None, **kwargs): + for evaluation_module in self.evaluation_modules: + batch = {'predictions': predictions, 'references': references, **kwargs} + batch = {input_name: batch[input_name] for input_name in evaluation_module._feature_names()} + evaluation_module.add_batch(**batch) + + def compute(self, predictions=None, references=None, **kwargs): + results = [] + for evaluation_module in self.evaluation_modules: + batch = {'predictions': predictions, 'references': references, **kwargs} + results.append(evaluation_module.compute(**batch)) + return self._merge_results(results) + + def _merge_results(self, results): + merged_results = {} + results_keys = list(itertools.chain.from_iterable([r.keys() for r in results])) + duplicate_keys = {item for (item, count) in collections.Counter(results_keys).items() if count > 1} + duplicate_names = [item for (item, count) in collections.Counter(self.evaluation_module_names).items() if count > 1] + duplicate_counter = {name: 0 for name in duplicate_names} + for (module_name, result) in zip(self.evaluation_module_names, results): + for (k, v) in result.items(): + if k not in duplicate_keys and (not self.force_prefix): + merged_results[f'{k}'] = v + elif module_name in duplicate_counter: + merged_results[f'{module_name}_{duplicate_counter[module_name]}_{k}'] = v + else: + merged_results[f'{module_name}_{k}'] = v + if module_name in duplicate_counter: + duplicate_counter[module_name] += 1 + return merged_results + +def combine(evaluations, force_prefix=False): + return CombinedEvaluations(evaluations, force_prefix=force_prefix) + +# File: evaluate-main/src/evaluate/naming.py +"""""" +import itertools +import os +import re +_uppercase_uppercase_re = re.compile('([A-Z]+)([A-Z][a-z])') +_lowercase_uppercase_re = re.compile('([a-z\\d])([A-Z])') +_single_underscore_re = re.compile('(? 0 + if is_file: + folder = path_or_file.parent + file_name = path_or_file.name + else: + folder = path_or_file + file_name = 'result-' + current_time.strftime('%Y_%m_%d-%H_%M_%S') + '.json' + folder.mkdir(parents=True, exist_ok=True) + return folder / file_name + +def _git_commit_hash(): + res = subprocess.run('git rev-parse --is-inside-work-tree'.split(), cwd='./', stdout=subprocess.PIPE) + if res.stdout.decode().strip() == 'true': + res = subprocess.run('git rev-parse HEAD'.split(), cwd=os.getcwd(), stdout=subprocess.PIPE) + return res.stdout.decode().strip() + else: + return None + +# File: evaluate-main/src/evaluate/visualization.py +import textwrap +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd + +class ComplexRadar: + + def __init__(self, fig, variables, ranges, n_ring_levels=5, show_scales=True, format_cfg=None): + self.format_cfg = format_cfg + angles = np.arange(0, 360, 360.0 / len(variables)) + axes = [fig.add_axes([0.1, 0.1, 0.9, 0.9], polar=True, label='axes{}'.format(i), **self.format_cfg['axes_args']) for i in range(len(variables) + 1)] + for ax in axes: + ax.set_theta_zero_location('N') + ax.set_theta_direction(-1) + ax.set_axisbelow(True) + for (i, ax) in enumerate(axes): + j = 0 if i == 0 or i == 1 else i - 1 + ax.set_ylim(*ranges[j]) + grid = np.linspace(*ranges[j], num=n_ring_levels, endpoint=self.format_cfg['incl_endpoint']) + gridlabel = ['{}'.format(round(x, 2)) for x in grid] + gridlabel[0] = '' + (lines, labels) = ax.set_rgrids(grid, labels=gridlabel, angle=angles[j], **self.format_cfg['rgrid_tick_lbls_args']) + ax.set_ylim(*ranges[j]) + ax.spines['polar'].set_visible(False) + ax.grid(visible=False) + if show_scales is False: + ax.set_yticklabels([]) + for ax in axes[1:]: + ax.patch.set_visible(False) + ax.xaxis.set_visible(False) + self.angle = np.deg2rad(np.r_[angles, angles[0]]) + self.ranges = ranges + self.ax = axes[0] + self.ax1 = axes[1] + self.plot_counter = 0 + self.ax.yaxis.grid(**self.format_cfg['rad_ln_args']) + self.ax.spines['polar'].set(**self.format_cfg['outer_ring']) + self.ax.xaxis.grid(**self.format_cfg['angle_ln_args']) + self.ax1.axis('off') + self.ax1.set_zorder(9) + (l, text) = self.ax.set_thetagrids(angles, labels=variables) + labels = [t.get_text() for t in self.ax.get_xticklabels()] + labels = ['\n'.join(textwrap.wrap(label, self.format_cfg['theta_tick_lbls_txt_wrap'], break_long_words=self.format_cfg['theta_tick_lbls_brk_lng_wrds'])) for label in labels] + self.ax.set_xticklabels(labels, **self.format_cfg['theta_tick_lbls']) + for (t, a) in zip(self.ax.get_xticklabels(), angles): + if a == 0: + t.set_ha('center') + elif a > 0 and a < 180: + t.set_ha('left') + elif a == 180: + t.set_ha('center') + else: + t.set_ha('right') + self.ax.tick_params(axis='both', pad=self.format_cfg['theta_tick_lbls_pad']) + + def _scale_data(self, data, ranges): + for (d, (y1, y2)) in zip(data[1:], ranges[1:]): + assert y1 <= d <= y2 or y2 <= d <= y1 + (x1, x2) = ranges[0] + d = data[0] + sdata = [d] + for (d, (y1, y2)) in zip(data[1:], ranges[1:]): + sdata.append((d - y1) / (y2 - y1) * (x2 - x1) + x1) + return sdata + + def plot(self, data, *args, **kwargs): + sdata = self._scale_data(data, self.ranges) + self.ax1.plot(self.angle, np.r_[sdata, sdata[0]], *args, **kwargs) + self.plot_counter = self.plot_counter + 1 + + def use_legend(self, *args, **kwargs): + self.ax1.legend(*args, **kwargs) + +def radar_plot(data, model_names, invert_range=[], config=None, fig=None): + data = pd.DataFrame(data) + data.index = model_names + variables = data.keys() + if all((x in variables for x in invert_range)) is False: + raise ValueError('All of the metrics in `invert_range` should be in the data provided.') + min_max_per_variable = data.describe().T[['min', 'max']] + min_max_per_variable['min'] = min_max_per_variable['min'] - 0.1 * (min_max_per_variable['max'] - min_max_per_variable['min']) + min_max_per_variable['max'] = min_max_per_variable['max'] + 0.1 * (min_max_per_variable['max'] - min_max_per_variable['min']) + ranges = list(min_max_per_variable.itertuples(index=False, name=None)) + ranges = [(max_value, min_value) if var in invert_range else (min_value, max_value) for (var, (min_value, max_value)) in zip(variables, ranges)] + format_cfg = {'axes_args': {}, 'rad_ln_args': {'visible': True}, 'outer_ring': {'visible': True}, 'angle_ln_args': {'visible': True}, 'rgrid_tick_lbls_args': {'fontsize': 12}, 'theta_tick_lbls': {'fontsize': 12}, 'theta_tick_lbls_pad': 3, 'theta_tick_lbls_brk_lng_wrds': True, 'theta_tick_lbls_txt_wrap': 15, 'incl_endpoint': False, 'marker': 'o', 'markersize': 3, 'legend_loc': 'upper right', 'bbox_to_anchor': (2, 1)} + if config is not None: + format_cfg.update(config) + if fig is None: + fig = plt.figure() + radar = ComplexRadar(fig, variables, ranges, n_ring_levels=3, show_scales=True, format_cfg=format_cfg) + for g in zip(data.index): + radar.plot(data.loc[g].values, label=g, marker=format_cfg['marker'], markersize=format_cfg['markersize']) + radar.use_legend(**{'loc': format_cfg['legend_loc'], 'bbox_to_anchor': format_cfg['bbox_to_anchor']}) + return fig +