libs/benchmark/overnight_stop.py

from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Dict, Mapping, Sequence

import numpy as np
import pandas as pd


STOP_MODELS = (
    "percentile_target",
    "regret_constrained",
    "utility_maximizing",
    "hybrid",
)

OBJECTIVES = (
    "quality_per_time",
    "quality_per_docking",
    "rank_percentile_minimization",
    "regret_constrained_utility",
    "target_percentile_attainment",
    "hybrid_objective",
)


@dataclass(frozen=True)
class StopModelParams:
    target_percentile: float = 1.0
    probability_threshold: float = 0.80
    epsilon_quality: float = 0.10
    min_budget: int = 100
    max_budget: int = 10000
    gain_threshold: float = 0.03
    utility_lambda: float = 0.001
    utility_threshold: float = 0.0
    uncertainty_threshold: float = 0.35
    confirmation_window: int = 24
    min_improvement_delta: float = 0.02


def _sigmoid(x: float) -> float:
    z = float(np.clip(x, -50.0, 50.0))
    return float(1.0 / (1.0 + np.exp(-z)))


def _safe_float(v: Any, default: float = np.nan) -> float:
    try:
        x = float(v)
        return x if np.isfinite(x) else float(default)
    except Exception:
        return float(default)


def _best_rank_percentile(selected_ids: Sequence[str], truth_map: Mapping[str, Mapping[str, float]]) -> float:
    vals = []
    for lid in selected_ids:
        info = truth_map.get(str(lid))
        if info is None:
            continue
        vals.append(_safe_float(info.get("rank_percentile"), 100.0))
    if not vals:
        return 100.0
    return float(np.nanmin(np.asarray(vals, dtype=float)))


def estimate_marginal_expected_gain(
    *,
    remaining_df: pd.DataFrame,
    incumbent_best_score: float,
    uncertainty_weight: float = 0.5,
) -> float:
    pred = pd.to_numeric(remaining_df.get("predicted_score_prebatch", np.nan), errors="coerce").dropna().to_numpy(dtype=float)
    if pred.size == 0:
        return 0.0
    unc = pd.to_numeric(remaining_df.get("predicted_uncertainty_prebatch", np.nan), errors="coerce").dropna().to_numpy(dtype=float)
    if unc.size == 0:
        unc = np.full(pred.shape[0], np.nanstd(pred) if pred.size > 1 else 1.0)
    if unc.size != pred.size:
        unc = np.full(pred.shape[0], np.nanmean(unc) if unc.size else 1.0)
    optimistic = pred - float(max(0.0, uncertainty_weight)) * np.abs(unc)
    optimistic_best = float(np.nanmin(optimistic)) if np.isfinite(optimistic).any() else float(np.nanmin(pred))
    if not np.isfinite(optimistic_best):
        return 0.0
    return float(max(0.0, float(incumbent_best_score) - optimistic_best))


def estimate_probability_target_percentile(
    *,
    best_rank_percentile: float,
    target_percentile: float,
    marginal_expected_gain: float,
    mean_uncertainty: float,
    improvement_slope: float,
    params: StopModelParams,
) -> float:
    p_rank = _sigmoid((float(target_percentile) - float(best_rank_percentile)) / max(0.25, float(target_percentile)))
    p_gain = _sigmoid((float(params.gain_threshold) - float(marginal_expected_gain)) / max(1e-3, float(params.gain_threshold)))
    p_unc = 0.5 if not np.isfinite(mean_uncertainty) else _sigmoid(
        (float(params.uncertainty_threshold) - float(mean_uncertainty)) / max(1e-3, float(params.uncertainty_threshold))
    )
    p_slope = 0.5 if not np.isfinite(improvement_slope) else _sigmoid(
        (float(params.min_improvement_delta) - abs(float(improvement_slope))) / max(1e-3, float(params.min_improvement_delta))
    )
    return float(np.clip(0.45 * p_rank + 0.25 * p_gain + 0.15 * p_unc + 0.15 * p_slope, 0.0, 1.0))


