File size: 4,209 Bytes
04ae9bb | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 | """Concatenate fold-fitted protein embeddings with current-visit features."""
from __future__ import annotations
import json
from pathlib import Path
import numpy as np
import torch
from sklearn.decomposition import PCA
from ampd.evaluation.decision import smape_optimal_point
from ampd.latent_encoder import LatentPredictor
from ampd.models import build_model
from ampd.protein_representation import RepresentationPredictor, current_process, standardize_fit
ARMS = ("latent_concat", "count_control", "missing_pca_control")
def fit_input_parameters(process_params, train_proteins, train_latent, all_training_proteins):
params = {"process_mean": process_params["process_mean"], "process_scale": process_params["process_scale"]}
latent_mean, latent_scale = standardize_fit(np.asarray(train_latent, dtype=float))
params.update(latent_mean=latent_mean, latent_scale=latent_scale)
count = np.isfinite(train_proteins).sum(1, keepdims=True).astype(float)
mean, scale = standardize_fit(count)
params.update(count_mean=mean, count_scale=scale)
missing = (~np.isfinite(all_training_proteins)).astype(float)
mean, scale = standardize_fit(missing)
pca = PCA(n_components=8, svd_solver="full").fit((missing-mean)/scale)
params.update(missing_mean=mean, missing_scale=scale, missing_center=pca.mean_, missing_components=pca.components_)
training_projection = missing_features(train_proteins, params)
mean, scale = standardize_fit(training_projection)
params.update(missing_latent_mean=mean, missing_latent_scale=scale)
return params
def missing_features(proteins, params):
missing = (~np.isfinite(proteins)).astype(float)
x = (missing-params["missing_mean"])/params["missing_scale"]
return (x-params["missing_center"]) @ params["missing_components"].T
def classifier_features(method, months, proteins, latent, params):
process = (current_process(months)-params["process_mean"])/params["process_scale"]
extra = np.zeros((len(months), 16))
if method == "latent_concat":
extra[:, :8] = (latent-params["latent_mean"])/params["latent_scale"]
elif method == "count_control":
count = np.isfinite(proteins).sum(1, keepdims=True).astype(float)
extra[:, :1] = (count-params["count_mean"])/params["count_scale"]
elif method == "missing_pca_control":
extra[:, :8] = (missing_features(proteins, params)-params["missing_latent_mean"])/params["missing_latent_scale"]
elif method != "none":
raise ValueError(method)
return np.c_[process, extra].astype(np.float32)
class LatentConcatPredictor:
def __init__(self, bundle):
bundle = Path(bundle)
self.spec = json.loads((bundle/"model.json").read_text())
self.baseline = RepresentationPredictor(bundle/"baseline")
self.encoder = LatentPredictor(bundle/"encoder")
if self.baseline.spec["proteins"] != self.encoder.spec["proteins"]:
raise ValueError("Baseline/encoder protein vocabularies do not align")
with np.load(bundle/"inputs.npz", allow_pickle=False) as archive:
self.params = dict(archive)
self.models = {}
for method in ARMS:
self.models[method] = []
for seed in self.spec["seeds"]:
model = build_model(self.spec["model"], 30, 16)
model.load_state_dict(torch.load(bundle/method/f"seed_{seed}.pt", map_location="cpu", weights_only=True))
self.models[method].append(model.eval())
def predict(self, events):
baseline = self.baseline.predict(events)
latent = self.encoder.predict(events)
months = np.asarray([e["visit_month"] for e in events], dtype=float)
proteins = np.asarray([e["proteins"] for e in events], dtype=float)
result = {"none": baseline}
with torch.no_grad():
for method, models in self.models.items():
x = torch.tensor(classifier_features(method, months, proteins, latent, self.params))
probabilities = torch.stack([model(x).softmax(-1) for model in models]).mean(0)
result[method] = smape_optimal_point(probabilities).numpy()
return result
|