add metrics

metrics/bart_score.py

@@ -0,0 +1,45 @@
+import os
+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 = scorer.score(predictions, references, batch_size=4)
+    recalls = scorer.score(references, predictions, batch_size=4)
+    f_scores = 0.5 * (precisions + recalls)
+
+    return [
+        {
+            f"{scorer_name}_f_score": f_scores[i],
+            f"{scorer_name}_precision": precisions[i],
+            f"{scorer_name}_recall": recalls[i],
+        }
+        for i in len(range(predictions))
+    ]
+
+
+def compute_bart_score(predictions, references, scorers):
+    result = [{} for _ in len(range(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

@@ -107,4 +107,16 @@ def compute_bleu(reference_corpus, translation_corpus, max_order=4, smooth=False
 
     bleu = geo_mean * bp
 
-    return (bleu, precisions, bp, ratio, translation_length, reference_length)
+    return {
+        "bleu": bleu,
+        **{f"precision-{i+1}": round(p, 4) for i, p in enumerate(precisions)},
+        "brevity_penalty": bp,
+        "length_ratio": ratio,
+        "translation_length": translation_length,
+        "reference_length": reference_length,
+    }
+
+
+def bleu_postprocess_text(text):
+    # TODO: Tokenize properly
+    return text.split()

metrics/exact_match.py

@@ -0,0 +1,40 @@
+import re
+import string
+
+
+def normalize_answer(s):
+    """Lower text and remove punctuation, articles and extra whitespace."""
+
+    def remove_articles(text):
+        return re.sub(r"\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 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_exact_match(predictions, references):
+    exact_match = 0
+    for prediction, ground_truths in zip(predictions, references):
+        exact_match += metric_max_over_ground_truths(exact_match_score, prediction, ground_truths)
+    return 100.0 * exact_match / len(predictions)

metrics/f1.py

@@ -0,0 +1,56 @@
+# Copied from https://github.com/huggingface/datasets/blob/d3c7b9481d427ce41256edaf6773c47570f06f3b/metrics/squad/evaluate.py
+
+import re
+import string
+from collections import Counter
+
+
+def normalize_answer(s):
+    """Lower text and remove punctuation, articles and extra whitespace."""
+
+    def remove_articles(text):
+        return re.sub(r"\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_f1(predictions, references):
+    f1 = 0
+    for prediction, ground_truths in zip(predictions, references):
+        f1 += metric_max_over_ground_truths(f1_score, prediction, ground_truths)
+    return 100.0 * f1 / len(predictions)

metrics/rouge.py

@@ -4,24 +4,24 @@ import nltk
 from rouge_score import rouge_scorer, scoring
 
 
-def compute_rouge(predictions, references, rouge_types=None, use_agregator=True, use_stemmer=False):
+def compute_rouge(predictions, references, rouge_types=None, use_aggregator=True, use_stemmer=False):
     if rouge_types is None:
         rouge_types = ["rouge1", "rouge2", "rougeL", "rougeLsum"]
 
     scorer = rouge_scorer.RougeScorer(rouge_types=rouge_types, use_stemmer=use_stemmer)
-    if use_agregator:
+    if use_aggregator:
         aggregator = scoring.BootstrapAggregator()
     else:
         scores = []
 
     for ref, pred in zip(references, predictions):
         score = scorer.score(ref, pred)
-        if use_agregator:
+        if use_aggregator:
             aggregator.add_scores(score)
         else:
             scores.append(score)
 
-    if use_agregator:
+    if use_aggregator:
         result = aggregator.aggregate()
     else:
         result = {}
@@ -33,7 +33,6 @@ def compute_rouge(predictions, references, rouge_types=None, use_agregator=True,
 
 # TODO: Check if it is necessary
 # Copied from https://github.com/huggingface/transformers/blob/3977b58437b8ce1ea1da6e31747d888efec2419b/examples/pytorch/summarization/run_summarization.py#L520
-def rouge_postprocess_text(texts):
+def rouge_postprocess_text(text):
     # rougeLSum expects newline after each sentence
-    texts = ["\n".join(nltk.sent_tokenize(text)) for text in texts]
-    return texts
+    return "\n".join(nltk.sent_tokenize(text))