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