PYTHON · NUMPY

Learn in imagination

Close the whole loop: identify a model of an unknown plant from data, tune a controller entirely inside that learned model, and deploy it on the real system. The complete physics-informed pipeline, on-device.

01Challenge

This is the course in one loop. You are handed an unknown plant — a damped mass under a disturbance whose parameters you do not know. Stage 1, identify it: from measured (position, velocity, force) → acceleration samples, least squares recovers the model ẍ = a·x + b·v + c·u + d, to machine precision. Stage 2, control it in imagination: tune a PID by differentiating the tracking cost through the LEARNED model — never touching the real plant. Stage 3, deploy: run the tuned controller on the TRUE plant. The Bench shows all three. The learned coefficients match the truth; the violet 'imagined' response and the green 'real' response both climb to the setpoint and sit on it. The controller was tuned entirely in a model learned from data, and it works on the real system — because the model is faithful and differentiable. That is how you avoid running thousands of risky trials on real hardware: you learn a model, and you learn in imagination.

02Model

Every idea in this course meets here. Identification is model-structured learning at its simplest — a physics-shaped linear model fit by least squares, the same tool as SINDy and Koopman. Control in imagination is differentiable control from the previous lesson, but now the plant you differentiate through is LEARNED, not given — the payoff of building models you can differentiate. And deploying on the true plant is the sim-to-real step: it works because the learned model is accurate where it matters and the controller it produced is robust. This is the loop behind model-based reinforcement learning and Dreamer-style agents that 'learn in imagination' — collect a little data, learn a model, then improve the policy inside the model for free, and only return to the real system to collect more data or to act. The sample-efficiency win is enormous: real interactions are scarce, slow, and risky, while rollouts in a learned model are unlimited and safe. The physics prior threads all the way through — a structured model needs little data to identify, a differentiable model turns control into gradient descent, and the whole pipeline runs on-device, no GPU, no cloud. You have built, from the autodiff tape up, the complete arc: sense the data, learn a model, imagine, and act.

03Guided practice

Step A (identify — already done): the readout shows the learned coefficients next to the true ones; they match to machine precision. The plant is known, from data alone. Step B (control in imagination): press Train in model. The PID is tuned by differentiating through the learned model — the violet 'imagined' step response climbs to the setpoint. Step C (deploy for real): the green curve is that same controller running on the TRUE plant. It also reaches the setpoint — the imagined and real responses nearly overlap. Step D (the whole loop): you identified a model, tuned a controller inside it without ever risking the real system, and deployed successfully. Learn a model, learn in imagination, act. That is physics-informed physical AI.

04Feedback

PASS WHEN PASS when a controller tuned entirely inside a model learned from data settles the real plant on its setpoint — sense, model, imagine, act, all on-device.

If your run fails, check:

Stage 1 is done — the learned coefficients already match the true plant. Press Train in model.
The controller is tuned inside the learned model (violet), then deployed on the real plant (green) — both reach the setpoint.

05Retrieve & space

What are the three stages of the loop, and which earlier lessons does each one reuse?
Why does tuning a controller inside a learned model save you from thousands of risky trials on real hardware?
Why does a controller trained entirely in imagination work on the real plant here — what has to be true of the learned model?

06Mastery & project

You closed the whole loop: identified a model from data, tuned a controller inside it without touching the real system, and deployed it successfully. Sense, model, imagine, act — the complete physics-informed physical-AI pipeline, built from the autodiff tape up and running on-device.

Everything you built — autodiff, networks, PINNs, Hamiltonian and Lagrangian nets, Neural ODEs, SINDy, Koopman, model-structured nets, differentiable control — composes into this loop, and ferromotion gives you the on-device, zero-GPU foundation to build it. The next lesson shows that scaling this exact pattern up is not hypothetical: Newton, two 2025–2026 papers doing real-robot system identification through MJX, and OrbiSim's differentiable-physics take on world models are all placing the same bet, right now, at industrial and research scale.

GO FURTHER · THE LIVE PLAYGROUND

ferromotion-learn: model-based control, in pure Rust ↗ — identify, imagine, deploy — the whole loop you just closed, on-device.

← Control by gradient The industry agrees: structure-as-differentiation, at scale →

PYTHON · NUMPY

Learn in imagination

Live ferromotion-wasm: identify a plant from data, tune a controller inside the learned model, deploy on the true plant. The whole course in one loop.

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