metrics/scrolls.py

""" SCROLLS benchmark metric. """

from collections import defaultdict
from copy import deepcopy
import datasets

# fmt: off
from .rouge import compute_rouge, postprocess_text as rouge_postprocess_text  # From: https://huggingface.co/datasets/tau/scrolls/raw/main/metrics/rouge.py
from .exact_match import compute_exact_match  # From: https://huggingface.co/datasets/tau/scrolls/raw/main/metrics/exact_match.py
from .f1 import compute_f1  # From: https://huggingface.co/datasets/tau/scrolls/raw/main/metrics/f1.py
# fmt: on

_CITATION = """\
# TODO: Add citation
"""

_DESCRIPTION = """\
SCROLLS: Standardized CompaRison Over Long Language Sequences.
A suite of natural language datasets that require reasoning over long texts.
https://scrolls-benchmark.com/
"""

_KWARGS_DESCRIPTION = """
Compute Scrolls evaluation metric associated to each Scrolls dataset.
Args:
    predictions: list of predictions to score.
        Each prediction should be a string.
    references: list of lists of references for each example.
        Each reference should be a string.
Returns: depending on the Scrolls subset, one or several of:
    "exact_match": Exact Match score
    "f1": F1 score
    "rouge": ROUGE score
Examples:
    predictions = ["exact match example", "hello there", "general kenobi"]  # List[str]
    references = [["exact match example"], ["hello", "hi there"], ["commander kenobi"]]  # List[List[str]]

    >>> scrolls_metric = datasets.load_metric('src/metrics/scrolls.py', 'gov_report')  # 'gov_report' or any of ["qmsum", "summ_screen_fd"]
    >>> results = scrolls_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'rouge/rouge1': 72.2222, 'rouge/rouge2': 33.3333, 'rouge/rougeL': 72.2222, 'rouge/rougeLsum': 72.2222, 'rouge/geometric_mean': 55.8136, 'num_predicted': 3, 'mean_prediction_length_characters': 14.6667}

    >>> scrolls_metric = datasets.load_metric('src/metrics/scrolls.py', 'contract_nli')  # 'contract_nli' or any of ["quality", "quality_hard"]
    >>> results = scrolls_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'exact_match': 33.3333, 'num_predicted': 3, 'mean_prediction_length_characters': 14.6667}

    >>> scrolls_metric = datasets.load_metric('src/metrics/scrolls.py', 'narrative_qa')  # 'narrative_qa' or any of ["qasper"]
    >>> results = scrolls_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'f1': 72.2222, 'num_predicted': 3, 'mean_prediction_length_characters': 14.6667}
"""

DATASET_TO_METRICS = {
    "contract_nli": {
        "metrics_to_compute": ["exact_match"],
        "scrolls_score_key": "exact_match",
        "display_keys": ["exact_match"],
    },
    "gov_report": {
        "metrics_to_compute": ["rouge"],
        "scrolls_score_key": "rouge/geometric_mean",
        "display_keys": ["rouge/rouge1", "rouge/rouge2", "rouge/rougeL"],
    },
    "narrative_qa": {
        "metrics_to_compute": ["f1"],
        "scrolls_score_key": "f1",
        "display_keys": ["f1"],
    },
    "qasper": {
        "metrics_to_compute": ["f1"],
        "scrolls_score_key": "f1",
        "display_keys": ["f1"],
    },
    "qmsum": {
        "metrics_to_compute": ["rouge"],
        "scrolls_score_key": "rouge/geometric_mean",
        "display_keys": ["rouge/rouge1", "rouge/rouge2", "rouge/rougeL"],
    },
    "summ_screen_fd": {
        "metrics_to_compute": ["rouge"],
        "scrolls_score_key": "rouge/geometric_mean",
        "display_keys": ["rouge/rouge1", "rouge/rouge2", "rouge/rougeL"],
    },
    "quality": {
        "metrics_to_compute": ["exact_match"],
        "scrolls_score_key": "exact_match",
        "display_keys": ["exact_match"],
    },
    "quality_hard": {
        "metrics_to_compute": ["exact_match"],
        "scrolls_score_key": None,
        "display_keys": ["exact_match"],
    },
}


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
class Scrolls(datasets.Metric):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self._compute_helper_kwargs_fn = {
            "rouge": lambda: {
                "metric_fn": compute_rouge,
                "agg_fn": max,
                "metric_fn_kwargs": {"use_stemmer": False},
                "metric_returns_per_example": True,
                "transform_single_input_fn": lambda text: rouge_postprocess_text(text),
                "transform_result_fn": lambda output: {
                    key: (value[0] if isinstance(value, list) else value).fmeasure * 100
                    for key, value in output.items()
                },
                "transform_aggregated_result_fn": lambda output: output.update(
                    {"geometric_mean": (output["rouge1"] * output["rouge2"] * output["rougeL"]) ** (1.0 / 3.0)}
                )
                or output,
            },
            "exact_match": lambda: {
                "metric_fn": compute_exact_match,
                "agg_fn": None,  # compute_exact_match already takes max
                "transform_result_fn": lambda output: {None: output},
            },
            "f1": lambda: {
                "metric_fn": compute_f1,
                "agg_fn": None,  # compute_f1 already takes max
                "transform_result_fn": lambda output: {None: output},
            },
        }

        custom_metrics = (
            [metric for metric in self.config_name.split(",") if len(metric) > 0]
            if self.config_name.startswith(",")
            else None
        )
        if custom_metrics is not None:
            for metric in custom_metrics:
                if metric not in self._compute_helper_kwargs_fn:
                    raise KeyError(
                        f"You should supply a metric name selected in {list(self._compute_helper_kwargs_fn.keys())}"
                    )
            self._metrics_to_compute = custom_metrics
        else:
            if self.config_name not in DATASET_TO_METRICS:
                raise KeyError(f"You should supply a configuration name selected in {list(DATASET_TO_METRICS.keys())}")
            self._metrics_to_compute = DATASET_TO_METRICS[self.config_name]["metrics_to_compute"]

    def _info(self):
        return datasets.MetricInfo(
            description=_DESCRIPTION,
            citation=_CITATION,
            inputs_description=_KWARGS_DESCRIPTION,
            features=datasets.Features(
                {
                    "predictions": datasets.Value("string"),
                    "references": datasets.Sequence(datasets.Value("string")),
                }
            ),
            codebase_urls=[],
            reference_urls=[],
        )

    def convert_from_map_format(self, id_to_pred, id_to_labels):
        index_to_id = list(id_to_pred.keys())
        predictions = [id_to_pred[id_] for id_ in index_to_id]
        references = [id_to_labels[id_] for id_ in index_to_id]
        return {"predictions": predictions, "references": references}

    def _compute(self, predictions, references):
        metrics = {}
        for metric in self._metrics_to_compute:
            result = _compute_helper(
                deepcopy(predictions),
                deepcopy(references),
                **self._compute_helper_kwargs_fn[metric](),
            )
            metrics.update(
                {(f"{metric}/{key}" if key is not None else metric): value for key, value in result.items()}
            )
        metrics["num_predicted"] = len(predictions)
        prediction_lengths = [len(prediction) for prediction in predictions]
        metrics["mean_prediction_length_characters"] = sum(prediction_lengths) / len(prediction_lengths)

        metrics = {key: round(value, 4) for key, value in metrics.items()}

        if self.config_name in DATASET_TO_METRICS:
            scrolls_score_key = DATASET_TO_METRICS[self.config_name]["scrolls_score_key"]
            if scrolls_score_key is not None:
                metrics["scrolls_score"] = metrics[scrolls_score_key]
            else:
                metrics["scrolls_score"] = None

            display_keys = DATASET_TO_METRICS[self.config_name]["display_keys"]
            metrics["display_keys"] = display_keys
            metrics["display"] = []
            for display_key in display_keys:
                metrics["display"].append(metrics[display_key])

        return metrics


