# 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('<skipped>', '')
        line = line.replace('-\n', '')
        line = line.replace('\n', ' ')
        if '&' in line:
            line = line.replace('&quot;', '"')
            line = line.replace('&amp;', '&')
            line = line.replace('&lt;', '<')
            line = line.replace('&gt;', '>')
        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('<skipped>', '')
        line = line.replace('-\n', '')
        line = line.replace('\n', ' ')
        if '&' in line:
            line = line.replace('&quot;', '"')
            line = line.replace('&amp;', '&')
            line = line.replace('&lt;', '<')
            line = line.replace('&gt;', '>')
        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 <command> [<args>]')
    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    <Tip>\n\n    Remember that, in order to process audio files, you need ffmpeg installed (https://ffmpeg.org/download.html)\n\n    </Tip>\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    <Tip>\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    </Tip>\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    <Tip>\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    </Tip>\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    <Tip>\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    </Tip>\n\n    <Tip warning={true}>\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    </Tip>\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('(?<!_)_(?!_)')
_multiple_underscores_re = re.compile('(_{2,})')
_split_re = '^\\w+(\\.\\w+)*$'

def camelcase_to_snakecase(name):
    name = _uppercase_uppercase_re.sub('\\1_\\2', name)
    name = _lowercase_uppercase_re.sub('\\1_\\2', name)
    return name.lower()

def snakecase_to_camelcase(name):
    name = _single_underscore_re.split(name)
    name = [_multiple_underscores_re.split(n) for n in name]
    return ''.join((n.capitalize() for n in itertools.chain.from_iterable(name) if n != ''))

def filename_prefix_for_name(name):
    if os.path.basename(name) != name:
        raise ValueError(f'Should be a dataset name, not a path: {name}')
    return camelcase_to_snakecase(name)

def filename_prefix_for_split(name, split):
    if os.path.basename(name) != name:
        raise ValueError(f'Should be a dataset name, not a path: {name}')
    if not re.match(_split_re, split):
        raise ValueError(f"Split name should match '{_split_re}'' but got '{split}'.")
    return f'{filename_prefix_for_name(name)}-{split}'

def filepattern_for_dataset_split(dataset_name, split, data_dir, filetype_suffix=None):
    prefix = filename_prefix_for_split(dataset_name, split)
    if filetype_suffix:
        prefix += f'.{filetype_suffix}'
    filepath = os.path.join(data_dir, prefix)
    return f'{filepath}*'

def filename_for_dataset_split(dataset_name, split, filetype_suffix=None):
    prefix = filename_prefix_for_split(dataset_name, split)
    if filetype_suffix:
        prefix += f'.{filetype_suffix}'
    return prefix

def filepath_for_dataset_split(dataset_name, split, data_dir, filetype_suffix=None):
    filename = filename_for_dataset_split(dataset_name=dataset_name, split=split, filetype_suffix=filetype_suffix)
    filepath = os.path.join(data_dir, filename)
    return filepath

# File: evaluate-main/src/evaluate/saving.py
import json
import os
import subprocess
import sys
from datetime import datetime
from pathlib import Path
from datasets.utils.filelock import FileLock
from . import __version__

def save(path_or_file, **data):
    current_time = datetime.now()
    file_path = _setup_path(path_or_file, current_time)
    data['_timestamp'] = current_time.isoformat()
    data['_git_commit_hash'] = _git_commit_hash()
    data['_evaluate_version'] = __version__
    data['_python_version'] = sys.version
    data['_interpreter_path'] = sys.executable
    with FileLock(str(file_path) + '.lock'):
        with open(file_path, 'w') as f:
            json.dump(data, f)
    try:
        os.remove(str(file_path) + '.lock')
    except FileNotFoundError:
        pass
    return file_path

def _setup_path(path_or_file, current_time):
    path_or_file = Path(path_or_file)
    is_file = len(path_or_file.suffix) > 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