Update metrics/bart_score.py

metrics/bart_score.py

@@ -1,137 +1,46 @@
 import os
 import numpy as np
 from BARTScore.bart_score import BARTScorer
-from src.metrics import Metric
-import logging
-from tqdm import tqdm
 
-logger = logging.getLogger(__name__)
 
+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`"
 
-class BartScore(Metric):
-    """
-    The BARTScore metric, based on the example from https://github.com/neulab/BARTScore
-    """
+    scorers = {}
 
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
+    scorers["vanilla"] = BARTScorer(device="cuda:0", checkpoint="facebook/bart-large")
 
-        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["cnn"] = BARTScorer(device="cuda:0", checkpoint="facebook/bart-large-cnn")
 
-        # we use 3 bart scorers: the vanilla, cnn, and para variants
-        self.bart_scorers_initializers = {
-            "vanilla": self.get_vanilla_scorer,
-            "cnn": self.get_cnn_scorer,
-            "para": self.get_para_scorer,
-        }
-        self.requires_decoded = True
-
-    @staticmethod
-    def get_vanilla_scorer():
-        """
-        returns the the vanilla bart scorer
-        """
-        bart_scorer = BARTScorer(device="cuda:0", checkpoint="facebook/bart-large")
-        return bart_scorer
-
-    @staticmethod
-    def get_cnn_scorer():
-        """
-        returns the the cnn version of bart sore
-        """
-        bart_scorer = BARTScorer(device="cuda:0", checkpoint="facebook/bart-large-cnn")
-        return bart_scorer
-
-    @staticmethod
-    def get_para_scorer():
-        """
-        returns the parabank version of bart score
-        """
-        # 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
-        bart_scorer = BARTScorer(device="cuda:0", checkpoint="facebook/bart-large-cnn")
-        bart_scorer.load(path="BARTScore/bart.pth")
-        return bart_scorer
-
-    def calc_bart_score(self, scorer, prediction, gold_labels):
-        """
-        calculate the bart score for a prediction given the gold labels for a specific scorer
-        """
-
-        # num_gold_labels
-        num_gold_labels = len(gold_labels)
-
-        # ref to hypo scores are the precision
-        ref_hypo_scores = np.array(scorer.score(gold_labels, [prediction] * num_gold_labels, batch_size=4))
-
-        # hypo to ref scores are the recall
-        hypo_ref_scores = np.array(scorer.score([prediction] * num_gold_labels, gold_labels, batch_size=4))
-
-        # take max and average
-        max_avg_f = (0.5 * (ref_hypo_scores + hypo_ref_scores)).max()
-        hypo_ref = hypo_ref_scores.max()
-        ref_hypo = ref_hypo_scores.max()
-
-        return {"f_score": max_avg_f, "precision": ref_hypo, "recall": hypo_ref}
-
-    def _compute_metrics(self, id_to_pred, id_to_labels):
+    # 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")
 
-        # init results dict
-        result = {}
+    return scorers
 
-        # iterate scorers
-        for scorer_name, scorer_getter in self.bart_scorers_initializers.items():
-            scorer = scorer_getter()
 
-            # calculate BARTScores
-            logger.info(f"Calculating {scorer_name} BART scores...")
+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)
 
-            # init bart_scores list
-            num_missing_predictions = 0
-            bart_scores = []
-
-            # iterate question ids
-            for question_id, question_gold_labels in tqdm(id_to_labels.items()):
-
-                # check if there was a prediction to the question
-                if question_id not in id_to_pred:
-                    num_missing_predictions += 1
-                    bart_scores.append(0.0)
-                    continue
-
-                # get pred
-                pred = id_to_pred[question_id]
-
-                # calculate bart scores
-                bart_scores.append(
-                    self.calc_bart_score(scorer=scorer, prediction=pred, gold_labels=question_gold_labels)
-                )
-
-            # Aggregate scorer metrics
-            bart_score_f = np.mean([score["f_score"] for score in bart_scores])
-            bart_score_precision = np.mean([score["precision"] for score in bart_scores])
-            bart_score_recall = np.mean([score["recall"] for score in bart_scores])
-
-            # scorer_results
-            scorer_result = {
-                f"{scorer_name}_BARTScore_f": bart_score_f,
-                f"{scorer_name}_BARTScore_precision": bart_score_precision,
-                f"{scorer_name}_BARTScore_recall": bart_score_recall,
-            }
-
-            logger.info(scorer_name)
-            logger.info(scorer_result)
-
-            # union results
-            result = {**result, **scorer_result}
-
-        # add results metadata
-        result["num_missing_predictions"] = num_missing_predictions
+    return [
+        {
+            f"{scorer_name}_f_score": f_scores[i],
+            f"{scorer_name}_precision": precisions[i],
+            f"{scorer_name}_recall": recalls[i],
+        }
+        for i in range(len(predictions))
+    ]
 
-        result = {k: round(v, 4) for k, v in result.items()}
 
-        logger.info("### Bart scores: ###")
-        logger.info(result)
-        return result
+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