File size: 4,513 Bytes
c289d87 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | from __future__ import annotations
from dataclasses import dataclass
from typing import Iterable, List
import numpy as np
import pandas as pd
from libs.adaptive.policies import PrioritizationPolicy
def clamp_time_importance(value: float) -> float:
return float(max(0.0, min(1.0, float(value))))
@dataclass(frozen=True)
class TimeImportanceControls:
utility_weight: float
uncertainty_weight: float
diversity_weight: float
cluster_bonus_weight: float
threshold_stop_shift: float
exploration_additive: float
def controls_from_time_importance(
base_policy: PrioritizationPolicy,
*,
exploration_boost: float,
time_importance: float,
) -> TimeImportanceControls:
ti = clamp_time_importance(time_importance)
exp = float(max(0.0, exploration_boost))
adjusted_exp = float(max(0.0, exp + (1.0 - ti) * 0.22))
utility = max(0.15, float(base_policy.utility_weight) - 0.40 * adjusted_exp + 0.22 * ti)
uncertainty = max(0.05, float(base_policy.uncertainty_weight) + 0.22 * adjusted_exp - 0.10 * ti)
diversity = max(0.05, float(base_policy.diversity_weight) + 0.14 * adjusted_exp - 0.08 * ti)
cluster_bonus = float(base_policy.cluster_bonus_weight) + 0.04 * adjusted_exp
# Negative means easier stopping (more time-sensitive).
threshold_stop_shift = float(-0.20 * ti)
return TimeImportanceControls(
utility_weight=float(utility),
uncertainty_weight=float(uncertainty),
diversity_weight=float(diversity),
cluster_bonus_weight=float(cluster_bonus),
threshold_stop_shift=threshold_stop_shift,
exploration_additive=adjusted_exp,
)
def required_budget_metric_columns() -> List[str]:
return [
"dataset",
"strategy",
"strategy_group",
"budget",
"time_importance",
"top10_recovery_fraction",
"top50_recovery_fraction",
"top100_recovery_fraction",
"best_docking_score",
"best_final_score",
"dockings_performed",
"wall_time_seconds",
"quality_per_time",
"quality_per_docking",
"auc_best_score_so_far",
]
def validate_budget_metric_schema(df: pd.DataFrame) -> List[str]:
missing = [c for c in required_budget_metric_columns() if c not in df.columns]
return missing
def select_best_policy_budget(metrics_df: pd.DataFrame) -> pd.Series:
if metrics_df.empty:
raise ValueError("metrics_df is empty")
missing = validate_budget_metric_schema(metrics_df)
if missing:
raise ValueError(f"metrics_df missing required columns: {missing}")
d = metrics_df.copy()
if "strategy_group" in d.columns:
d = d[d["strategy_group"].astype(str) == "adaptive"].copy()
if d.empty:
raise ValueError("No adaptive rows found for selection")
for c in ["top10_recovery_fraction", "top50_recovery_fraction", "top100_recovery_fraction", "quality_per_time", "quality_per_docking"]:
d[f"rank_{c}"] = pd.to_numeric(d[c], errors="coerce").rank(method="average", ascending=False)
d["rank_budget"] = pd.to_numeric(d["budget"], errors="coerce").rank(method="average", ascending=True)
d["rank_best_final"] = pd.to_numeric(d["best_final_score"], errors="coerce").rank(method="average", ascending=True)
d["selection_score"] = (
0.24 * d["rank_top50_recovery_fraction"]
+ 0.24 * d["rank_top100_recovery_fraction"]
+ 0.20 * d["rank_top10_recovery_fraction"]
+ 0.12 * d["rank_quality_per_docking"]
+ 0.10 * d["rank_quality_per_time"]
+ 0.06 * d["rank_best_final"]
+ 0.04 * d["rank_budget"]
)
chosen = d.sort_values(["selection_score", "budget"], ascending=[True, True]).iloc[0]
return chosen
def summarize_diversity(df: pd.DataFrame, *, similarity_col: str = "reference_similarity", scaffold_col: str = "scaffold_core") -> pd.DataFrame:
vals = pd.to_numeric(df.get(similarity_col, pd.Series(dtype=float)), errors="coerce").dropna()
bins = np.linspace(0.0, 1.0, 11)
hist, edges = np.histogram(vals.to_numpy(dtype=float), bins=bins)
out = pd.DataFrame(
{
"bin_left": edges[:-1],
"bin_right": edges[1:],
"count": hist,
"fraction": hist / max(1, int(hist.sum())),
}
)
out["unique_scaffold_count"] = int(df.get(scaffold_col, pd.Series(dtype=str)).astype(str).replace({"": np.nan}).dropna().nunique())
out["total_ligands"] = int(df.shape[0])
return out
|