PYTHON · NUMPY

Learn the structure, not the map

Build a network that keeps the equation of motion's structure and learns only its physical pieces — the mass matrix and the potential — with the inertia guaranteed valid by construction. This is the Deep Lagrangian Network, and it recovers ferromotion's own dynamics from data.

01Challenge

A black box learns the whole map (q, q̇, q̈) → τ and can violate physics anywhere. A Deep Lagrangian Network refuses to. It keeps the manipulator equation M(q)q̈ + C(q,q̇)q̇ + G(q) = τ and learns only the meaningful unknowns: the mass matrix M(q) and the potential V(q). Two structural gifts follow. First, the network outputs a lower-triangular Cholesky factor L(q) and sets M = LLᵀ — so M is symmetric positive-definite at every configuration, for any weights, trained or not (a real inertia can never be otherwise). Second, the Coriolis term is not learned at all: C(q,q̇)q̇ is COMPUTED from ∂M/∂q by autodiff. The Bench trains a DeLaN on inverse-dynamics samples from ferromotion's own double pendulum. Drag q to inspect any configuration and watch the learned M(q) (green) converge onto ferromotion's true M(q) (gold) as you train — while the minimum eigenvalue stays positive everywhere, the SPD guarantee in action.

02Model

Deep Lagrangian Networks sit between the black box and hand-derived equations: they assume the FORM of the dynamics (the manipulator equation) but learn the FUNCTIONS inside it. The mass matrix must be symmetric positive-definite — that is what makes kinetic energy ½q̇ᵀM(q)q̇ positive and the equations solvable — so instead of letting a network output M directly (which could come out indefinite or singular), DeLaN outputs the entries of a lower-triangular L(q), makes the diagonal positive with softplus, and forms M = LLᵀ. That is SPD by construction. The elegant part is the Coriolis and centrifugal forces: rather than learn C(q,q̇) as a separate network, DeLaN computes it from the mass matrix via the Christoffel symbols, which need ∂M/∂q — and ferromotion gets those derivatives exactly by pushing a first-order jet in q through the network on the autodiff tape. Gravity is G(q)=∂V/∂q from a learned potential, exact the same way. The payoff over a black box is generalization and trust: because the model can only represent physically-valid dynamics, it extrapolates to configurations it never saw and cannot invent an unstable or non-conservative system. Trained on ferromotion's double pendulum, it recovers the true M(q) the recursive-Newton–Euler algorithm computes.

03Guided practice

Step A (SPD from the start): before any training, drag q0 and q1 — the learned M(q) is already symmetric positive-definite (minimum eigenvalue > 0) at every configuration, though its values are wrong. That validity is structural, not learned. Step B (train): press Train ×2000 a few times. Watch the green learned M(q) numbers slide toward the gold true M(q) numbers; the max error drops below 0.2. Step C (inspect anywhere): drag q to a new configuration — the learned M still matches the truth there, because it learned the function M(q), not a lookup table. Step D (the lesson): the network never output an invalid inertia, learned the Coriolis forces for free from ∂M/∂q, and recovered the real robot's mass matrix — all because the architecture encoded the equation of motion's structure.

04Feedback

PASS WHEN PASS when the learned mass matrix converges to ferromotion's true M(q) while staying symmetric positive-definite everywhere — structure recovered from data.

If your run fails, check:

Press Train ×2000 a few times and watch the green learned M(q) numbers approach the gold true M(q).
Drag q0 and q1: the learned M stays positive-definite (min eigenvalue > 0) at every configuration, even before it is accurate.

05Retrieve & space

Why must the mass matrix be symmetric positive-definite, and how does the Cholesky parameterization M=LLᵀ guarantee it for any weights?
How does DeLaN get the Coriolis/centrifugal term without learning a separate network for it?
Why does encoding the manipulator-equation structure let the model generalize to configurations it never saw during training?

06Mastery & project

You trained a network that could only ever represent a physically-valid rigid-body system — SPD inertia, Coriolis from ∂M/∂q, gravity from a potential — and watched it recover ferromotion's true mass matrix from data. The equation of motion's structure was built into the architecture, and it paid off in validity and generalization.

The last architectural idea is to put a structure-preserving integrator in the training loop itself — Neural ODEs and Variational Integrator Networks — closing the arc from Module 2's energy drift. From here, Module 5 turns to discovering equations from data (SINDy, Koopman), and Module 6 puts these learned models to work in differentiable control.

GO FURTHER · THE LIVE PLAYGROUND

ferromotion-learn: DeLaN, in pure Rust ↗ — the Cholesky-SPD mass matrix and autodiff Coriolis you just trained, verified against ferromotion's RNEA.

← Conserve energy by construction Learn the flow, predict the future →

PYTHON · NUMPY

Learn the structure, not the map

Live ferromotion-wasm: a Deep Lagrangian Network learning ferromotion's double-pendulum dynamics. Train it and watch its Cholesky-SPD mass matrix converge to the true M(q).

You read

the arrays and values already in scope

You change

the code you write in each cell

Fixed

the dataset and the checks that grade you