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