maxffarrell's picture
Release experimental Transition Foundation Model v0.1 with reproducible source and validation
1baf215 verified
Raw History Blame Contribute Delete
6.79 kB
"""History-only baselines with the exact same delta-query interface."""
from __future__ import annotations
import numpy as np
import torch
class PersistenceBaseline(torch.nn.Module):
def __init__(self, std=0.1):
super().__init__()
self.std = std
def forward(self, batch):
mean = torch.zeros_like(batch["query_horizons"])
return mean, torch.full_like(mean, float(np.log(self.std)))
class HistoryLinearBaseline(torch.nn.Module):
"""Fit a local affine controlled state transition separately for each window.
Ridge is centered on persistence. Only observed historical transition pairs
are fitted, then planned actions and exogenous inputs are rolled out. Hidden
simulator parameters, future targets, and test-wide fitting are prohibited.
"""
def __init__(self, role_ids, ridge=1.0, min_std=0.05, dt_minutes=15):
super().__init__()
self.roles = np.asarray(role_ids)
self.ridge, self.min_std, self.dt_minutes = ridge, min_std, dt_minutes
def forward(self, batch):
device = batch["history"].device
values = {k: v.detach().cpu().numpy() for k, v in batch.items() if torch.is_tensor(v)}
outputs, uncertainty = [], []
for index in range(len(values["history"])):
history, mask = values["history"][index], values["history_mask"][index].astype(bool)
active = values["field_mask"][index].astype(bool)
state_ids = np.flatnonzero(active & (self.roles == 0))
input_ids = np.flatnonzero(active & (self.roles != 0))
current = values["current"][index, state_ids].astype(float)
# Impute absent current fields only from this window's observations.
for j, field in enumerate(state_ids):
if not values["current_mask"][index, field]:
observed = np.flatnonzero(mask[:, field])
current[j] = history[observed[-1], field] if len(observed) else 0
features = np.concatenate(
[history[:-1, state_ids], history[:-1, input_ids], np.ones((len(history) - 1, 1))], axis=1
)
targets = history[1:, state_ids] - history[:-1, state_ids]
valid = mask[:-1, state_ids].all(axis=1) & mask[1:, state_ids].all(axis=1)
if len(input_ids):
valid &= mask[:-1, input_ids].all(axis=1)
x, y = features[valid], targets[valid]
if len(x):
coef = np.linalg.solve(x.T @ x + self.ridge * np.eye(x.shape[1]), x.T @ y)
residual_std = np.maximum(np.sqrt(np.mean((y - x @ coef) ** 2, axis=0)), self.min_std)
else:
coef = np.zeros((features.shape[1], len(state_ids)))
residual_std = np.full(len(state_ids), self.min_std)
predicted, state = [], current.copy()
for actions, exogenous in zip(values["future_actions"][index], values["future_exogenous"][index]):
inputs = (actions + exogenous)[input_ids]
state = state + np.concatenate([state, inputs, [1]]) @ coef
predicted.append(state.copy())
means, stds = [], []
lookup = {int(field): j for j, field in enumerate(state_ids)}
for field, horizon in zip(values["query_fields"][index], values["query_horizons"][index]):
steps = round(float(horizon) / self.dt_minutes)
if steps < 1 or steps > len(predicted) or field not in lookup:
means.append(0.0)
stds.append(self.min_std)
continue
j = lookup[int(field)]
means.append(predicted[steps - 1][j] - current[j])
stds.append(residual_std[j] * np.sqrt(steps))
outputs.append(means)
uncertainty.append(np.log(stds))
return (
torch.tensor(np.asarray(outputs), dtype=torch.float32, device=device),
torch.tensor(np.asarray(uncertainty), dtype=torch.float32, device=device),
)
def catboost_features(batch):
"""Canonical masks and semantic query tokens; no family or system metadata."""
keys = (
"history",
"history_mask",
"history_dt",
"current",
"current_mask",
"future_actions",
"future_exogenous",
"future_dt",
"field_mask",
)
n = len(batch["history"])
q = batch["query_fields"].shape[1]
parts = []
before_query = (
np.asarray(batch["future_dt"])[:, None, :] <= np.asarray(batch["query_horizons"])[:, :, None]
)
for key in keys:
expanded = np.repeat(np.asarray(batch[key])[:, None], q, axis=1)
if key in ("future_actions", "future_exogenous"):
expanded = expanded * before_query[:, :, :, None]
elif key == "future_dt":
expanded = expanded * before_query
parts.append(expanded.reshape(n * q, -1))
return np.concatenate(
[
*parts,
np.asarray(batch["query_fields"]).reshape(-1, 1),
np.asarray(batch["query_horizons"]).reshape(-1, 1),
],
axis=1,
)
class CatBoostBaseline:
"""Optional pooled query regression fitted on training windows only."""
def __init__(self, iterations=200, seed=0):
self.iterations, self.seed = iterations, seed
def fit(self, batch, *, training_system_ids, fitted_system_ids):
if not set(fitted_system_ids) <= set(training_system_ids) or not fitted_system_ids:
raise ValueError("CatBoost may only be fitted on nonempty training systems")
from catboost import CatBoostRegressor
features, mask = catboost_features(batch), np.asarray(batch["target_mask"]).reshape(-1).astype(bool)
targets = np.asarray(batch["target"]).reshape(-1)
self.model = CatBoostRegressor(
iterations=self.iterations,
depth=6,
learning_rate=0.05,
random_seed=self.seed,
verbose=False,
allow_writing_files=False,
)
self.model.fit(features[mask], targets[mask])
residual = targets[mask] - self.model.predict(features[mask])
self.std = max(float(np.sqrt(np.mean(residual**2))), 0.05)
self.fitted_system_ids = sorted(set(fitted_system_ids))
return self
def __call__(self, batch):
numpy_batch = {k: v.detach().cpu().numpy() if torch.is_tensor(v) else v for k, v in batch.items()}
mean = self.model.predict(catboost_features(numpy_batch)).reshape(batch["query_fields"].shape)
device = batch["history"].device
mean = torch.tensor(mean, dtype=torch.float32, device=device)
return mean, torch.full_like(mean, np.log(self.std))