"""Frozen protein AE latent -> MLP residual prediction.""" from __future__ import annotations import json from pathlib import Path import numpy as np import torch from sklearn.linear_model import Ridge from ampd.ae_latent_selection import MONTHS, encode, errors, month_features, quality_features from ampd.evaluation.decision import smape_optimal_point from ampd.models import build_model ARMS = ("all_latent_r", "selected_latent_r", "residual_ranked_r", "residual_fdr_r", "month_r", "missingness_r") ALPHAS = (1., 10., 100., 1000.) WEIGHTS = (0., .1, .25, .5, 1.) TOP_K = (2, 4, 8, 16) def current_process(months): months = np.asarray(months, dtype=float) return np.c_[np.where(months[:, None] == MONTHS, 1., -1.), -np.ones((len(months), 3)), months] def fit_baseline_pre(months): x = current_process(months) scale = x.std(0) return {"process_mean": x.mean(0), "process_scale": np.where(scale > 0, scale, 1.), "feature_mean": np.zeros(16), "feature_scale": np.ones(16)} def baseline_features(months, pre): process = (current_process(months)-pre["process_mean"])/pre["process_scale"] zeros = np.broadcast_to(-pre["feature_mean"]/pre["feature_scale"], (len(months), 16)) return np.c_[process, zeros].astype(np.float32) class FrozenMonthMLP: def __init__(self, bundle): bundle = Path(bundle) self.spec = json.loads((bundle/"model.json").read_text()) if self.spec["method"] != "none": raise ValueError("Residual baseline must be the no-protein model") self.pre = dict(np.load(bundle/"extractor.npz", allow_pickle=False)) self.models = [] for seed in self.spec["seeds"]: model = build_model(self.spec["model"], 30, 16) model.load_state_dict(torch.load(bundle/f"seed_{seed}.pt", weights_only=True, map_location="cpu")) self.models.append(model.eval()) def predict(self, months): x = torch.tensor(baseline_features(months, self.pre)) with torch.no_grad(): probabilities = torch.stack([model(x).softmax(-1) for model in self.models]).mean(0) return smape_optimal_point(probabilities).numpy() def fit_feature_pre(months, proteins, latent): out = {} for name, x in [("latent", latent), ("month", month_features(months)), ("quality", quality_features(proteins))]: scale = x.std(0) out[f"{name}_mean"], out[f"{name}_scale"] = x.mean(0), np.where(scale > 1e-12, scale, 1.) return out def features(months, proteins, latent, arm, pre): if arm == "month_r": name, x = "month", month_features(months) elif arm == "missingness_r": name, x = "quality", quality_features(proteins) else: name, x = "latent", latent return (x-pre[f"{name}_mean"])/pre[f"{name}_scale"] def fit_residual(x, y, baseline, arm, mask, alpha): coefficients = [] for head in range(16): active = np.ones(x.shape[1], dtype=bool) if arm in {"month_r", "missingness_r"} else mask[head//4] valid = np.isfinite(y[:, head]) model = Ridge(alpha=alpha, fit_intercept=False, solver="cholesky").fit( x[valid]*active, y[valid, head]-baseline[valid, head]) coefficients.append(model.coef_*active) return np.stack(coefficients) def correct(baseline, residual, weights): weights = np.repeat(np.asarray(weights, dtype=float), 4) prediction = np.clip(baseline+residual*weights, 0., 86.) return np.where(weights == 0, baseline, prediction) def choose_weights(y, baseline, residual): weights = [] for target in range(4): cols = slice(4*target, 4*(target+1)) scores = [float(np.nanmean(errors(y[:, cols], np.clip(baseline[:, cols]+w*residual[:, cols], 0, 86)))) for w in WEIGHTS] selected = next(i for i, value in enumerate(scores) if value <= min(scores)+1e-10) weights.append(WEIGHTS[selected]) return weights, float(np.nanmean(errors(y, correct(baseline, residual, weights)))) class AEResidualPredictor: def __init__(self, bundle, arms=ARMS): bundle = Path(bundle) self.spec = json.loads((bundle/"model.json").read_text()) self.baseline = FrozenMonthMLP(bundle/"baseline") self.pre = dict(np.load(bundle/"protein_preprocessor.npz", allow_pickle=False)) self.network = dict(np.load(bundle/"autoencoder_numeric.npz", allow_pickle=False)) self.feature_pre = dict(np.load(bundle/"feature_preprocessor.npz", allow_pickle=False)) if any(arm not in ARMS for arm in arms): raise ValueError("Unknown residual arm") self.heads = {arm: dict(np.load(bundle/f"{arm}.npz", allow_pickle=False)) for arm in arms} def encode(self, proteins): return encode(proteins, self.pre, self.network) def components(self, events): for event in events: if set(event) != {"visit_id", "visit_month", "proteins"}: raise ValueError("Only current visit_id, visit_month and proteins are accepted") if len(event["proteins"]) != len(self.spec["proteins"]): raise ValueError("Protein vocabulary mismatch") proteins = np.asarray([e["proteins"] for e in events], dtype=float) months = np.asarray([e["visit_month"] for e in events], dtype=float) latent = self.encode(proteins) baseline = self.baseline.predict(months) residuals, predictions = {}, {"baseline": baseline} for arm, head in self.heads.items(): x = features(months, proteins, latent, arm, self.feature_pre) residuals[arm] = x @ head["coef"].T predictions[arm] = correct(baseline, residuals[arm], head["weights"]) return {"latent": latent, "baseline": baseline, "raw_residuals": residuals, "predictions": predictions} def predict(self, events): return self.components(events)["predictions"]