def _rank_slope(rank_history: Sequence[float], window: int) -> float:
    w = max(2, int(window))
    if len(rank_history) < w:
        return float("nan")
    a = float(rank_history[-w])
    b = float(rank_history[-1])
    return float((a - b) / max(1, w - 1))


def _stop_condition(
    model_name: str,
    *,
    params: StopModelParams,
    n_evaluated: int,
    max_budget: int,
    estimated_probability_target_percentile: float,
    marginal_expected_gain: float,
    expected_quality_loss: float,
    utility_value: float,
    mean_uncertainty: float,
    improvement_slope: float,
) -> tuple[bool, str]:
    if int(n_evaluated) >= int(max_budget):
        return True, "max_budget_reached"
    if int(n_evaluated) < int(params.min_budget):
        return False, "below_min_budget"

    if model_name == "percentile_target":
        if (
            float(estimated_probability_target_percentile) >= float(params.probability_threshold)
            and float(marginal_expected_gain) <= float(params.gain_threshold)
        ):
            return True, "percentile_target_stop"
        return False, "continue_percentile_target"

    if model_name == "regret_constrained":
        if (
            float(expected_quality_loss) <= float(params.epsilon_quality)
            and float(marginal_expected_gain) <= float(params.gain_threshold)
        ):
            return True, "regret_constrained_stop"
        return False, "continue_regret_constrained"

    if model_name == "utility_maximizing":
        if float(utility_value) <= float(params.utility_threshold):
            return True, "utility_maximizing_stop"
        return False, "continue_utility_maximizing"

    if model_name == "hybrid":
        hybrid_ready = (
            float(estimated_probability_target_percentile) >= float(params.probability_threshold)
            and float(marginal_expected_gain) <= float(params.gain_threshold)
            and (not np.isfinite(mean_uncertainty) or float(mean_uncertainty) <= float(params.uncertainty_threshold))
            and (not np.isfinite(improvement_slope) or abs(float(improvement_slope)) <= float(params.min_improvement_delta))
        )
        if hybrid_ready or (
            float(expected_quality_loss) <= float(params.epsilon_quality) and float(utility_value) <= float(params.utility_threshold)
        ):
            return True, "hybrid_stop"
        return False, "continue_hybrid"

    raise ValueError(f"Unsupported stop model: {model_name}")


