Datasets:
Formats:
parquet
Languages:
English
Size:
< 1K
Tags:
video-language-model
egocentric-video
laboratory
wet-lab
procedural-monitoring
error-detection
License:
File size: 3,783 Bytes
f91d9a0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | """Generic metric helpers for benchmark tasks."""
from __future__ import annotations
import random
import statistics
from collections import Counter
from typing import Any, Callable, Iterable
def safe_div(num: float, denom: float) -> float | None:
return num / denom if denom else None
def mean(values: Iterable[float | None]) -> float | None:
clean = [value for value in values if value is not None]
return sum(clean) / len(clean) if clean else None
def classification_scores(
pairs: Iterable[tuple[Any, Any]],
*,
labels: Iterable[Any] | None = None,
none_is_wrong: bool = True,
) -> dict[str, Any]:
"""Compute accuracy, balanced accuracy, F1, precision, recall, and confusion."""
pair_list = list(pairs)
if labels is None:
label_values = sorted(
{
str(value)
for target, pred in pair_list
for value in (target, pred)
if value is not None
}
)
else:
label_values = [str(label) for label in labels]
total = len(pair_list)
correct = sum(1 for target, pred in pair_list if pred is not None and str(target) == str(pred))
target_total: Counter[str] = Counter()
pred_total: Counter[str] = Counter()
class_correct: Counter[str] = Counter()
confusion: Counter[str] = Counter()
for target, pred in pair_list:
target_s = str(target)
pred_s = "UNPARSED" if pred is None and none_is_wrong else str(pred)
target_total[target_s] += 1
pred_total[pred_s] += 1
confusion[f"{target_s}->{pred_s}"] += 1
if target_s == pred_s:
class_correct[target_s] += 1
recall: dict[str, float] = {}
precision: dict[str, float] = {}
f1: dict[str, float] = {}
for label in label_values:
recall[label] = class_correct[label] / target_total[label] if target_total[label] else 0.0
precision[label] = class_correct[label] / pred_total[label] if pred_total[label] else 0.0
denom = precision[label] + recall[label]
f1[label] = 2 * precision[label] * recall[label] / denom if denom else 0.0
return {
"accuracy": correct / total if total else None,
"balanced_accuracy": mean(recall.values()) if total and label_values else None,
"macro_f1": mean(f1.values()) if total and label_values else None,
"macro_precision": mean(precision.values()) if total and label_values else None,
"macro_recall": mean(recall.values()) if total and label_values else None,
"precision": precision,
"recall": recall,
"f1": f1,
"confusion": dict(confusion),
"target_counts": dict(target_total),
"pred_counts": dict(pred_total),
}
def parse_success_rate(rows: list[dict[str, Any]], field: str = "pred_parse_ok") -> float | None:
if not rows:
return None
return sum(1 for row in rows if row.get(field)) / len(rows)
def metric_value(summary: dict[str, Any], metric: str) -> float | None:
value = summary.get(metric)
return value if isinstance(value, (int, float)) else None
def bootstrap_sem(
rows: list[dict[str, Any]],
metric: str,
summarize_fn: Callable[[list[dict[str, Any]]], dict[str, Any]],
*,
iterations: int = 500,
seed: int = 17,
) -> float | None:
if not rows:
return None
rng = random.Random(f"{seed}:{metric}:{len(rows)}")
values: list[float] = []
for _ in range(iterations):
sample = [rows[rng.randrange(len(rows))] for _ in rows]
value = metric_value(summarize_fn(sample), metric)
if value is not None:
values.append(value)
if not values:
return None
return statistics.stdev(values) if len(values) > 1 else 0.0
|