| 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) |
|
|
|
|
