🐦‍🔥 The O13 PINN Engine - Overview & Technical White Paper

An open-source inverse PINN engine that takes governing equations & noisy sensor data, discovers unknown physical parameters in real-time and outputs physics-guaranteed dynamics models that drop into MPC/RL/state estimation pipelines.

You can find the code here: https://github.com/wolfeiq/pinn_service

Commercial layer provides managed compute, deployment, and continuous adaptation.

The Problem

Every robot needs to know two things:

• state estimation and
• dynamics prediction.

When reality doesn't match the model, however, (think: foot hits ice, excavator hits wet clay, joint wears down, payload changes) the model breaks. The state estimate drifts. The MPC controller plans based on wrong predictions and the robot eventually fails in deployment.

The Simplified Solution

An inverse PINN that discovers the actual physical parameters from sensor data, constrained by governing equations. The robot provides its general equations of motion and its noisy sensor streams, i.e. IMU, encoders, force-torque, etc.

The PINN solves backwards:

• what values of friction, stiffness, damping, payload mass, and contact regime make all of the sensor readings simultaneously consistent with Newton's laws?

Once the parameters are correct, the state estimate is correct automatically. The dynamics model is correct automatically, and the MPC plans based on reality, not approximation.

Currently, several PINN research libraries exist, allowing ML engineers to experiment with the architecture. For example:

• DeepXDE
• PhysicsNeMo
• PINA
• etc.

However, robotics engineers and operators need a different level of abstraction that the PINN engine aims to be.

But PINNs are so Painful! 🐦‍🔥

PINNs are notoriously difficult to set up.

Loss Balancing

Engineers must manually balance competing loss terms (sensor data vs physics equations vs boundary conditions). Network gets stuck in local minima when terms conflict.

• Our AutoML does this automatically. Bayesian optimization over loss weights + self-adaptive loss balancing.

Extreme Training Time

Every training step computes high-order PDEs via automatic differentiation. Hours or days on GPU clusters for minor architectural adjustments.

• AutoML finds the right architecture faster than manual search. PFM initialization (Poseidon/PhysiX) provides educated starting point, dramatically reducing convergence time. Pre-trained parametric models (v2) eliminate training from scratch. Commercial tier runs on A100 clusters.

Failure on Stiff and Discontinuous Physics

PINNs struggle with sudden physical shifts, such as material wrinkling, buckling, contact transitions. Neural networks are biased toward smooth functions.

• Inverse PINN discovers regime changes through parameter estimation. Detects that coefficients changed rather than trying to learn the discontinuity as a continuous function. Validated equation templates include known-good configurations for stiff systems.

Sim-to-Real Generalization Gap

A PINN is only as smart as the physics equations you give it. Unmodeled forces (internal friction, fluid drag, torsion) cause accuracy to degrade.

• User provides the most general form of equations with all possible terms. Inverse PINN discovers which terms are active by estimating their coefficients from sensor data.
  • Unknown friction? Add a friction term, the PINN discovers it's 0.37.
  • Unmodeled drag? Add a drag term, the PINN discovers the coefficient.
  • You don't need to know which physics matters in advance.

High (Re-)Deployment Maintenance

Soft materials stretch, wear out, change properties. Companies must build entire secondary pipelines for continuous recalibration.

• This is our commercial tier. The continuous retraining loop: monitor → detect drift → retrain → deploy.

Three Capabilities, One Engine

1. Proprioception / State Estimation Discovers where the robot is, what forces are acting, what physical parameters are true right now.

• Replaces EKF/ESKF with physics-guaranteed estimates that adapt to changing conditions.

2. MPC Dynamics Surrogate The same PINN with discovered parameters becomes the fast, accurate model that MPC optimizes against.

3. Sim-to-Real Gap Closure The PINN dynamics model matches reality because it was fitted to real sensor data constrained by real physics. The simulator's approximations are replaced by discovered ground truth.

Offline and Real-Time: Two Modes of the PINN

The same inverse PINN engine operates in both modes:

Post-Processing (Offline) After the mission is done, operators upload the full sensor log. The inverse PINN trains on the complete trajectory with full AutoML search. This ensures maximum accuracy because it sees the whole dataset at once, iterates as long as needed, and refines globally.

Somewhat Obvious Use cases:

• Post-mission analysis
• Discovering what went wrong when something failed
• Generating ground-truth trajectories for validation
• Building the initial parametric model for a new robot class
• Comprehensive parameter discovery across an entire mission

Real-Time (Online) The robot is operating in situ. The pre-trained parametric PINN runs inference on incoming sensor data and discovers parameters on the fly using lightweight weight updates on a rolling window of recent data. Feeds directly into the MPC/state estimation loop at 50-100+ Hz.

More Use cases:

• Active MPC control with adaptive dynamics
• Live proprioception and state estimation
• Real-time regime detection (slip, contact, free swing)
• Immediate parameter adaptation (payload change, terrain change)
• Sensor failure detection and compensation Figure 1: The Continuous Loop of Iteration

How the Engine Works:

1. Validates equation structure, checks well-posedness
2. AutoML searches architecture (Bayesian optimization over network depth, width, activation, loss formulation)
3. (Optional) PFM initialization; uses open-source Physics Foundation Models (Poseidon, PhysiX) to generate an educated initial guess for the solution field, dramatically accelerating convergence
4. Trains inverse PINN that simultaneously:
   • Estimates unknown physical parameters
   • Estimates system state
   • Detects operating regime (slip vs grip, contact vs free swing)
   • Handles sensor noise and dropout
   • Provides uncertainty bounds on all estimates
5. Outputs: trained dynamics model + discovered parameters + uncertainty bounds + convergence diagnostics

Continuous operation:

• Architecture fixed after initial AutoML (runs once per robot class)
• Parameters update continuously as conditions change
• Fast timescale (ms): regime detection via parametric PINN inference
• Medium timescale (min): weight fine-tuning on recent sensor data
• Slow timescale (days): full retraining for gradual drift/wear

PFM + PINN Hybrid Architecture

This is an optional step and might only be needed for certain use cases; however, the PFM community and the PINN community are separate worlds. PFM researchers build generalist models, while PINN researchers build specialized solvers. This engine is attempting to bridge both: using PFMs for what they're good at (fast approximate initialization) and PINNs for what they're good at (physics-guaranteed parameter discovery and refinement).

Open Source vs Commercial

Open Source (Apache 2.0): The Engine

• Full inverse PINN training engine with AutoML architecture search
• PFM integration layer
  • using Poseidon, PhysiX, or GPhyT as initialization for faster convergence
• Self-adaptive loss weighting, noise-aware training
• Uncertainty quantification on discovered parameters
• Regime detection through parameter discovery
• Sensor data ingestion (CSV, ROS bags, HDF5)
• Equation templates (rigid-body, Fossen 6-DOF, Cosserat rod, Navier-Stokes, contact dynamics, custom)
• Export to ONNX, TorchScript
• Benchmarks against EKF/ESKF/UKF on public datasets
• Community-contributed equation templates

Commercial (Platform): Everything Around the Engine

• Managed GPU compute for AutoML search (A100/H100 clusters)
• Pre-trained parametric models per robot class (quadruped, manipulator, excavator, AUV, soft robot) that fine-tune in minutes
• Continuous retraining loop: monitor → detect drift → retrain → deploy
• ROS 2 native integration
• MPC pipeline export (CasADi, Drake, acados)
• Edge deployment optimization
• Model versioning and deployment tracking
• Fleet-wide monitoring and drift detection
• Support and consulting