source/train.py

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