Download code/ampd/ae_residual.py from fryabcfry/cs4486-amp-pd-checkpoints: direct link, hf CLI and curl.
- Browser
- Download file 5.9 kB
-
https://huggingface.co/fryabcfry/cs4486-amp-pd-checkpoints/resolve/main/code/ampd/ae_residual.py
- Command line
-
hf download hf://fryabcfry/cs4486-amp-pd-checkpoints/code/ampd/ae_residual.py
-
curl -L -o ae_residual.py https://huggingface.co/fryabcfry/cs4486-amp-pd-checkpoints/resolve/main/code/ampd/ae_residual.py
5.9 kB
| """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"] | |