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