from pathlib import Path import numpy as np import pandas as pd import torch import torch.nn as nn from torch.utils.data import DataLoader from sklearn.metrics import average_precision_score from ..atlas.dataset import PairDataset from ..atlas.model_mlp import AtlasMLP from ..utils.io import load_cfg, set_seed, save_json def _train_model(ds: PairDataset, lr: float, epochs: int, batch_size: int, device: str) -> AtlasMLP: model = AtlasMLP().to(device).train() optimizer = torch.optim.AdamW(model.parameters(), lr=lr) loader = DataLoader(ds, batch_size=batch_size, shuffle=True) for _ in range(epochs): for p, l, y, _, _ in loader: p, l, y = p.to(device), l.to(device), y.squeeze(-1).to(device) loss = nn.functional.binary_cross_entropy_with_logits(model(p, l), y) optimizer.zero_grad(); loss.backward(); optimizer.step() return model.eval() @torch.no_grad() def _predict_proba(model: AtlasMLP, ds: PairDataset, batch_size: int, device: str) -> np.ndarray: loader = DataLoader(ds, batch_size=batch_size, shuffle=False) probs = [] for p, l, _, _, _ in loader: probs.append(torch.sigmoid(model(p.to(device), l.to(device))).cpu().numpy()) return np.concatenate(probs) def _scores_uncertainty(model, pool_ds, batch_size, device): """Predictive entropy: max at p=0.5.""" p = _predict_proba(model, pool_ds, batch_size, device) entropy = -p * np.log(p + 1e-9) - (1 - p) * np.log(1 - p + 1e-9) return entropy def _scores_diversity(model, pool_ds, labeled_ds, batch_size, device): """ Mean embedding distance from pool point to nearest labeled point. Uses concatenated (protein, ligand) embeddings as feature space. """ def _embeddings(ds): embs = [] for p, l, _, _, _ in DataLoader(ds, batch_size=batch_size): embs.append(torch.cat([p, l], dim=-1).numpy()) return np.concatenate(embs) pool_emb = _embeddings(pool_ds) labeled_emb = _embeddings(labeled_ds) pool_n = pool_emb / (np.linalg.norm(pool_emb, axis=1, keepdims=True) + 1e-9) labeled_n = labeled_emb / (np.linalg.norm(labeled_emb, axis=1, keepdims=True) + 1e-9) sims = pool_n @ labeled_n.T return 1.0 - sims.max(axis=1) def _scores_causal(pool_ds, causal_effects: dict) -> np.ndarray: """ Causal weight: prioritize pairs from high-ATE transporters. causal_effects : {gene_name: ATE_value} (positive = protective) """ weights = np.zeros(len(pool_ds.pairs)) for i, (ti, _ci, _y) in enumerate(pool_ds.pairs): gene = pool_ds.Tnames[ti] if hasattr(pool_ds, "Tnames") else str(ti) weights[i] = abs(causal_effects.get(gene, 0.0)) return weights / (weights.max() + 1e-9) def run_active_learning( cfg_path: str = "env/config.yaml", strategy: str = "uncertainty", causal_csv: str = "results/causal_effects.csv", ) -> dict: """ Run a pool-based active learning simulation. Returns a dict with AUPRC at each round for the chosen strategy. """ cfg = load_cfg(cfg_path) set_seed(cfg["training"]["seed"]) device = "cuda" if torch.cuda.is_available() else "cpu" proc = Path(cfg["paths"]["processed"]) res = Path(cfg["paths"]["results"]) res.mkdir(parents=True, exist_ok=True) al_cfg = cfg["active_learning"] tr_cfg = cfg["training"] full_ds = PairDataset(proc) n = len(full_ds.pairs) rng = np.random.default_rng(tr_cfg["seed"]) causal_effects = {} if strategy in ("causal", "hybrid") and Path(causal_csv).exists(): df_c = pd.read_csv(causal_csv) causal_effects = dict(zip(df_c["gene"], df_c["ATE"].abs())) init_k = int(al_cfg["init_frac"] * n) acquire_k = int(al_cfg["acquire_per_iter"] * n) labeled = set(rng.choice(n, size=init_k, replace=False).tolist()) pool = set(range(n)) - labeled curve_fracs, curve_auprc = [], [] for it in range(al_cfg["iters"]): labeled_list = sorted(labeled) pool_list = sorted(pool) ds_labeled = PairDataset(proc, labeled_list) ds_pool = PairDataset(proc, pool_list) model = _train_model(ds_labeled, tr_cfg["lr"], epochs=8, batch_size=tr_cfg["batch_size"], device=device) if strategy == "random": scores = rng.random(len(pool_list)) elif strategy == "uncertainty": scores = _scores_uncertainty(model, ds_pool, tr_cfg["batch_size"], device) elif strategy == "diversity": scores = _scores_diversity(model, ds_pool, ds_labeled, tr_cfg["batch_size"], device) elif strategy == "causal": scores = _scores_causal(ds_pool, causal_effects) elif strategy == "hybrid": s_unc = _scores_uncertainty(model, ds_pool, tr_cfg["batch_size"], device) s_causal = _scores_causal(ds_pool, causal_effects) scores = 0.5 * s_unc / (s_unc.max() + 1e-9) + 0.5 * s_causal else: raise ValueError(f"Unknown strategy: {strategy!r}") acquire_k_actual = min(acquire_k, len(pool_list)) top_local = np.argsort(scores)[::-1][:acquire_k_actual] newly_labeled = {pool_list[i] for i in top_local} labeled |= newly_labeled pool -= newly_labeled hold_size = min(int(0.2 * n), len(pool)) if hold_size > 0: hold_idx = rng.choice(sorted(pool), size=hold_size, replace=False) ds_hold = PairDataset(proc, hold_idx.tolist()) probs = _predict_proba(model, ds_hold, tr_cfg["batch_size"] * 2, device) y_hold = np.array([y for _, _, y in ds_hold.pairs]) ap = float(average_precision_score(y_hold, probs)) else: ap = float("nan") frac = len(labeled) / n curve_fracs.append(frac) curve_auprc.append(ap) print(f" iter={it+1} labeled={len(labeled)}/{n} ({frac:.2%}) AUPRC={ap:.4f}") snapshot = { "strategy": strategy, "curves": {"fracs": curve_fracs, "auprc": curve_auprc}, } save_json(snapshot, res / f"al_section4_{strategy}_snapshot.json") return snapshot