"""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