Download benchpress_eval/salience.py from EDAnonSubmission/benchmark2: direct link, hf CLI and curl.
- Browser
- Download file 6.55 kB
-
https://huggingface.co/datasets/EDAnonSubmission/benchmark2/resolve/main/benchpress_eval/salience.py
- Command line
-
hf download hf://datasets/EDAnonSubmission/benchmark2/benchpress_eval/salience.py
-
curl -L -o salience.py https://huggingface.co/datasets/EDAnonSubmission/benchmark2/resolve/main/benchpress_eval/salience.py
6.55 kB
| 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 | |
| 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)) | |