| from __future__ import annotations |
|
|
| from dataclasses import dataclass, field |
| from pathlib import Path |
| from typing import Dict, List |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| from .metrics import score_metrics |
| from .policies import PrioritizationPolicy |
| from .prioritization import cluster_bonus, compute_priority |
| from .queue_manager import QueueManager |
| from .state import QueueItem, SchedulerState |
| from .surrogate_model import SurrogateConfig, SurrogateModel |
| from .weight_schedule import WeightScheduleConfig, compute_model_weight |
|
|
|
|
| @dataclass |
| class SchedulerConfig: |
| batch_size: int = 8 |
| init_coverage_fraction: float = 0.25 |
| conservative_deprioritize: bool = True |
| state_path: str = "results/state.json" |
| weight_schedule: WeightScheduleConfig = field(default_factory=WeightScheduleConfig) |
|
|
|
|
| class AdaptiveScheduler: |
| """Adaptive batch scheduler with queue state and online masked surrogate updates.""" |
|
|
| def __init__( |
| self, |
| config: SchedulerConfig | None = None, |
| policy: PrioritizationPolicy | None = None, |
| surrogate_config: SurrogateConfig | None = None, |
| ) -> None: |
| self.config = config or SchedulerConfig() |
| self.policy = policy or PrioritizationPolicy() |
| self.surrogate = SurrogateModel(surrogate_config) |
| self.state = SchedulerState() |
| self.queue_manager = QueueManager.from_items([]) |
| self.last_model_weight: float = 0.0 |
|
|
| def initialize( |
| self, |
| ligands_df: pd.DataFrame, |
| cluster_map: Dict[str, int], |
| hypercluster_for_cluster: Dict[int, int], |
| ) -> None: |
| items: List[QueueItem] = [] |
| cluster_load: Dict[int, int] = {} |
|
|
| for row in ligands_df.itertuples(index=False): |
| ligand_id = str(row.ligand_id) |
| cluster_id = int(cluster_map.get(ligand_id, -1)) |
| hypercluster_id = int(hypercluster_for_cluster.get(cluster_id, -1)) |
| bonus = cluster_bonus(cluster_load, cluster_id) |
| priority = compute_priority( |
| predicted_utility=0.0, |
| uncertainty=1.0, |
| diversity_gain=bonus, |
| cluster_bonus=bonus, |
| policy=self.policy, |
| ) |
| items.append( |
| QueueItem( |
| ligand_id=ligand_id, |
| status="active", |
| priority=float(priority), |
| cluster_id=cluster_id, |
| hypercluster_id=hypercluster_id, |
| ) |
| ) |
| cluster_load[cluster_id] = cluster_load.get(cluster_id, 0) + 1 |
|
|
| self.state = SchedulerState(queue=items, batch_history=[], round_idx=0) |
| self.queue_manager = QueueManager.from_items(items) |
|
|
| def select_batch(self) -> List[str]: |
| active = self.queue_manager.ordered_active() |
| if not active: |
| |
| |
| deprioritized = sorted( |
| [item for item in self.queue_manager.items.values() if item.status == "deprioritized"], |
| key=lambda item: item.priority, |
| reverse=True, |
| ) |
| if not deprioritized: |
| return [] |
| for item in deprioritized: |
| item.status = "active" |
| active = deprioritized |
|
|
| coverage_count = max(1, int(self.config.batch_size * self.config.init_coverage_fraction)) |
| by_hypercluster: Dict[int, List[QueueItem]] = {} |
| for item in active: |
| by_hypercluster.setdefault(item.hypercluster_id, []).append(item) |
|
|
| selected: List[str] = [] |
| |
| for _h_id, items in sorted(by_hypercluster.items(), key=lambda x: len(x[1]), reverse=True): |
| if len(selected) >= coverage_count: |
| break |
| selected.append(items[0].ligand_id) |
|
|
| |
| for item in active: |
| if len(selected) >= self.config.batch_size: |
| break |
| if item.ligand_id not in selected: |
| selected.append(item.ligand_id) |
|
|
| for ligand_id in selected: |
| self.queue_manager.items[ligand_id].times_selected += 1 |
| return selected |
|
|
| @staticmethod |
| def _mean_or_default(values: list[float], default: float = 0.0) -> float: |
| if not values: |
| return float(default) |
| return float(np.mean(np.asarray(values, dtype=float))) |
|
|
| def update_from_batch( |
| self, |
| evaluated_df: pd.DataFrame, |
| feature_values_df: pd.DataFrame, |
| feature_masks_df: pd.DataFrame, |
| ) -> Dict[str, float]: |
| |
| score_map = dict(zip(evaluated_df["ligand_id"].astype(str), evaluated_df["docking_score"].astype(float))) |
| for ligand_id, score in score_map.items(): |
| if ligand_id in self.queue_manager.items: |
| item = self.queue_manager.items[ligand_id] |
| item.status = "completed" |
| item.last_score = float(score) |
|
|
| if feature_values_df.empty or feature_masks_df.empty: |
| raise ValueError("Feature tables cannot be empty in adaptive update") |
|
|
| if "ligand_id" not in feature_values_df.columns or "ligand_id" not in feature_masks_df.columns: |
| raise ValueError("Feature tables must include ligand_id column") |
|
|
| ligand_order = feature_values_df["ligand_id"].astype(str).tolist() |
| features = feature_values_df.drop(columns=["ligand_id"]).to_numpy(dtype=float) |
| masks = feature_masks_df.drop(columns=["ligand_id"]).to_numpy(dtype=float) |
| feature_names = feature_values_df.drop(columns=["ligand_id"]).columns.tolist() |
| mask_names = feature_masks_df.drop(columns=["ligand_id"]).columns.tolist() |
|
|
| target = np.full(len(ligand_order), np.nan, dtype=float) |
| for i, ligand_id in enumerate(ligand_order): |
| if ligand_id in self.queue_manager.items: |
| score = self.queue_manager.items[ligand_id].last_score |
| if score is not None: |
| target[i] = float(score) |
|
|
| fit_stats = self.surrogate.fit( |
| features=features, |
| masks=masks, |
| y=target, |
| feature_names=feature_names, |
| mask_names=mask_names, |
| ) |
|
|
| n_train = int(fit_stats.get("n_train", 0.0)) |
| instability_ratio = float(fit_stats.get("instability_ratio", 1.0)) |
| model_weight = compute_model_weight( |
| n_samples=n_train, |
| instability_ratio=instability_ratio, |
| config=self.config.weight_schedule, |
| ) |
| if self.surrogate.model is None: |
| model_weight = 0.0 |
| self.last_model_weight = float(model_weight) |
|
|
| |
| active_items = self.queue_manager.active_items() |
| active_ids = [item.ligand_id for item in active_items] |
|
|
| completed_items = [item for item in self.queue_manager.items.values() if item.last_score is not None] |
| global_completed = [float(item.last_score) for item in completed_items if item.last_score is not None] |
| global_mean_score = self._mean_or_default(global_completed, default=0.0) |
|
|
| cluster_scores: Dict[int, list[float]] = {} |
| hyper_scores: Dict[int, list[float]] = {} |
| for item in completed_items: |
| assert item.last_score is not None |
| cluster_scores.setdefault(item.cluster_id, []).append(float(item.last_score)) |
| hyper_scores.setdefault(item.hypercluster_id, []).append(float(item.last_score)) |
|
|
| if active_ids: |
| id_to_idx = {lid: idx for idx, lid in enumerate(ligand_order)} |
| x_active = np.vstack([features[id_to_idx[lid]] for lid in active_ids]) |
| m_active = np.vstack([masks[id_to_idx[lid]] for lid in active_ids]) |
| bundle = self.surrogate.predict_bundle(x_active, m_active) |
|
|
| cluster_load: Dict[int, int] = {} |
| for item in active_items: |
| cluster_load[item.cluster_id] = cluster_load.get(item.cluster_id, 0) + 1 |
|
|
| for i, ligand_id in enumerate(active_ids): |
| item = self.queue_manager.items[ligand_id] |
|
|
| cluster_mean = self._mean_or_default(cluster_scores.get(item.cluster_id, []), default=np.nan) |
| hyper_mean = self._mean_or_default(hyper_scores.get(item.hypercluster_id, []), default=np.nan) |
| observed_docking = ( |
| cluster_mean |
| if np.isfinite(cluster_mean) |
| else hyper_mean |
| if np.isfinite(hyper_mean) |
| else global_mean_score |
| ) |
|
|
| docking_component = -float(observed_docking) |
| model_component = -float(bundle["expected_score"][i]) |
| blended_utility = (1.0 - model_weight) * docking_component + model_weight * model_component |
|
|
| bonus = cluster_bonus(cluster_load, item.cluster_id) |
| item.priority = compute_priority( |
| predicted_utility=float(blended_utility), |
| uncertainty=float(bundle["uncertainty"][i]), |
| diversity_gain=bonus, |
| cluster_bonus=bonus, |
| policy=self.policy, |
| ) |
|
|
| if self.config.conservative_deprioritize: |
| priorities = np.asarray([self.queue_manager.items[lid].priority for lid in active_ids], dtype=float) |
| threshold = float(np.quantile(priorities, self.policy.conservative_deprioritize_quantile)) |
| for lid in active_ids: |
| if self.queue_manager.items[lid].priority < threshold: |
| self.queue_manager.items[lid].status = "deprioritized" |
|
|
| self.state.round_idx += 1 |
| sm = score_metrics(evaluated_df["docking_score"].astype(float).tolist()) |
| batch_record: Dict[str, float | str] = { |
| "round_idx": self.state.round_idx, |
| "batch_size": int(evaluated_df.shape[0]), |
| "model_weight": float(model_weight), |
| "n_train": float(n_train), |
| "train_mae": float(fit_stats.get("train_mae", np.nan)), |
| "val_mae": float(fit_stats.get("val_mae", np.nan)), |
| "instability_ratio": float(instability_ratio), |
| "surrogate_backend": self.surrogate.backend, |
| **sm, |
| } |
| self.state.batch_history.append(batch_record) |
| return fit_stats |
|
|
| def save_state(self, output_path: str | Path | None = None) -> Path: |
| target = Path(output_path or self.config.state_path) |
| self.state.queue = list(self.queue_manager.items.values()) |
| return self.state.save(target) |
|
|