def _compute_helper(
    predictions,
    references,
    metric_fn,
    agg_fn,
    metric_fn_kwargs=None,
    transform_single_input_fn=None,
    transform_result_fn=None,
    transform_aggregated_result_fn=None,
    metric_returns_per_example=False,
):
    if metric_fn_kwargs is None:
        metric_fn_kwargs = {}

    if agg_fn is None:
        assert metric_returns_per_example is False

    if transform_single_input_fn is not None:
        predictions = [transform_single_input_fn(prediction) for prediction in predictions]
        references = [
            [transform_single_input_fn(reference) for reference in reference_list] for reference_list in references
        ]

    if transform_result_fn is None:
        transform_result_fn = lambda x: x
        do_transform_result = False
    else:
        do_transform_result = True

    if transform_aggregated_result_fn is None:
        transform_aggregated_result_fn = lambda x: x

    if agg_fn is not None:
        # Required when the metric doesn't do the aggregation we need
        scores = defaultdict(list)
        if metric_returns_per_example is False:
            # If when given a list of prediction and references the metric returns an aggregated score,
            # we need to compute the metric for each prediction and reference and then aggregate the results.
            # This is only an issue when we want to get the best aggregated score (e.g. max) for prediction
            # with multiple references.
            for prediction, reference_list in zip(predictions, references):
                prediction_scores = defaultdict(list)
                for reference in reference_list:
                    result = transform_result_fn(metric_fn([prediction], [reference], **metric_fn_kwargs))
                    for key in result:
                        prediction_scores[key].append(result[key])
                for key in prediction_scores:
                    scores[key].append(agg_fn(prediction_scores[key]))
        else:
            # Flatten the references and then aggregate per prediction with agg_fn
            mapping = [[] for _ in range(len(predictions))]
            flattened_predictions = []
            flattened_references = []
            for i, prediction in enumerate(predictions):
                for reference in references[i]:
                    flattened_predictions.append(prediction)
                    flattened_references.append(reference)
                    mapping[i].append(len(flattened_references) - 1)

            results = metric_fn(flattened_predictions, flattened_references, **metric_fn_kwargs)
            if isinstance(results, dict):
                # Convert a dictionary with lists per key to a list with dictionary with the same keys per element
                results_list = [{k: None for k in results} for _ in range(len(flattened_predictions))]
                for k, v in results.items():
                    for i in range(len(v)):
                        results_list[i][k] = v[i]
            else:
                results_list = results

            if do_transform_result:
                for i in range(len(results_list)):
                    results_list[i] = transform_result_fn(results_list[i])

            for reference_indexes in mapping:
                prediction_scores = defaultdict(list)
                for reference_index in reference_indexes:
                    result = results_list[reference_index]
                    for key in result:
                        prediction_scores[key].append(result[key])
                for key in prediction_scores:
                    scores[key].append(agg_fn(prediction_scores[key]))

        return transform_aggregated_result_fn({key: sum(value) / len(value) for key, value in scores.items()})
    else:
        return transform_aggregated_result_fn(
            transform_result_fn(metric_fn(predictions, references, **metric_fn_kwargs))
        )