""" Zero-zero_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/zero_scrolls/raw/main/metrics/rouge.py from .accuracy import compute_accuracy # From: https://huggingface.co/datasets/tau/zero_scrolls/raw/main/metrics/accuracy.py from .f1 import compute_f1 # From: https://huggingface.co/datasets/tau/zero_scrolls/raw/main/metrics/f1.py from .exp_similarity import compute_exp_similarity # From: https://huggingface.co/datasets/tau/zero_scrolls/raw/main/metrics/exp_similarity.py from .concordance_index import compute_concordance_index # From: https://huggingface.co/datasets/tau/zero_scrolls/raw/main/metrics/concordance_index.py # fmt: on _CITATION = """ """ _DESCRIPTION = """ ZeroSCROLLS: Zero-Shot CompaRison Over Long Language Sequences. A zero shot benchmark for long text reasoning. https://zero.scrolls-benchmark.com/ """ _KWARGS_DESCRIPTION = """ Compute zero_scrolls evaluation metric associated to each zero_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 zero_scrolls subset, one or several of: "accuracy": Accuracy score "f1": F1 score "rouge": ROUGE score "exp_similarity": Exponential Similarity score "concordance_index": Concordance Index score Use the following code to download the metric: ``` import os, shutil from huggingface_hub import hf_hub_download def download_metric(): zero_scrolls_metric_path = hf_hub_download(repo_id="tau/zero_scrolls", repo_type="dataset", filename="metrics/zero_scrolls.py") updated_zero_scrolls_metric_path = ( os.path.dirname(zero_scrolls_metric_path) + os.path.basename(zero_scrolls_metric_path).replace(".", "_") + ".py" ) shutil.copy(zero_scrolls_metric_path, updated_zero_scrolls_metric_path) return updated_zero_scrolls_metric_path zero_scrolls_metric_path = download_metric() ``` Examples: >>> predictions = ["hello there", "general kenobi"] # List[str] >>> references = [["hello", "hi there"], ["commander kenobi"]] # List[List[str]] >>> zero_scrolls_metric = datasets.load_metric(zero_scrolls_metric_path, 'gov_report') # "gov_report" or "summ_screen_fd" or "qmsum" or "squality] >>> results = zero_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, 'zero_scrolls_score': 55.8136, 'display_keys': ['rouge/rouge1', 'rouge/rouge2', 'rouge/rougeL'], 'display': [72.2222, 33.3333, 72.2222]} >>> zero_scrolls_metric = datasets.load_metric(zero_scrolls_metric_path, 'narrative_qa') # "qasper" or "narrative_qa" or "musique" >>> results = zero_scrolls_metric.compute(predictions=predictions, references=references) >>> print(results) {'f1': 72.2222, 'num_predicted': 3, 'mean_prediction_length_characters': 14.6667, 'zero_scrolls_score': 72.2222, 'display_keys': ['f1'], 'display': [72.2222]} >>> predictions = ["The answer is (B)", "D", "A"] # List[str] >>> references = [["B"], ["C"], ["C"]] # List[List[str]] >>> zero_scrolls_metric = datasets.load_metric(zero_scrolls_metric_path, 'quality') >>> results = zero_scrolls_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 33.3333, 'num_predicted': 3, 'mean_prediction_length_characters': 6.3333, 'zero_scrolls_score': 33.3333, 'display_keys': ['accuracy'], 'display': [33.3333]} 'display_keys': ['accuracy'], 'display': [33.3333]} >>> predictions = ["Answer: 4,1,2,3", "2,4,5,4,1"] # List[str] >>> references = [["1,2,3,4"], ["5,3,2,1,4"]] # List[List[str]] >>> zero_scrolls_metric = datasets.load_metric(zero_scrolls_metric_path, 'book_sum_sort') >>> results = zero_scrolls_metric.compute(predictions=predictions, references=references) >>> print(results) {'concordance_index': 25.0, 'num_predicted': 2, 'mean_prediction_length_characters': 12.0, 'zero_scrolls_score': 25.0, 'display_keys': ['concordance_index'], 'display': [25.0]} >>> predictions = ["There are 30% positive reviews", "25%"] # List[str] >>> references = [["40%"], ["82%"]] # List[List[str]] >>> zero_scrolls_metric = datasets.load_metric(zero_scrolls_metric_path, 'space_digest') >>> results = zero_scrolls_metric.compute(predictions=predictions, references=references) >>> print(results) {'exp_similarity': 25.9618, 'num_predicted': 2, 'mean_prediction_length_characters': 16.5, 'zero_scrolls_score': 25.9618, 'display_keys': ['exp_similarity'], 'display': [25.9618]} """ DATASET_TO_METRICS = { "gov_report": { "metrics_to_compute": ["rouge"], "zero_scrolls_score_key": "rouge/geometric_mean", "display_keys": ["rouge/rouge1", "rouge/rouge2", "rouge/rougeL"], }, "narrative_qa": { "metrics_to_compute": ["f1"], "zero_scrolls_score_key": "f1", "display_keys": ["f1"], }, "qasper": { "metrics_to_compute": ["f1"], "zero_scrolls_score_key": "f1", "display_keys": ["f1"], }, "qmsum": { "metrics_to_compute": ["rouge"], "zero_scrolls_score_key": "rouge/geometric_mean", "display_keys": ["rouge/rouge1", "rouge/rouge2", "rouge/rougeL"], }, "summ_screen_fd": { "metrics_to_compute": ["rouge"], "zero_scrolls_score_key": "rouge/geometric_mean", "display_keys": ["rouge/rouge1", "rouge/rouge2", "rouge/rougeL"], }, "quality": { "metrics_to_compute": ["accuracy"], "zero_scrolls_score_key": "accuracy", "display_keys": ["accuracy"], }, "quality_hard": { "metrics_to_compute": ["accuracy"], "zero_scrolls_score_key": None, "display_keys": ["accuracy"], }, "squality": { "metrics_to_compute": ["rouge"], "zero_scrolls_score_key": "rouge/geometric_mean", "display_keys": ["rouge/rouge1", "rouge/rouge2", "rouge/rougeL"], }, "musique": { "metrics_to_compute": ["f1"], "zero_scrolls_score_key": "f1", "display_keys": ["f1"], }, "space_digest": { "metrics_to_compute": ["exp_similarity"], "zero_scrolls_score_key": "exp_similarity", "display_keys": ["exp_similarity"], }, "book_sum_sort": { "metrics_to_compute": ["concordance_index"], "zero_scrolls_score_key": "concordance_index", "display_keys": ["concordance_index"], }, } @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) class ZeroScrolls(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, }, "accuracy": lambda: { "metric_fn": compute_accuracy, "agg_fn": None, # compute_accuracy 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}, }, "exp_similarity": lambda: { "metric_fn": compute_exp_similarity, "agg_fn": None, # compute_exp_similarity already takes max "transform_result_fn": lambda output: {None: output}, }, "concordance_index": lambda: { "metric_fn": compute_concordance_index, "agg_fn": None, # compute_concordance_index 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: zero_scrolls_score_key = DATASET_TO_METRICS[self.config_name]["zero_scrolls_score_key"] if zero_scrolls_score_key is not None: metrics["zero_scrolls_score"] = metrics[zero_scrolls_score_key] else: metrics["zero_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)) )