source/app.py

from __future__ import annotations

from pathlib import Path

import gradio as gr
import numpy as np
import plotly.graph_objects as go
from model import HamiltonianNetwork, VectorFieldNetwork
from physics import true_energy
from safetensors.torch import load_file
from train import rollout

ARTIFACT_DIR = Path(__file__).resolve().parent / "artifacts" / "hamiltonian-pocket"
HAMILTONIAN = HamiltonianNetwork()
HAMILTONIAN.load_state_dict(
    load_file(ARTIFACT_DIR / "hamiltonian.safetensors")
)
HAMILTONIAN.eval()
VECTOR_FIELD = VectorFieldNetwork()
VECTOR_FIELD.load_state_dict(
    load_file(ARTIFACT_DIR / "vector_field.safetensors")
)
VECTOR_FIELD.eval()


def simulate(angle: float, momentum: float, seconds: float) -> tuple[go.Figure, dict]:
    initial = np.asarray([[angle, momentum]], dtype=np.float32)
    steps = int(float(seconds) / 0.05)
    trajectories = {
        "Physics": rollout(None, initial, steps, 0.05)[:, 0],
        "Hamiltonian network": rollout(HAMILTONIAN, initial, steps, 0.05)[:, 0],
        "Black-box vector field": rollout(
            VECTOR_FIELD, initial, steps, 0.05
        )[:, 0],
    }
    figure = go.Figure()
    for name, trajectory in trajectories.items():
        figure.add_trace(
            go.Scatter(
                x=trajectory[:, 0],
                y=trajectory[:, 1],
                mode="lines",
                name=name,
            )
        )
    figure.update_layout(
        title="Learned pendulum phase portrait",
        xaxis_title="Angle",
        yaxis_title="Momentum",
        template="plotly_dark",
    )
    initial_energy = float(true_energy(initial)[0])
    return figure, {
        name: {
            "final_energy": round(float(true_energy(path[-1:])[0]), 5),
            "absolute_energy_drift": round(
                abs(float(true_energy(path[-1:])[0]) - initial_energy), 5
            ),
        }
        for name, path in trajectories.items()
    }


with gr.Blocks(title="Hamiltonian Pocket") as demo:
    gr.Markdown(
        "# Hamiltonian Pocket\n"
        "Compare physics-structured and black-box neural dynamics over a long "
        "pendulum rollout."
    )
    with gr.Row():
        angle = gr.Slider(-3.0, 3.0, 1.5, step=0.1, label="Initial angle")
        momentum = gr.Slider(-2.0, 2.0, 0.3, step=0.1, label="Initial momentum")
        seconds = gr.Slider(2, 20, 10, step=1, label="Simulated seconds")
    run = gr.Button("Roll out dynamics", variant="primary")
    phase = gr.Plot()
    energy = gr.JSON()
    run.click(simulate, [angle, momentum, seconds], [phase, energy])
    demo.load(simulate, [angle, momentum, seconds], [phase, energy])


if __name__ == "__main__":
    demo.launch()