evalsuite-python 0.1.0__py3-none-any.whl

evalsuite/__init__.py

@@ -0,0 +1,159 @@
+"""EvalSuite: unified, reproducible evaluation for machine learning and research.
+
+>>> import evalsuite as es
+>>> result = es.evaluate([0, 1, 1, 0], [0, 1, 0, 0])
+>>> print(result.summary())  # doctest: +SKIP
+"""
+
+from . import classification, plot, regression, stats
+from .api import evaluate
+from .classification import (
+    accuracy,
+    average_precision,
+    balanced_accuracy,
+    brier_score,
+    calibration_curve,
+    cohen_kappa,
+    confusion_matrix,
+    expected_calibration_error,
+    f1,
+    fbeta,
+    hamming_loss,
+    jaccard,
+    log_loss,
+    mcc,
+    npv,
+    pr_curve,
+    precision,
+    recall,
+    roc_auc,
+    roc_curve,
+    specificity,
+    top_k_accuracy,
+)
+from .core.exceptions import (
+    EvalSuiteError,
+    InputValidationError,
+    MetricInputError,
+    OptionalDependencyError,
+    StatisticalTestError,
+    UndefinedMetricWarning,
+    UnsupportedTaskError,
+)
+from .core.registry import MetricInfo, list_metrics, metric_info
+from .core.result import EvaluationResult, MetricResult
+from .regression import (
+    adjusted_r2,
+    explained_variance,
+    huber_loss,
+    mae,
+    mape,
+    max_error,
+    mean_bias_error,
+    median_absolute_error,
+    mse,
+    msle,
+    quantile_loss,
+    r2,
+    rae,
+    rmse,
+    rmsle,
+    rse,
+    smape,
+)
+from .reporting import ClassificationReport, classification_report
+from .stats import (
+    ComparisonResult,
+    ConfidenceInterval,
+    TestResult,
+    accuracy_ci,
+    adjust_pvalues,
+    bootstrap_ci,
+    cliffs_delta,
+    cohens_d,
+    compare,
+    delong_test,
+    hedges_g,
+    mcnemar_test,
+    paired_bootstrap_test,
+    proportion_ci,
+    roc_auc_ci,
+)
+from .version import __version__
+
+__all__ = [
+    "plot",
+    "expected_calibration_error",
+    "calibration_curve",
+    "classification_report",
+    "ClassificationReport",
+    "stats",
+    "roc_auc_ci",
+    "proportion_ci",
+    "paired_bootstrap_test",
+    "mcnemar_test",
+    "hedges_g",
+    "delong_test",
+    "compare",
+    "cohens_d",
+    "cliffs_delta",
+    "bootstrap_ci",
+    "adjust_pvalues",
+    "accuracy_ci",
+    "TestResult",
+    "ConfidenceInterval",
+    "ComparisonResult",
+    "EvalSuiteError",
+    "EvaluationResult",
+    "InputValidationError",
+    "MetricInfo",
+    "MetricInputError",
+    "MetricResult",
+    "OptionalDependencyError",
+    "StatisticalTestError",
+    "UndefinedMetricWarning",
+    "UnsupportedTaskError",
+    "__version__",
+    "accuracy",
+    "adjusted_r2",
+    "average_precision",
+    "balanced_accuracy",
+    "brier_score",
+    "classification",
+    "cohen_kappa",
+    "confusion_matrix",
+    "evaluate",
+    "explained_variance",
+    "f1",
+    "fbeta",
+    "hamming_loss",
+    "huber_loss",
+    "jaccard",
+    "list_metrics",
+    "log_loss",
+    "mae",
+    "mape",
+    "max_error",
+    "mcc",
+    "mean_bias_error",
+    "median_absolute_error",
+    "metric_info",
+    "mse",
+    "msle",
+    "npv",
+    "pr_curve",
+    "precision",
+    "quantile_loss",
+    "r2",
+    "rae",
+    "recall",
+    "regression",
+    "rmse",
+    "rmsle",
+    "roc_auc",
+    "roc_curve",
+    "rse",
+    "smape",
+    "specificity",
+    "top_k_accuracy",
+]

evalsuite/__main__.py

@@ -0,0 +1,5 @@
+"""``python -m evalsuite`` runs the command-line interface."""
+
+from .cli.main import main
+
+raise SystemExit(main())

evalsuite/api.py

