from __future__ import annotations import json from pathlib import Path import pandas as pd import torch import trackio from model import CalibratedDiscreteTransition, NeuralVectorField, parameter_count from safetensors.torch import save_file from torch.nn import functional as F PROJECT_DIR = Path(__file__).resolve().parent ARTIFACT_DIR = PROJECT_DIR / "artifacts" / "neural-ode-pocket" DATA_DIR = PROJECT_DIR / "data" SEED = 2213 def true_field(state: torch.Tensor) -> torch.Tensor: x, velocity = state[:, :1], state[:, 1:] return torch.cat( [velocity, 1.5 * (1 - x.square()) * velocity - x], dim=1, ) def true_step(state: torch.Tensor, delta_time: torch.Tensor) -> torch.Tensor: k1 = true_field(state) k2 = true_field(state + 0.5 * delta_time * k1) k3 = true_field(state + 0.5 * delta_time * k2) k4 = true_field(state + delta_time * k3) return state + delta_time * (k1 + 2 * k2 + 2 * k3 + k4) / 6 @torch.inference_mode() def rollout( model: torch.nn.Module, initial: torch.Tensor, delta_time: float, steps: int, *, continuous: bool, ) -> torch.Tensor: state = initial output = [] dt = torch.full((len(initial), 1), delta_time) for _ in range(steps): state = model.step(state, dt) if continuous else model(state, dt) output.append(state) return torch.stack(output, dim=1) @torch.inference_mode() def true_rollout( initial: torch.Tensor, delta_time: float, steps: int, ) -> torch.Tensor: state = initial output = [] dt = torch.full((len(initial), 1), delta_time) for _ in range(steps): state = true_step(state, dt) output.append(state) return torch.stack(output, dim=1) def first_failure(error: torch.Tensor, threshold: float = 0.5) -> float: horizons = [] for row in error: failures = torch.nonzero(row > threshold) horizons.append(int(failures[0]) if len(failures) else len(row)) return float(sum(horizons) / len(horizons)) @torch.inference_mode() def evaluate( model: torch.nn.Module, delta_time: float, steps: int, *, continuous: bool, ) -> dict: generator = torch.Generator().manual_seed(SEED + int(delta_time * 1000)) initial = -2.5 + 5 * torch.rand(500, 2, generator=generator) truth = true_rollout(initial, delta_time, steps) prediction = rollout( model, initial, delta_time, steps, continuous=continuous ) error = (prediction - truth).square().sum(2).sqrt() return { "trajectory_rmse": float((prediction - truth).square().mean().sqrt()), "final_state_rmse": float( (prediction[:, -1] - truth[:, -1]).square().mean().sqrt() ), "mean_horizon_before_error_0.5": first_failure(error), "delta_time": delta_time, "steps": steps, "initial_conditions": len(initial), } def train_variant( name: str, model: torch.nn.Module, *, continuous: bool, ) -> torch.nn.Module: optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-6) best = float("inf") best_state = None validation_generator = torch.Generator().manual_seed(SEED + 10_000) validation_state = -3 + 6 * torch.rand(5_000, 2, generator=validation_generator) validation_dt = torch.full((len(validation_state), 1), 0.05) validation_target = true_step(validation_state, validation_dt) for step in range(1, 5_001): generator = torch.Generator().manual_seed(SEED + step) state = -3 + 6 * torch.rand(512, 2, generator=generator) dt = torch.full((len(state), 1), 0.05) target = true_step(state, dt) prediction = model.step(state, dt) if continuous else model(state, dt) loss = F.mse_loss(prediction, target) optimizer.zero_grad(set_to_none=True) loss.backward() optimizer.step() if step % 250 == 0: with torch.inference_mode(): validation_prediction = ( model.step(validation_state, validation_dt) if continuous else model(validation_state, validation_dt) ) validation_rmse = float( (validation_prediction - validation_target) .square() .mean() .sqrt() ) trackio.log( { "variant": name, "training_step": step, "training_mse": float(loss.detach()), "validation_one_step_rmse": validation_rmse, } ) if validation_rmse < best: best = validation_rmse best_state = { key: value.detach().cpu().clone() for key, value in model.state_dict().items() } assert best_state is not None model.load_state_dict(best_state) return model def main() -> None: torch.manual_seed(SEED) torch.set_num_threads(1) models = { "neural_ode_rk4": (NeuralVectorField(), True), "discrete_transition": (CalibratedDiscreteTransition(), False), } assert {parameter_count(item[0]) for item in models.values()} == {1_218} trackio.init( project="neural-ode-pocket", name="van-der-pol-rk4-v1", config={ "parameters_per_model": 1_218, "training_delta_time": 0.05, "training_steps": 5_000, }, ) results = {} ARTIFACT_DIR.mkdir(parents=True, exist_ok=True) DATA_DIR.mkdir(parents=True, exist_ok=True) for name, (model, continuous) in models.items(): model = train_variant(name, model, continuous=continuous) models[name] = (model, continuous) results[name] = { "parameters": parameter_count(model), "trained_timestep": evaluate( model, 0.05, 400, continuous=continuous ), "unseen_four_x_timestep": evaluate( model, 0.20, 100, continuous=continuous ), } save_file(model.state_dict(), ARTIFACT_DIR / f"{name}.safetensors") initial = torch.tensor([[2.0, 0.0]]) truth = true_rollout(initial, 0.05, 400)[0] frame = { "step": list(range(400)), "true_x": truth[:, 0].numpy(), "true_velocity": truth[:, 1].numpy(), } for name, (model, continuous) in models.items(): prediction = rollout(model, initial, 0.05, 400, continuous=continuous)[0] frame[f"{name}_x"] = prediction[:, 0].numpy() frame[f"{name}_velocity"] = prediction[:, 1].numpy() report = { "experiment": "Neural ODE versus discrete transition model", "system": "Van der Pol oscillator, mu=1.5", "results": results, } (ARTIFACT_DIR / "evaluation.json").write_text( json.dumps(report, indent=2), encoding="utf-8" ) pd.DataFrame(frame).to_parquet(DATA_DIR / "phase_rollout.parquet", index=False) trackio.log( { "ode_unseen_rmse": results["neural_ode_rk4"][ "unseen_four_x_timestep" ]["trajectory_rmse"], "discrete_unseen_rmse": results["discrete_transition"][ "unseen_four_x_timestep" ]["trajectory_rmse"], } ) trackio.finish() print(json.dumps(report, indent=2)) if __name__ == "__main__": main()