remove unused metrics

metrics/bart_score.py

@@ -1,53 +0,0 @@
-import os
-import numpy as np
-from BARTScore.bart_score import BARTScorer
-
-
-def get_scorers():
-    assert os.path.isfile(
-        os.path.join("BARTScore", "bart.pth")
-    ), "You must download `bart.pth` to use BARTScore.\nUse `gdown --id 1_7JfF7KOInb7ZrxKHIigTMR4ChVET01m --output bart.pth`"
-
-    scorers = {}
-
-    scorers["vanilla"] = BARTScorer(device="cuda:0", checkpoint="facebook/bart-large")
-
-    scorers["cnn"] = BARTScorer(device="cuda:0", checkpoint="facebook/bart-large-cnn")
-
-    # for the parabank model, first init a bart model, then load the local para model from BARTScore/bart.pth
-    # see the documentation from https://github.com/neulab/BARTScore for reference
-    scorers["para"] = BARTScorer(device="cuda:0", checkpoint="facebook/bart-large-cnn")
-    scorers["para"].load(path="BARTScore/bart.pth")
-
-    return scorers
-
-
-def compute_bart_score_for_scorer(predictions, references, scorer_name, scorer):
-    #precisions = np.array(scorer.score(references, predictions, batch_size=4))
-    recalls = np.array(scorer.score(predictions, references, batch_size=4))
-    #f_scores = 0.5 * (precisions + recalls)
-    baselines = np.array(scorer.score(references, references, batch_size=4))
-    normalized = baselines / recalls
-    diffs = recalls - baselines
-    expdiffs = np.exp(diffs)
-
-    return [
-        {
-            #f"{scorer_name}_f_score": f_scores[i],
-            #f"{scorer_name}_precision": precisions[i],
-            f"{scorer_name}_recall": recalls[i],
-            f"{scorer_name}_normalized": normalized[i],
-            f"{scorer_name}_diffs": diffs[i],
-            f"{scorer_name}_expdiffs": expdiffs[i],
-        }
-        for i in range(len(predictions))
-    ]
-
-
-def compute_bart_score(predictions, references, scorers):
-    result = [{} for _ in range(len(predictions))]
-    for scorer_name, scorer in scorers.items():
-        scorer_result = compute_bart_score_for_scorer(predictions, references, scorer_name, scorer)
-        for i, element in enumerate(scorer_result):
-            result[i].update(element)
-    return result

metrics/bleu.py

@@ -1,47 +0,0 @@
-# Copied from https://github.com/huggingface/datasets/blob/76bb45964df1e62d1411b0a9e9fc673e9a791c9a/metrics/sacrebleu/sacrebleu.py
-
-from copy import deepcopy
-from sacrebleu.metrics import BLEU
-
-
-def compute_bleu(
-    predictions,
-    references,
-    smooth_method="exp",
-    smooth_value=None,
-    force=False,
-    lowercase=False,
-    tokenize=None,
-    effective_order=False,
-):
-    references_per_prediction = len(references[0])
-    if any(len(refs) != references_per_prediction for refs in references):
-        references = deepcopy(references)
-        max_references_per_prediction = max(len(refs) for refs in references)
-        for refs in references:
-            refs.extend([None] * (max_references_per_prediction - len(refs)))
-
-    transformed_references = [[refs[i] for refs in references] for i in range(references_per_prediction)]
-
-    bleu = BLEU(
-        smooth_method=smooth_method,
-        smooth_value=smooth_value,
-        force=force,
-        lowercase=lowercase,
-        effective_order=effective_order,
-        **(dict(tokenize=tokenize) if tokenize else {}),
-    )
-    output = bleu.corpus_score(
-        predictions,
-        transformed_references,
-    )
-    output_dict = {
-        "score": output.score,
-        **{f"counts-{i+1}": round(p, 4) for i, p in enumerate(output.counts)},
-        **{f"totals-{i+1}": round(p, 4) for i, p in enumerate(output.totals)},
-        **{f"precision-{i+1}": round(p, 4) for i, p in enumerate(output.precisions)},
-        "bp": output.bp,
-        "sys_len": output.sys_len,
-        "ref_len": output.ref_len,
-    }
-    return output_dict