@@ -0,0 +1,264 @@
+"""High-level API: ``evaluate()``."""
+
+from __future__ import annotations
+
+import platform
+from collections.abc import Sequence
+from typing import Any, Callable, Optional
+
+import numpy as np
+
+from .classification import metrics as clf
+from .classification._common import averaged
+from .core.context import ClassificationContext
+from .core.exceptions import InputValidationError, UnsupportedTaskError
+from .core.result import EvaluationResult, MetricResult
+from .core.types import ArrayLike, ZeroDivision
+from .core.validation import target_type, to_numpy
+from .regression import metrics as reg
+from .version import __version__
+
+__all__ = ["evaluate"]
+
+CtxMetric = Callable[[ClassificationContext], MetricResult]
+
+
+def _classification_registry(
+    average: Optional[str], pos_label: Any, zero_division: ZeroDivision
+) -> dict[str, tuple[CtxMetric, bool]]:
+    """metric id -> (function of a shared context, needs probabilities)."""
+
+    def avg(fn: Any, metric: str, name: str) -> CtxMetric:
+        return lambda ctx: averaged(
+            ctx,
+            fn,
+            metric=metric,
+            name=name,
+            average=average,
+            pos_label=pos_label,
+            zero_division=zero_division,
+        )
+
+    return {
+        "accuracy": (clf._accuracy, False),
+        "balanced_accuracy": (clf._balanced_accuracy, False),
+        "precision": (avg(clf._precision, "precision", "Precision"), False),
+        "recall": (avg(clf._recall, "recall", "Recall"), False),
+        "f1": (avg(clf._fbeta_fn(1.0), "f1", "F1"), False),
+        "specificity": (avg(clf._specificity, "specificity", "Specificity"), False),
+        "npv": (avg(clf._npv, "npv", "NPV"), False),
+        "jaccard": (avg(clf._jaccard, "jaccard", "Jaccard"), False),
+        "mcc": (lambda ctx: clf._mcc(ctx, zero_division), False),
+        "cohen_kappa": (lambda ctx: clf._cohen_kappa(ctx, None, zero_division), False),
+        "hamming_loss": (_hamming, False),
+        "roc_auc": (lambda ctx: clf._roc_auc(ctx, average=average, pos_label=pos_label), True),
+        "average_precision": (
+            lambda ctx: clf._average_precision(ctx, average=average, pos_label=pos_label),
+            True,
+        ),
+        "log_loss": (lambda ctx: clf._log_loss(ctx, pos_label), True),
+        "brier_score": (lambda ctx: clf._brier(ctx, pos_label), True),
+    }
+
+
+def _hamming(ctx: ClassificationContext) -> MetricResult:
+    if ctx.target_type == "multilabel":
+        assert ctx.y_pred is not None  # noqa: S101
+        wrong = (ctx.y_true != ctx.y_pred).mean(axis=1)
+    else:
+        wrong = (ctx.true_idx != ctx.pred_idx).astype(float)
+    return MetricResult("hamming_loss", "Hamming loss", float(np.average(wrong, weights=ctx.weights)))
+
+
+_DEFAULT_SINGLE = [
+    "accuracy",
+    "balanced_accuracy",
+    "precision",
+    "recall",
+    "f1",
+    "specificity",
+    "mcc",
+    "cohen_kappa",
+]
+_DEFAULT_MULTILABEL = ["accuracy", "hamming_loss", "precision", "recall", "f1", "jaccard"]
+_DEFAULT_PROB = ["roc_auc", "average_precision", "log_loss", "brier_score"]
+_DEFAULT_PROB_MULTILABEL = ["roc_auc", "average_precision"]
+
+_REGRESSION: dict[str, Callable[..., MetricResult]] = {
+    "mae": reg.mae,
+    "mse": reg.mse,
+    "rmse": reg.rmse,
+    "r2": reg.r2,
+    "explained_variance": reg.explained_variance,
+    "median_absolute_error": reg.median_absolute_error,
+    "max_error": reg.max_error,
+    "mean_bias_error": reg.mean_bias_error,
+    "mape": reg.mape,
+    "smape": reg.smape,
+    "msle": reg.msle,
+    "rmsle": reg.rmsle,
+    "rae": reg.rae,
+    "rse": reg.rse,
+    "huber_loss": reg.huber_loss,
+    "quantile_loss": reg.quantile_loss,
+}
+_DEFAULT_REGRESSION = [
+    "mae",
+    "mse",
+    "rmse",
+    "r2",
+    "explained_variance",
+    "median_absolute_error",
+    "max_error",
+    "mean_bias_error",
+]
+_NO_WEIGHTS = {"max_error"}
+
+
+def _infer_task(y_true: ArrayLike, y_prob: Optional[ArrayLike]) -> str:
+    if y_prob is not None:
+        return "classification"
+    return (
+        "regression"
+        if target_type(to_numpy(y_true, "y_true", allow_2d=True)) == "continuous"
+        else "classification"
+    )
+
+
+def evaluate(
+    y_true: ArrayLike,
+    y_pred: Optional[ArrayLike] = None,
+    *,
+    y_prob: Optional[ArrayLike] = None,
+    task: Optional[str] = None,
+    metrics: Optional[Sequence[str]] = None,
+    average: Optional[str] = "auto",
+    labels: Optional[ArrayLike] = None,
+    pos_label: Any = None,
+    sample_weight: Optional[ArrayLike] = None,
+    zero_division: ZeroDivision = "warn",
+) -> EvaluationResult:
+    """Evaluate predictions with a standard set of metrics (or the ``metrics`` you name).
+
+    The task is inferred when omitted: probabilities or integer/string labels mean classification, non-integer
+    numbers mean regression. Inputs are validated once and shared intermediate results (the confusion matrix)
+    are computed once for all metrics.
+
+    >>> import evalsuite as es
+    >>> r = es.evaluate([0, 1, 1, 0], [0, 1, 0, 0])
+    >>> round(r["accuracy"], 2)
+    0.75
+    """
+    task = task or _infer_task(y_true, y_prob)
+    if task == "classification":
+        return _evaluate_classification(
+            y_true, y_pred, y_prob, metrics, average, labels, pos_label, sample_weight, zero_division
+        )
+    if task == "regression":
+        if y_pred is None:
+            raise InputValidationError("Regression evaluation needs y_pred.")
+        return _evaluate_regression(y_true, y_pred, metrics, sample_weight)
+    raise UnsupportedTaskError("task must be 'classification' or 'regression' in EvalSuite 0.1.")
+
+
+def _metadata(**extra: Any) -> dict[str, Any]:
+    return {
+        "evalsuite_version": __version__,
+        "numpy_version": np.__version__,
+        "python_version": platform.python_version(),
+        **extra,
+    }
+
+
+def _evaluate_classification(
+    y_true: ArrayLike,
+    y_pred: Optional[ArrayLike],
+    y_prob: Optional[ArrayLike],
+    metrics: Optional[Sequence[str]],
+    average: Optional[str],
+    labels: Optional[ArrayLike],
+    pos_label: Any,
+    sample_weight: Optional[ArrayLike],
+    zero_division: ZeroDivision,
+) -> EvaluationResult:
+    if y_pred is None and y_prob is None:
+        raise InputValidationError("Classification evaluation needs y_pred, y_prob, or both.")
+    ctx = ClassificationContext(y_true, y_pred, y_prob=y_prob, labels=labels, sample_weight=sample_weight)
+    registry = _classification_registry(average, pos_label, zero_division)
+    if metrics is None:
+        multilabel = ctx.target_type == "multilabel"
+        names = [] if y_pred is None else list(_DEFAULT_MULTILABEL if multilabel else _DEFAULT_SINGLE)
+        if y_prob is not None:
+            names += _DEFAULT_PROB_MULTILABEL if multilabel else _DEFAULT_PROB
+    else:
+        names = list(metrics)
+        unknown = [m for m in names if m not in registry]
+        if unknown:
+            raise InputValidationError(
+                f"Unknown classification metric(s): {', '.join(unknown)}. Available: {', '.join(registry)}."
+            )
+    out: dict[str, MetricResult] = {}
+    for name in names:
+        fn, needs_prob = registry[name]
+        if needs_prob and y_prob is None:
+            raise InputValidationError(f"Metric '{name}' needs y_prob (predicted probabilities).")
+        if not needs_prob and y_pred is None:
+            raise InputValidationError(f"Metric '{name}' needs y_pred (predicted labels).")
+        out[name] = fn(ctx)
+    cm = None if ctx.target_type == "multilabel" or y_pred is None else ctx.confusion_matrix
+    return EvaluationResult(
+        task="classification",
+        metrics=out,
+        n_samples=ctx.n,
+        target_type=ctx.target_type,
+        labels=tuple(ctx.labels.tolist()),
+        confusion_matrix=cm,
+        metadata=_metadata(average=average, zero_division=zero_division, weighted=sample_weight is not None),
+    )
+
+
+def _evaluate_regression(
+    y_true: ArrayLike, y_pred: ArrayLike, metrics: Optional[Sequence[str]], sample_weight: Optional[ArrayLike]
+) -> EvaluationResult:
+    yt = to_numpy(y_true, "y_true", allow_2d=True)
+    multi = yt.ndim == 2
+    if metrics is None:
+        names = [m for m in _DEFAULT_REGRESSION if not (multi and m == "max_error")]
+    else:
+        names = list(metrics)
+        unknown = [m for m in names if m not in _REGRESSION]
+        if unknown:
+            raise InputValidationError(
+                f"Unknown regression metric(s): {', '.join(unknown)}. Available: {', '.join(_REGRESSION)}."
+            )
+    out: dict[str, MetricResult] = {}
+    shared = reg._Inputs(y_true, y_pred, sample_weight)  # validate once for every metric
+    token = reg._SHARED.set((id(y_true), id(y_pred), id(sample_weight), shared))
+    try:
+        _regression_loop(names, out, y_true, y_pred, sample_weight)
+    finally:
+        reg._SHARED.reset(token)
+    return EvaluationResult(
+        task="regression",
+        metrics=out,
+        n_samples=yt.shape[0],
+        target_type="continuous",
+        metadata=_metadata(weighted=sample_weight is not None, outputs=yt.shape[1] if multi else 1),
+    )
+
+
+def _regression_loop(
+    names: list[str],
+    out: dict[str, MetricResult],
+    y_true: ArrayLike,
+    y_pred: ArrayLike,
+    sample_weight: Optional[ArrayLike],
+) -> None:
+    for name in names:
+        fn = _REGRESSION[name]
+        if name in _NO_WEIGHTS:
+            if sample_weight is not None:
+                raise InputValidationError(f"Metric '{name}' does not support sample_weight.")
+            out[name] = fn(y_true, y_pred)
+        else:
+            out[name] = fn(y_true, y_pred, sample_weight=sample_weight)

