| from __future__ import annotations |
|
|
| import copy |
| import json |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| import torch |
| import trackio |
| from model import HamiltonianNetwork, VectorFieldNetwork, parameter_count |
| from physics import generate_states, true_derivative, true_energy |
| from safetensors.torch import save_file |
| from torch import nn |
| from torch.nn import functional as F |
|
|
| PROJECT_DIR = Path(__file__).resolve().parent |
| ARTIFACT_DIR = PROJECT_DIR / "artifacts" / "hamiltonian-pocket" |
| DATA_DIR = PROJECT_DIR / "data" |
|
|
|
|
| def model_derivative(model: nn.Module, states: torch.Tensor) -> torch.Tensor: |
| if isinstance(model, HamiltonianNetwork): |
| return model(states, create_graph=model.training) |
| return model(states) |
|
|
|
|
| def train_model( |
| name: str, |
| model: nn.Module, |
| states: torch.Tensor, |
| derivatives: torch.Tensor, |
| validation_states: torch.Tensor, |
| validation_derivatives: torch.Tensor, |
| ) -> tuple[nn.Module, list[dict]]: |
| optimizer = torch.optim.AdamW(model.parameters(), lr=2e-3, weight_decay=1e-6) |
| rng = np.random.default_rng(2043) |
| best = copy.deepcopy(model.state_dict()) |
| best_validation = float("inf") |
| history = [] |
| for step in range(1, 3_001): |
| indices = rng.choice(len(states), 512, replace=False) |
| batch = states[indices].detach().clone() |
| prediction = model_derivative(model, batch) |
| loss = F.mse_loss(prediction, derivatives[indices]) |
| optimizer.zero_grad() |
| loss.backward() |
| torch.nn.utils.clip_grad_norm_(model.parameters(), 2.0) |
| optimizer.step() |
| if step % 100 == 0: |
| model.eval() |
| validation_input = validation_states.detach().clone() |
| prediction = model_derivative(model, validation_input) |
| validation_loss = float( |
| F.mse_loss(prediction, validation_derivatives).detach() |
| ) |
| record = { |
| "training_step": step, |
| f"{name}_training_mse": float(loss.detach()), |
| f"{name}_validation_mse": validation_loss, |
| } |
| history.append(record) |
| trackio.log(record) |
| if validation_loss < best_validation: |
| best_validation = validation_loss |
| best = copy.deepcopy(model.state_dict()) |
| model.train() |
| model.load_state_dict(best) |
| model.eval() |
| return model, history |
|
|
|
|
| def derivative_numpy(model: nn.Module, states: np.ndarray) -> np.ndarray: |
| tensor = torch.from_numpy(states.astype(np.float32)) |
| prediction = model_derivative(model, tensor) |
| return prediction.detach().numpy() |
|
|
|
|
| def rk4_step(model: nn.Module | None, states: np.ndarray, dt: float) -> np.ndarray: |
| derivative = ( |
| true_derivative |
| if model is None |
| else lambda values: derivative_numpy(model, values) |
| ) |
| k1 = derivative(states) |
| k2 = derivative(states + 0.5 * dt * k1) |
| k3 = derivative(states + 0.5 * dt * k2) |
| k4 = derivative(states + dt * k3) |
| return states + dt * (k1 + 2 * k2 + 2 * k3 + k4) / 6 |
|
|
|
|
| def rollout( |
| model: nn.Module | None, |
| initial_states: np.ndarray, |
| steps: int, |
| dt: float, |
| ) -> np.ndarray: |
| trajectory = [initial_states.copy()] |
| state = initial_states.copy() |
| for _ in range(steps): |
| state = rk4_step(model, state, dt) |
| trajectory.append(state.copy()) |
| return np.stack(trajectory) |
|
|
|
|
| def rollout_metrics( |
| model: nn.Module, |
| initial_states: np.ndarray, |
| truth: np.ndarray, |
| dt: float, |
| ) -> dict: |
| predicted = rollout(model, initial_states, len(truth) - 1, dt) |
| initial_energy = true_energy(predicted[0]) |
| energy_drift = np.abs(true_energy(predicted) - initial_energy) |
| return { |
| "trajectory_mse": float(np.mean((predicted - truth) ** 2)), |
| "final_state_mse": float(np.mean((predicted[-1] - truth[-1]) ** 2)), |
| "mean_absolute_energy_drift": float(energy_drift.mean()), |
| "final_absolute_energy_drift": float(energy_drift[-1].mean()), |
| } |
|
|
|
|
| def main() -> None: |
| torch.manual_seed(2043) |
| torch.set_num_threads(1) |
| train_states, train_derivatives = generate_states(20_000, 2043) |
| validation_states, validation_derivatives = generate_states(3_000, 3043) |
| test_states, test_derivatives = generate_states(5_000, 4043) |
| hamiltonian = HamiltonianNetwork() |
| vector_field = VectorFieldNetwork() |
| trackio.init( |
| project="hamiltonian-pocket", |
| name="conservative-dynamics-v1", |
| config={ |
| "training_samples": len(train_states), |
| "training_steps": 3_000, |
| "hamiltonian_parameters": parameter_count(hamiltonian), |
| "vector_field_parameters": parameter_count(vector_field), |
| }, |
| ) |
| hamiltonian, hamiltonian_history = train_model( |
| "hamiltonian", |
| hamiltonian, |
| torch.from_numpy(train_states), |
| torch.from_numpy(train_derivatives), |
| torch.from_numpy(validation_states), |
| torch.from_numpy(validation_derivatives), |
| ) |
| vector_field, vector_history = train_model( |
| "vector_field", |
| vector_field, |
| torch.from_numpy(train_states), |
| torch.from_numpy(train_derivatives), |
| torch.from_numpy(validation_states), |
| torch.from_numpy(validation_derivatives), |
| ) |
| initial_states, _ = generate_states(128, 5043) |
| dt = 0.05 |
| steps = 400 |
| truth = rollout(None, initial_states, steps, dt) |
| results = {} |
| for name, model in [ |
| ("hamiltonian", hamiltonian), |
| ("vector_field", vector_field), |
| ]: |
| derivative_mse = float( |
| np.mean((derivative_numpy(model, test_states) - test_derivatives) ** 2) |
| ) |
| results[name] = { |
| "parameters": parameter_count(model), |
| "derivative_mse": derivative_mse, |
| "rollout": rollout_metrics(model, initial_states, truth, dt), |
| } |
| report = { |
| "benchmark": "Conservative pendulum dynamics", |
| "training_samples": len(train_states), |
| "rollout_initial_conditions": len(initial_states), |
| "rollout_steps": steps, |
| "dt": dt, |
| "results": results, |
| "training_history": { |
| "hamiltonian": hamiltonian_history, |
| "vector_field": vector_history, |
| }, |
| } |
| ARTIFACT_DIR.mkdir(parents=True, exist_ok=True) |
| DATA_DIR.mkdir(parents=True, exist_ok=True) |
| save_file( |
| hamiltonian.state_dict(), ARTIFACT_DIR / "hamiltonian.safetensors" |
| ) |
| save_file( |
| vector_field.state_dict(), ARTIFACT_DIR / "vector_field.safetensors" |
| ) |
| (ARTIFACT_DIR / "evaluation.json").write_text( |
| json.dumps(report, indent=2), encoding="utf-8" |
| ) |
| pd.DataFrame( |
| np.column_stack([train_states, train_derivatives]), |
| columns=["angle", "momentum", "d_angle", "d_momentum"], |
| ).to_parquet(DATA_DIR / "pendulum_derivatives.parquet", index=False) |
| trackio.log( |
| { |
| "hamiltonian_derivative_mse": results["hamiltonian"][ |
| "derivative_mse" |
| ], |
| "vector_derivative_mse": results["vector_field"]["derivative_mse"], |
| "hamiltonian_energy_drift": results["hamiltonian"]["rollout"][ |
| "final_absolute_energy_drift" |
| ], |
| "vector_energy_drift": results["vector_field"]["rollout"][ |
| "final_absolute_energy_drift" |
| ], |
| } |
| ) |
| trackio.finish() |
| print(json.dumps(report, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
