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: # If conservative deprioritization exhausted active queue, reactivate # deprioritized candidates to continue spending the docking budget. 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] = [] # Broad initial coverage. 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) # Fill remaining slots by priority. 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]: # Mark completed ligands and store latest score. 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) # Predict for active items. 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)