File size: 7,600 Bytes
0d48417
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
"""Auditable adaptations of the AMP-PD first/fourth/fifth-place approaches.

The fifth-place numerical optimizers are loaded from the attributed audit
snapshot. No submission code, pretrained weights, or external labels are run.
"""
from __future__ import annotations

import ast
from pathlib import Path

import numpy as np
import pandas as pd
import scipy.optimize
import torch
from sklearn.utils import check_consistent_length
from torch import nn


def decision_from_distribution(probabilities, candidates=87):
    """Minimize expected SMAPE+1 over integer predictions, without true labels."""
    p = np.asarray(probabilities, dtype=float)
    values = np.arange(p.shape[1], dtype=float)[:, None]
    choices = np.arange(candidates, dtype=float)[None, :]
    loss = 200 * np.abs(values - choices) / (values + choices + 2)
    return (p @ loss).argmin(axis=1).astype(float)


def history_groups(samples, clinical, months):
    """Fifth-place sticky group update, restricted to the visible prefix."""
    calendars = clinical[clinical.visit_month.isin(months)].groupby("uid").visit_month.apply(list).to_dict()
    groups = []
    for row in samples.itertuples():
        past = [m for m in calendars[row.uid] if m <= row.visit_month]
        if any(m % 12 != 0 for m in past):
            groups.append("ill")
        elif row.visit_month >= 12:
            groups.append("healthy")
        else:
            groups.append("unknown")
    return np.asarray(groups)


def load_fifth_optimizers(path):
    names = {"smapep1", "optimize_smapep1", "calculate_predictions",
             "optimize_smapep1_linear", "optimize_smapep1_isotonic"}
    nodes = [node for node in ast.parse(Path(path).read_text()).body
             if isinstance(node, ast.FunctionDef) and node.name in names]
    assert {node.name for node in nodes} == names
    namespace = {"np": np, "scipy": scipy, "check_consistent_length": check_consistent_length}
    exec(compile(ast.Module(body=nodes, type_ignores=[]), str(path), "exec"), namespace)
    return namespace


class GroupTrends:
    """Fifth-place unknown constant / healthy isotonic / ill linear model.

    Only observed training targets are optimized. For healthy months absent from
    training, extend the last known step, with constant boundary extrapolation.
    """
    def __init__(self, optimizers):
        self.optimizers = optimizers
        self.parameters = {}

    def fit(self, frame):
        for target, df in frame.groupby("target"):
            fallback = self.optimizers["optimize_smapep1"](df.y_true.to_numpy())
            for group in ["unknown", "healthy", "ill"]:
                rows = df[df.group == group]
                if rows.empty:
                    self.parameters[(target, group)] = ("constant", float(fallback))
                elif group == "unknown":
                    value = self.optimizers["optimize_smapep1"](rows.y_true.to_numpy())
                    self.parameters[(target, group)] = ("constant", float(value))
                elif group == "healthy":
                    months, _, values = self.optimizers["optimize_smapep1_isotonic"](
                        rows.target_month.to_numpy(), rows.y_true.to_numpy())
                    self.parameters[(target, group)] = ("step", months, values)
                else:
                    parameters = self.optimizers["optimize_smapep1_linear"](
                        rows.target_month.to_numpy(), rows.y_true.to_numpy(), target)
                    self.parameters[(target, group)] = ("linear", parameters)
        return self

    def predict(self, frame):
        frame = frame.reset_index(drop=True)
        prediction = np.zeros(len(frame))
        for (target, group), rows in frame.groupby(["target", "group"]):
            spec = self.parameters[(target, group)]
            months = rows.target_month.to_numpy()
            if spec[0] == "constant":
                value = np.full(len(rows), spec[1])
            elif spec[0] == "step":
                index = np.searchsorted(spec[1], months, side="right") - 1
                value = spec[2][np.clip(index, 0, len(spec[2]) - 1)]
            else:
                value = self.optimizers["calculate_predictions"](months, spec[1], target)
            prediction[rows.index.to_numpy()] = value
        return prediction


def fourth_mlp(input_dim):
    layers = []
    for _ in range(10):
        layers.extend([nn.Linear(input_dim, 24), nn.ReLU()])
        input_dim = 24
    layers.append(nn.Linear(24, 1))
    return nn.Sequential(*layers)


def first_mlp(input_dim):
    return nn.Sequential(nn.Linear(input_dim, 64), nn.ReLU(), nn.Linear(64, 64),
                         nn.ReLU(), nn.Linear(64, 1), nn.LeakyReLU(.01))


def rounded(predictions):
    return np.rint(np.clip(predictions, 0, None))


def smape(y, predictions):
    return float(np.mean(200 * np.abs(y - predictions) / (np.abs(y) + np.abs(predictions) + 2)))


def train_nn(X, y, seed, family, epochs, validation=None):
    """Fixed fourth-place schedule, or inner-selected first-style SMAPE training."""
    torch.manual_seed(seed)
    model = fourth_mlp(X.shape[1]) if family == "fourth" else first_mlp(X.shape[1])
    optimizer = torch.optim.Adam(model.parameters(), lr=.001)
    inputs = torch.tensor(X, dtype=torch.float32)
    labels = torch.tensor(y, dtype=torch.float32)
    rng = np.random.default_rng(seed)
    batch = 32 if family == "fourth" else 256
    history, best_epoch, best_score, stale = [], epochs, float("inf"), 0
    if validation is not None:
        vx = torch.tensor(validation[0], dtype=torch.float32)
        vy = validation[1]
    for epoch in range(1, epochs + 1):
        if family == "fourth" and epoch == 13:
            # The original recompiles with a fresh Adam optimizer at this point.
            optimizer = torch.optim.Adam(model.parameters(), lr=.0001)
        elif family == "first":
            rate = .00001 + .5 * (.001 - .00001) * (1 + np.cos(np.pi * (epoch - 1) / 100))
            for group in optimizer.param_groups:
                group["lr"] = rate
        model.train()
        total = 0.0
        for indices in np.array_split(rng.permutation(len(X)), max(1, int(np.ceil(len(X) / batch)))):
            prediction = model(inputs[indices]).ravel()
            if family == "fourth":
                loss = (prediction - labels[indices]).abs().mean()
            else:
                loss = ((prediction - labels[indices]).abs() /
                        ((prediction.abs() + labels[indices].abs()) / 2 + 1)).mean()
            if not torch.isfinite(loss):
                raise RuntimeError("Non-finite training loss")
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            total += float(loss.detach()) * len(indices)
        entry = {"epoch": epoch, "train_loss": total / len(X), "lr": optimizer.param_groups[0]["lr"]}
        if validation is not None:
            model.eval()
            with torch.no_grad():
                value = model(vx).ravel().numpy()
            score = smape(vy, rounded(value))
            entry["inner_smape"] = score
            if score < best_score - .0001:
                best_score, best_epoch, stale = score, epoch, 0
            else:
                stale += 1
            if epoch >= 30 and stale >= 20:
                history.append(entry)
                break
        history.append(entry)
    model.eval()
    return model, history, best_epoch


def nn_predict(model, X):
    with torch.no_grad():
        return model(torch.tensor(X, dtype=torch.float32)).ravel().numpy().astype(float)