benchpress_eval/salience.py

from __future__ import annotations

from dataclasses import dataclass
from typing import Callable

import numpy as np
import pandas as pd

from .data import parse_metadata
from .metrics import auroc_safe


@dataclass(frozen=True)
class ParameterSpec:
    name: str
    edit_types: tuple[str, ...]
    column_candidates: tuple[str, ...]
    metadata_candidates: tuple[str, ...] = ()
    transform: Callable[[pd.Series], pd.Series] | None = None


def _abs(series: pd.Series) -> pd.Series:
    return pd.to_numeric(series, errors="coerce").abs()


def _scale_delta(series: pd.Series) -> pd.Series:
    return (pd.to_numeric(series, errors="coerce") - 1.0).abs()


PARAMETERS = (
    ParameterSpec(
        "shape_delta",
        ("shape",),
        ("meta.delta", "shape_delta", "delta_theta"),
        ("delta", "shape_delta", "delta_theta"),
        _abs,
    ),
    ParameterSpec(
        "articulation_delta",
        ("articulation",),
        ("meta.delta", "articulation_delta", "delta_psi"),
        ("delta", "articulation_delta", "delta_psi"),
        _abs,
    ),
    ParameterSpec(
        "scale_delta",
        ("scale",),
        ("meta.factor", "scale_factor", "factor"),
        ("factor", "scale_factor"),
        _scale_delta,
    ),
    ParameterSpec(
        "movement_distance",
        ("movement",),
        ("meta.distance_moved", "movement_distance", "distance_moved"),
        ("distance_moved", "movement_distance"),
        None,
    ),
    ParameterSpec(
        "rotation_angle",
        ("rotation",),
        ("meta.angle_deg", "rotation_angle_deg", "angle_deg"),
        ("angle_deg", "rotation_angle_deg"),
        _abs,
    ),
    ParameterSpec(
        "camera_position_delta",
        ("camera",),
        ("meta.position_delta", "camera_position_delta", "position_delta"),
        ("position_delta", "camera_position_delta"),
        None,
    ),
    ParameterSpec(
        "camera_focal_delta",
        ("camera",),
        ("meta.delta_lens", "focal_delta", "delta_f"),
        ("delta_lens", "focal_delta", "delta_f"),
        _abs,
    ),
    ParameterSpec(
        "lighting_magnitude",
        ("lighting",),
        ("meta.magnitude", "lighting_magnitude"),
        ("magnitude", "lighting_magnitude"),
        None,
    ),
    ParameterSpec(
        "removal_visibility",
        ("removal",),
        ("meta.visibility", "visibility"),
        ("visibility",),
        None,
    ),
)


def _metadata_series(df: pd.DataFrame, candidates: tuple[str, ...]) -> pd.Series:
    if "metadata" not in df.columns:
        return pd.Series(np.nan, index=df.index)
    values = []
    for value in df["metadata"]:
        metadata = parse_metadata(value)
        found = np.nan
        for key in candidates:
            if key in metadata:
                found = metadata[key]
                break
        values.append(found)
    return pd.Series(values, index=df.index)


def parameter_values(dataset_df: pd.DataFrame, spec: ParameterSpec) -> pd.Series:
    values = pd.Series(np.nan, index=dataset_df.index, dtype="float64")
    for column in spec.column_candidates:
        if column in dataset_df.columns:
            values = pd.to_numeric(dataset_df[column], errors="coerce")
            break
    if values.isna().all() and spec.metadata_candidates:
        values = pd.to_numeric(_metadata_series(dataset_df, spec.metadata_candidates), errors="coerce")
    if spec.transform:
        values = spec.transform(values)
    return values


def compute_noedit_salience(
    dataset_df: pd.DataFrame,
    aligned_predictions: pd.DataFrame,
    n_bins: int = 5,
) -> tuple[pd.DataFrame, pd.DataFrame]:
    """Compute no-edit AUROC stratified by ground-truth parameter magnitude."""
    id_col = "sample_id" if "sample_id" in aligned_predictions.columns else "parquet_row_index"
    base = dataset_df.reset_index(drop=True).copy()
    if "parquet_row_index" not in base.columns:
        base["parquet_row_index"] = base.index

    usable = aligned_predictions[
        (aligned_predictions["label"].eq(1)) | (aligned_predictions["negative_type"].eq("no_edit"))
    ].copy()
    rows = []
    summary = []

    for spec in PARAMETERS:
        mask = base["edit_type"].isin(spec.edit_types)
        param = parameter_values(base, spec)
        param_df = base.loc[mask, [id_col if id_col in base.columns else "parquet_row_index"]].copy()
        param_df["parameter_value"] = param[mask].values
        param_df = param_df.dropna(subset=["parameter_value"])
        if param_df["parameter_value"].nunique() < 2:
            continue

        try:
            bins = pd.qcut(param_df["parameter_value"], q=n_bins, duplicates="drop")
        except ValueError:
            continue
        param_df["bin"] = bins.astype(str)
        merged = usable.merge(param_df, on=id_col, how="inner")
        if merged.empty:
            continue

        for bin_label, group in merged.groupby("bin", sort=False):
            rows.append(
                {
                    "parameter": spec.name,
                    "edit_types": ",".join(spec.edit_types),
                    "bin": bin_label,
                    "auc": auroc_safe(group["label"], group["score"]),
                    "n_triplets": int(len(group)),
                    "n_edits": int(group[id_col].nunique()),
                    "value_min": float(group["parameter_value"].min()),
                    "value_max": float(group["parameter_value"].max()),
                }
            )

        summary.append(
            {
                "parameter": spec.name,
                "edit_types": ",".join(spec.edit_types),
                "spearman_auc_vs_bin_midpoint": _bin_spearman(rows, spec.name),
                "n_bins": int(param_df["bin"].nunique()),
                "n_edits": int(param_df[id_col].nunique()),
            }
        )

    return pd.DataFrame(rows), pd.DataFrame(summary)


def _bin_spearman(rows: list[dict], parameter_name: str) -> float:
    subset = pd.DataFrame([row for row in rows if row["parameter"] == parameter_name])
    if len(subset) < 2:
        return float("nan")
    mids = (subset["value_min"] + subset["value_max"]) / 2.0
    x = pd.to_numeric(mids, errors="coerce")
    y = pd.to_numeric(subset["auc"], errors="coerce")
    mask = x.notna() & y.notna()
    if mask.sum() < 2:
        return float("nan")
    x_rank = x[mask].rank(method="average")
    y_rank = y[mask].rank(method="average")
    if x_rank.nunique() < 2 or y_rank.nunique() < 2:
        return float("nan")
    return float(x_rank.corr(y_rank))