def simulate_stop_model(
    order_df: pd.DataFrame,
    *,
    truth_map: Mapping[str, Mapping[str, float]],
    model_name: str,
    budget: int,
    params: StopModelParams,
    wall_time_per_dock: float,
    uncertainty_weight: float = 0.5,
) -> tuple[pd.DataFrame, pd.DataFrame]:
    if model_name not in STOP_MODELS:
        raise ValueError(f"Unsupported stop model `{model_name}`")
    if order_df.empty:
        return order_df.copy(), pd.DataFrame()

    cap = int(max(1, min(int(budget), int(params.max_budget), int(order_df.shape[0]))))
    ordered = order_df.sort_values("step").head(cap).copy().reset_index(drop=True)

    selected_rows: list[dict[str, Any]] = []
    selected_ids: list[str] = []
    rank_history: list[float] = []
    score_history: list[float] = []
    trace_rows: list[dict[str, Any]] = []

    for i, row in ordered.iterrows():
        row_d = row.to_dict()
        selected_rows.append(row_d)
        lid = str(row_d.get("ligand_id"))
        selected_ids.append(lid)

        dscore = _safe_float(row_d.get("docking_score"), np.nan)
        if np.isfinite(dscore):
            score_history.append(float(dscore))
        incumbent_best = float(np.nanmin(np.asarray(score_history, dtype=float))) if score_history else float("inf")

        best_pct = _best_rank_percentile(selected_ids, truth_map)
        rank_history.append(best_pct)
        slope = _rank_slope(rank_history, int(params.confirmation_window))

        remaining = ordered.iloc[i + 1 :].copy()
        marginal_gain = estimate_marginal_expected_gain(
            remaining_df=remaining,
            incumbent_best_score=incumbent_best,
            uncertainty_weight=float(uncertainty_weight),
        )
        recent_unc = pd.to_numeric(remaining.head(32).get("predicted_uncertainty_prebatch", np.nan), errors="coerce").dropna()
        mean_unc = float(recent_unc.mean()) if not recent_unc.empty else float("nan")
        p_target = estimate_probability_target_percentile(
            best_rank_percentile=best_pct,
            target_percentile=float(params.target_percentile),
            marginal_expected_gain=marginal_gain,
            mean_uncertainty=mean_unc,
            improvement_slope=slope,
            params=params,
        )
        expected_quality_loss = float(marginal_gain / max(1.0, abs(incumbent_best))) if np.isfinite(incumbent_best) else float("inf")
        utility_value = float(marginal_gain - float(params.utility_lambda) * max(1e-9, float(wall_time_per_dock)))

        stop, reason = _stop_condition(
            model_name=model_name,
            params=params,
            n_evaluated=int(i + 1),
            max_budget=min(cap, int(params.max_budget)),
            estimated_probability_target_percentile=p_target,
            marginal_expected_gain=marginal_gain,
            expected_quality_loss=expected_quality_loss,
            utility_value=utility_value,
            mean_uncertainty=mean_unc,
            improvement_slope=slope,
        )
        trace_rows.append(
            {
                "step": int(i),
                "ligand_id": lid,
                "stop_model": model_name,
                "best_rank_percentile": float(best_pct),
                "improvement_slope": float(slope) if np.isfinite(slope) else np.nan,
                "estimated_probability_target_percentile": float(p_target),
                "marginal_expected_gain": float(marginal_gain),
                "expected_quality_loss": float(expected_quality_loss),
                "utility_value": float(utility_value),
                "mean_uncertainty": float(mean_unc) if np.isfinite(mean_unc) else np.nan,
                "stop": bool(stop),
                "stop_reason": str(reason),
                "estimated_wall_time_seconds": float((i + 1) * max(1e-9, float(wall_time_per_dock))),
            }
        )
        if stop:
            break

    selected_df = pd.DataFrame(selected_rows)
    if not selected_df.empty:
        selected_df["step"] = np.arange(selected_df.shape[0], dtype=int)
    return selected_df, pd.DataFrame(trace_rows)


def objective_value(row: Mapping[str, Any], objective: str, target_percentile: float = 1.0) -> float:
    rank_pct = _safe_float(row.get("best_found_rank_percentile"), 100.0)
    q_loss = _safe_float(row.get("quality_loss_vs_exhaustive_best"), 1.0)
    red = _safe_float(row.get("docking_reduction_fraction"), 0.0)
    qpt = _safe_float(row.get("quality_per_time"), 0.0)
    qpd = _safe_float(row.get("quality_per_docking"), 0.0)
    p_est = _safe_float(row.get("estimated_probability_target_percentile"), 0.0)
    gain = _safe_float(row.get("marginal_expected_gain"), 0.0)

    if objective == "quality_per_time":
        return float(qpt)
    if objective == "quality_per_docking":
        return float(qpd)
    if objective == "rank_percentile_minimization":
        return float(-rank_pct)
    if objective == "regret_constrained_utility":
        return float((1.0 - q_loss) + 0.5 * red - 0.2 * gain)
    if objective == "target_percentile_attainment":
        hit = 1.0 if float(rank_pct) <= float(target_percentile) else 0.0
        return float(2.0 * hit + 0.5 * red + p_est - 0.1 * gain)
    if objective == "hybrid_objective":
        return float(0.35 * qpt + 0.25 * qpd + 0.25 * (1.0 - q_loss) + 0.15 * p_est - 0.15 * (rank_pct / 100.0))
    raise ValueError(f"Unsupported objective `{objective}`")


def is_trivial_objective_solution(best_budget: int, budget_grid: Sequence[int]) -> bool:
    if not budget_grid:
        return False
    low = min(int(x) for x in budget_grid)
    return int(best_budget) <= int(low)