Release experimental Transition Foundation Model v0.1 with reproducible source and validation
1baf215 verified Download tfm/evaluation/baselines.py from maxffarrell/transition-foundation-model: direct link, hf CLI and curl.
- Browser
- Download file 6.79 kB
-
https://huggingface.co/maxffarrell/transition-foundation-model/resolve/main/tfm/evaluation/baselines.py
- Command line
-
hf download hf://maxffarrell/transition-foundation-model/tfm/evaluation/baselines.py
-
curl -L -o baselines.py https://huggingface.co/maxffarrell/transition-foundation-model/resolve/main/tfm/evaluation/baselines.py
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)) | |