evalsuite/benchmarks.py

@@ -0,0 +1,272 @@
+"""Speed and memory benchmarks, against scikit-learn when it is installed.
+
+Each case times the fastest of ``repeat`` runs (after one warm-up) and measures peak traced memory with
+``tracemalloc`` (NumPy reports its allocations to it). Both libraries compute the same metrics on the same
+data, and the largest absolute difference between their results is reported, so speed is never shown for
+numbers that disagree.
+
+    >>> from evalsuite.benchmarks import run_benchmarks
+    >>> print(run_benchmarks(sizes=(10_000,), repeat=3))  # doctest: +SKIP
+"""
+
+from __future__ import annotations
+
+import json
+import platform
+import time
+import tracemalloc
+import warnings
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Any, Optional, cast
+
+import numpy as np
+
+from .core.result import _json_safe, _latex_escape, _latex_table
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+__all__ = ["BenchmarkResult", "run_benchmarks"]
+
+_HEADER = (
+    "case",
+    "n",
+    "evalsuite_ms",
+    "sklearn_ms",
+    "speedup",
+    "evalsuite_peak_mb",
+    "sklearn_peak_mb",
+    "max_abs_diff",
+)
+
+
+def _measure(fn: Callable[[], Any], repeat: int) -> tuple[float, float, Any]:
+    """(fastest seconds, peak MiB, result)."""
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        result = fn()  # warm-up
+        best = float("inf")
+        for _ in range(repeat):
+            t0 = time.perf_counter()
+            fn()
+            best = min(best, time.perf_counter() - t0)
+        tracemalloc.start()
+        try:
+            fn()
+            _, peak = tracemalloc.get_traced_memory()
+        finally:
+            tracemalloc.stop()
+    return best, peak / 2**20, result
+
+
+def _cases(n: int, rng: np.random.Generator) -> list[tuple[str, Callable[[], Any], Optional[Callable[[], Any]]]]:
+    import evalsuite as es
+
+    y = rng.integers(0, 2, n)
+    p = np.where(rng.random(n) < 0.8, y, 1 - y)
+    prob = 1 / (1 + np.exp(-(2.0 * (y - 0.5) + rng.normal(0, 1, n))))
+    yk = rng.integers(0, 10, n)
+    pk = np.where(rng.random(n) < 0.7, yk, rng.integers(0, 10, n))
+    yr = rng.normal(10, 3, n)
+    pr = yr + rng.normal(0, 1, n)
+    names = ["accuracy", "balanced_accuracy", "precision", "recall", "f1", "specificity", "mcc", "cohen_kappa"]
+
+    def es_binary() -> list[float]:
+        r = es.evaluate(y, p, metrics=names)
+        return [float(r[m]) for m in names]
+
+    def es_reg() -> list[float]:
+        r = es.evaluate(yr, pr, metrics=["mae", "mse", "rmse", "r2"])
+        return [float(r[m]) for m in ("mae", "mse", "rmse", "r2")]
+
+    cases: list[tuple[str, Callable[[], Any], Optional[Callable[[], Any]]]] = [
+        ("binary: 8 label metrics via evaluate()", es_binary, None),
+        ("10 classes: macro F1", lambda: [float(es.f1(yk, pk, average="macro"))], None),
+        ("binary: ROC AUC", lambda: [float(es.roc_auc(y, prob))], None),
+        ("regression: MAE, MSE, RMSE, R² via evaluate()", es_reg, None),
+    ]
+    try:
+        import sklearn.metrics as skm  # type: ignore[import-untyped]
+    except ImportError:
+        return cases
+
+    def sk_binary() -> list[float]:
+        return [
+            skm.accuracy_score(y, p),
+            skm.balanced_accuracy_score(y, p),
+            skm.precision_score(y, p),
+            skm.recall_score(y, p),
+            skm.f1_score(y, p),
+            skm.recall_score(y, p, pos_label=0),
+            skm.matthews_corrcoef(y, p),
+            skm.cohen_kappa_score(y, p),
+        ]
+
+    def sk_reg() -> list[float]:
+        mse = skm.mean_squared_error(yr, pr)
+        return [skm.mean_absolute_error(yr, pr), mse, float(np.sqrt(mse)), skm.r2_score(yr, pr)]
+
+    sk = [sk_binary, lambda: [skm.f1_score(yk, pk, average="macro")], lambda: [skm.roc_auc_score(y, prob)], sk_reg]
+    return [(name, es_fn, sk_fn) for (name, es_fn, _), sk_fn in zip(cases, sk)]
+
+
+@dataclass(frozen=True, eq=False)
+class BenchmarkResult:
+    """Rows of timings (milliseconds), peak memory (MiB) and agreement, plus the environment they ran in."""
+
+    rows: tuple[Any, ...]
+    environment: Any = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "rows", tuple(MappingProxyType(dict(r)) for r in self.rows))
+        object.__setattr__(self, "environment", MappingProxyType(dict(self.environment)))
+
+    def _cells(self, digits: int) -> list[list[str]]:
+        def f(v: Any, d: int = digits) -> str:
+            return "–" if v is None else f"{v:.{d}f}"
+
+        return [
+            [
+                r["case"],
+                f"{r['n']:,}",
+                f(r["evalsuite_ms"]),
+                f(r["sklearn_ms"]),
+                "–" if r["speedup"] is None else f"{r['speedup']:.2f}×",
+                f(r["evalsuite_peak_mb"], 2),
+                f(r["sklearn_peak_mb"], 2),
+                "–" if r["max_abs_diff"] is None else f"{r['max_abs_diff']:.1e}",
+            ]
+            for r in self.rows
+        ]
+
+    _TITLES = (
+        "Case",
+        "n",
+        "EvalSuite (ms)",
+        "scikit-learn (ms)",
+        "Speed-up",
+        "EvalSuite peak (MiB)",
+        "scikit-learn peak (MiB)",
+        "Max |difference|",
+    )
+
+    def summary(self, *, digits: int = 3) -> str:
+        cells = self._cells(digits)
+        widths = [max(len(t), *(len(c[i]) for c in cells)) for i, t in enumerate(self._TITLES)]
+
+        def line(c: Sequence[str]) -> str:
+            return "  ".join(x.ljust(widths[i]) if i == 0 else x.rjust(widths[i]) for i, x in enumerate(c))
+
+        env = self.environment
+        head = (
+            f"EvalSuite {env['evalsuite']} benchmarks | Python {env['python']} | NumPy {env['numpy']}"
+            + (f" | scikit-learn {env['sklearn']}" if env.get("sklearn") else "")
+            + f" | {env['machine']} | fastest of {env['repeat']} runs"
+        )
+        note = "Speed-up > 1 means EvalSuite is faster. Max |difference| compares the two libraries' results."
+        return "\n".join([head, "", line(self._TITLES), *(line(c) for c in cells), "", note])
+
+    def __repr__(self) -> str:
+        return self.summary()
+
+    def to_dict(self) -> dict[str, Any]:
+        return cast(
+            "dict[str, Any]",
+            _json_safe({"environment": dict(self.environment), "rows": [dict(r) for r in self.rows]}),
+        )
+
+    def to_json(self, *, indent: Optional[int] = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent, allow_nan=False)
+
+    def to_dataframe(self) -> pd.DataFrame:
+        import pandas as pd
+
+        frame: pd.DataFrame = pd.DataFrame([dict(r) for r in self.rows])
+        return frame
+
+    def to_csv(self, path: Optional[str] = None) -> str:
+        from .core.export import csv_text
+
+        rows = [[r[h] if r[h] is not None else float("nan") for h in _HEADER] for r in self.rows]
+        text = csv_text(list(_HEADER), rows)
+        if path is not None:
+            with open(path, "w", encoding="utf-8", newline="") as fh:
+                fh.write(text)
+        return text
+
+    def to_markdown(self, *, digits: int = 3) -> str:
+        lines = ["| " + " | ".join(self._TITLES) + " |", "| --- |" + " ---: |" * (len(self._TITLES) - 1)]
+        return "\n".join(lines + ["| " + " | ".join(c) + " |" for c in self._cells(digits)])
+
+    def to_latex(self, *, digits: int = 3, caption: Optional[str] = None, label: Optional[str] = None) -> str:
+        return _latex_table(
+            [_latex_escape(t) for t in self._TITLES],
+            [[_latex_escape(x) for x in c] for c in self._cells(digits)],
+            caption=caption or "EvalSuite benchmarks.",
+            label=label,
+        )
+
+    def to_html(self, *, digits: int = 3, full: bool = False) -> str:
+        from .core.export import html_document, html_table
+
+        table = html_table(list(self._TITLES), self._cells(digits), caption="Benchmarks")
+        env = self.environment
+        meta = f"Python {env['python']}, NumPy {env['numpy']}, {env['machine']}"
+        return html_document("EvalSuite benchmarks", table, meta) if full else table
+
+
+def run_benchmarks(
+    sizes: Sequence[int] = (1_000, 100_000, 1_000_000),
+    *,
+    repeat: int = 5,
+    compare_sklearn: bool = True,
+    random_state: Optional[int] = 0,
+) -> BenchmarkResult:
+    """Time and memory for common evaluation workloads at each size, against scikit-learn if installed."""
+    import evalsuite as es
+
+    if repeat < 1:
+        raise ValueError("repeat must be at least 1.")
+    rng = np.random.default_rng(random_state)
+    rows: list[dict[str, Any]] = []
+    sk_version: Optional[str] = None
+    if compare_sklearn:
+        try:
+            import sklearn
+
+            sk_version = sklearn.__version__
+        except ImportError:
+            compare_sklearn = False
+    for n in sizes:
+        for name, es_fn, sk_fn in _cases(int(n), rng):
+            es_t, es_mem, es_val = _measure(es_fn, repeat)
+            row: dict[str, Any] = {
+                "case": name,
+                "n": int(n),
+                "evalsuite_ms": es_t * 1000,
+                "evalsuite_peak_mb": es_mem,
+                "sklearn_ms": None,
+                "sklearn_peak_mb": None,
+                "speedup": None,
+                "max_abs_diff": None,
+            }
+            if compare_sklearn and sk_fn is not None:
+                sk_t, sk_mem, sk_val = _measure(sk_fn, repeat)
+                row.update(
+                    sklearn_ms=sk_t * 1000,
+                    sklearn_peak_mb=sk_mem,
+                    speedup=sk_t / es_t if es_t else None,
+                    max_abs_diff=float(np.max(np.abs(np.asarray(es_val, float) - np.asarray(sk_val, float)))),
+                )
+            rows.append(row)
+    env = {
+        "evalsuite": es.__version__,
+        "python": platform.python_version(),
+        "numpy": np.__version__,
+        "sklearn": sk_version,
+        "machine": f"{platform.system()} {platform.machine()}",
+        "repeat": repeat,
+    }
+    return BenchmarkResult(tuple(rows), env)