Introduction

In the world of robotics, there is a constant tug-of-war between speed and accuracy. Nowhere is this more apparent than in Model Predictive Control (MPC). MPC is the gold standard for controlling complex robots—from agile drones to autonomous race cars—because it doesn’t just react to the present; it looks into the future, plans a sequence of moves, and executes the best one.

But to look into the future, MPC needs a crystal ball: a dynamics model.

Here lies the problem. If you use a simple, physics-based model (like a high-school physics equation), your controller is fast but often inaccurate. It misses the messy details of the real world, like aerodynamic drag, loose gears (backlash), or squishy tires. On the other hand, if you use a massive neural network to simulate the robot, you get high accuracy, but it’s too computationally heavy to run in real-time on a fast-moving robot.

For years, researchers have tried to find a middle ground. They add “correction” terms or try to learn the parameters of the physics model (like mass or friction). However, these approaches almost always assume one thing: that the system’s parameters stay constant.

But what if they don’t? What if the “effective” mass of a drone changes because a payload is swinging? What if the “friction” of a car tire changes milliseconds before a turn because the car leans?

In this post, we are diving deep into a new paper, “Beyond Constant Parameters: Hyper Prediction Models and HyperMPC.” The researchers propose a fascinating solution: a Hyper Prediction Model (HyperPM). Instead of learning a static parameter, this system predicts a trajectory of how parameters will evolve over time, allowing simple models to capture complex, unmodeled behaviors.

We will unpack how this works, why it matters, and look at the impressive results from simulations and real-world F1TENTH racing.

Background: The MPC Dilemma

Before understanding the solution, we need to solidify the problem.

Model Predictive Control (MPC) works by solving an optimization problem at every time step. Imagine a drone flying through a forest. Every fraction of a second, the drone’s computer simulates thousands of possible future paths based on its current state and possible control inputs (actions). It picks the path that minimizes “cost” (don’t crash, reach the target, save battery) and executes the first step of that path.

The engine powering this simulation is the Dynamics Model:

\[ \dot{x} = f(x, u) \]

Where \(x\) is the state (position, velocity) and \(u\) is the control (throttle, steering).

The Limits of Analytical Models

Engineers usually prefer Analytical Models (Derived from First Principles). These are equations based on Newton’s laws. They are sparse, efficient, and interpretible. However, they are idealizations. They assume the robot is a rigid body, the ground is flat, and the tires are perfect. Real-world phenomena like unmodeled dynamics—such as a payload swinging on a rope beneath a drone—are invisible to these models.

The Limits of Hybrid Models

To fix this, roboticists often use Hybrid Models. They take the analytical model and add a “residual” neural network to predict the error.

\[ \dot{x} = f_{analytical}(x, u) + NN(x, u) \]

Or, they use a network to estimate the parameters \(\theta\) (like mass or friction) of the analytical model:

\[ \dot{x} = f_{\theta}(x, u) \]

The issue with current state-of-the-art methods is that they estimate \(\theta\) based on the current instant and assume it holds true for the entire prediction horizon (e.g., the next 2 seconds).

The researchers argue this is insufficient. If a drone carries a swinging payload, the forces acting on the drone change rhythmically. If you assume the force is constant for the next 2 seconds based only on right now, your prediction will be wrong. You need to anticipate how those parameters will change.

The Core Method: Hyper Prediction Model (HyperPM)

The paper introduces HyperPM, a framework that predicts the evolution of model parameters. It doesn’t ask “What is the friction now?”; it asks “What will the friction trajectory look like over the next 2 seconds?”

The Concept

The core idea is to project unmodeled dynamics onto time-dependent parameters.

Let’s say we have a simple model of a car. It doesn’t know about suspension or body roll (weight transfer). When a car turns, weight shifts to the outside tires, effectively changing the available grip parameters. A standard model sees constant grip. HyperPM, however, sees that a turn is coming and predicts that the “grip parameter” will change continuously throughout the turn.

Figure 1: HyperPM leverages the recent state and control history, together with the planned control sequence, to predict a trajectory of time-varying model parameters. Injecting these predicted parameters into the nominal dynamics yields more accurate long-horizon state forecasts.

As shown in Figure 1, the architecture takes three inputs:

  1. Past States (\(x\)): Where have we been?
  2. Past Controls (\(u\)): What did we do?
  3. Future Planned Controls (\(\hat{u}\)): What are we planning to do?

This third input is critical. You cannot predict how the car’s body will roll if you don’t know that the controller plans to steer left in 0.5 seconds.

The output is a trajectory of parameters \(\theta[t, t+t_p]\). These parameters are then fed into the standard “Plant model” (the analytical physics equations) to generate the state prediction.

Mathematical Formulation

The goal is to find a sequence of parameters that minimizes the difference between the predicted state \(\hat{x}\) and the real state \(x\) over the horizon \(t_p\).

Equation describing the minimization of the integral of the error between real state x and predicted state x-hat, subject to the dynamics function parameterized by theta.

The HyperPM function itself is defined as:

Equation showing HyperPM as a function of past states, past controls, and future planned controls, outputting a parameter trajectory theta.

Network Architecture

How do we build a neural network that handles history and future plans? The researchers combined Recurrent Neural Networks (RNNs) with B-Splines.

Let’s break down the architecture shown in Figure 5 below:

Figure 5: The architecture of Hyper Prediction Model. It consists of a History Encoder (GRU), an Expected Controls Preprocessor (B-spline), and a Causal Parameters Predictor.

  1. History Encoder: A GRU (Gated Recurrent Unit) processes the sequence of past states and actions. It condenses the robot’s recent history into a single “context” vector (\(h_{t_c}\)). This captures the current “hidden” state (e.g., “the payload is currently swinging to the left”).
  2. Expected Controls Preprocessor: The future controls are processed using B-Splines. B-Splines are mathematical curves that allow the network to represent the future control signal smoothly using just a few “control points.” This makes the network efficient and independent of the specific time-step resolution.
  3. Robustness via Noise: A clever trick the authors use (marked with dashed lines in the figure) is injecting noise into the future controls during training. Why? Because in the real world, the MPC might plan a move, but not execute it perfectly. The network needs to be robust to imperfect future plans.
  4. Causal Parameter Predictor: This MLP (Multi-Layer Perceptron) takes the history context and the future control points to generate the parameter changes (\(\Delta \theta\)). It uses causal masking, ensuring that the parameter prediction at time \(t\) only depends on controls up to time \(t\). You can’t let the physics at time \(t=0\) depend on a steering command at time \(t=2\).

Training Strategy: Backpropagation Through Time

Training this model is unique. You cannot just train it to predict the “next step” (standard supervised learning). You must train it to be accurate over the entire long horizon.

Figure 6: The Hyper Prediction Model is trained to predict trajectories of parameters. It rolls out the dynamics using an RK4 integrator and calculates loss over the whole horizon.

As illustrated in Figure 6, the training process involves:

  1. Predicting the full parameter trajectory.
  2. Plugging those parameters into a differentiable physics simulator (using an RK4 integrator).
  3. Rolling out the simulation for the full horizon (e.g., 2 seconds).
  4. Comparing the entire simulated path to the ground truth.
  5. Backpropagating the error through time to update the network weights.

This ensures the model isn’t just good at the next millisecond, but stable and accurate seconds into the future.

HyperMPC: Closing the Loop

So we have a great prediction model. How do we use it to control a robot? This integration is called HyperMPC.

The workflow is circular. Standard MPC solves an optimization problem to output a control sequence. HyperMPC adds a pre-processing step:

  1. Input: Take the planned control sequence from the previous step (shifted forward) and the current observation history.
  2. Hyper Step: Pass this into HyperPM to get the trajectory of model parameters \(\{\theta_t\}\).
  3. Optimization: Feed these time-varying parameters into the MPC solver.
  4. Solve: The MPC solver finds the optimal control \(u^*\).
  5. Execute: Apply the first control \(u_0\) to the robot.
  6. Repeat.

The beauty of this approach is computational efficiency. The heavy lifting (the neural network) happens outside the optimization loop. Inside the loop, the solver is just dealing with the analytical model (which is fast), it just happens to be an analytical model where the mass/friction values change at every step.

Algorithm 1 equations showing the optimization problem where x_t+dt is a function of the RK4 integrator using time-varying theta_t.

The optimization problem (shown above) looks standard, but notice the subscript \(\theta_t\)—the dynamics model evolves over time \(t\).

Experiments and Results

The researchers tested HyperPM on three distinct platforms, ranging from simulation to the real world.

Figure 2: Experimental platforms: (i) pendulum with backlash, (ii) drone with rope-suspended payload, (iii) real-world F1TENTH racing car.

1. Simulated Pendulum with Backlash

The Challenge: A pendulum is simple. But add “backlash” (a gap between gear teeth), and it becomes a nightmare. When the motor changes direction, there is a moment where the gear spins but the pendulum doesn’t move (the dead zone). A standard model assumes immediate contact.

Figure 7: Visualization of the pendulum with backlash. Red dots show the virtual joint slack.

The Result: Standard models failed completely because they couldn’t anticipate the loss of torque during the backlash phase. Looking at Table 1 below, notice the “Success Rate.” The constant parameter models (const) and even the standard HyperDynamics (HD, which predicts static parameters) failed to swing the pendulum up (0% success). HyperPM achieved a 100% success rate.

Table 1: Prediction and MPC performance for a pendulum with backlash. HyperPM shows 100% success rate compared to 0% for others.

HyperPM learned to predict a parameter trajectory that effectively “turned off” the gear ratio parameter during the backlash phase, perfectly mimicking the dead zone.

2. Drone with Rope-Suspended Payload

The Challenge: A drone carries a weight on a string. The drone’s sensors can see the drone, but they cannot see the payload or the rope. The payload swings, pulling the drone around. This is a classic “Partially Observable” system.

Figure 8: Drone model with a rope-attached payload.

The Result: The researchers tested this with varying rope lengths. A longer rope means more complex unmodeled dynamics.

Figure 9: Comparison of prediction performance on datasets with different rope lengths. HyperPM maintains lower error as rope length increases.

In Figure 9, notice that when rope length is 0 (rigid payload), all models are equal. As the rope gets longer (\(l=1.0\)), the error for standard models spikes. HyperPM (the red bar) keeps the error significantly lower. It infers the oscillation of the hidden payload from the drone’s history and predicts how that pulling force will evolve over the horizon.

3. Real-World F1TENTH Racing

The Challenge: Autonomous racing pushes physics to the limit. The vehicle is an F1TENTH (1/8th scale) race car. The goal is to drive as fast as possible on a virtual track.

Figure 10: Experimental setup for F1TENTH racing. Left: Virtual track. Right: The robotic vehicle.

The Physics: When a car brakes hard or corners, weight transfers. This changes the normal force on the tires, which changes grip. A simple “single-track” model doesn’t capture this.

The Result: First, let’s look at prediction error in Table 3. HyperPM reduces prediction error by nearly 49% compared to the baseline constant model (const_s).

Table 3: Long-horizon prediction error for F1TENTH car. HyperPM outperforms HD and constant models.

But does accurate prediction translate to better racing? Yes. Figure 4 (below) shows the total cost (lap time/progress) and safety penalty. HyperPM (Blue line/bar) achieves the best balance of speed and safety. Notably, it outperforms the “Residual” model (res), which uses a neural network to correct the dynamics directly. This is likely because residual models tend to overfit to the training data, whereas HyperPM adapts the physics parameters, keeping the predictions grounded in reality.

Figure 4: Comparison of modeling approaches in F1TENTH racing. HyperPM shows lower costs and safety penalties.

Interpretability: The “Aha!” Moment

One of the coolest parts of this paper is the interpretability check. The researchers asked: “What is the model actually doing to the parameters?”

They looked at the Normal Force (\(F_{zf}\)) on the front tire. In physics, when you brake, weight shifts forward, increasing this force. The standard analytical model used in the MPC assumes this force is constant.

The researchers plotted the force calculated by a complex “ground truth” physics formula (black line) versus what HyperPM predicted (red line) by tweaking the car’s parameters (specifically, the center of gravity).

Figure 11: Front tire normal force calculated using different methods. The red line (HyperPM) closely follows the black line (Physics Ground Truth), capturing load transfer.

As seen in Figure 11, the red line follows the black line beautifully. HyperPM “discovered” the concept of load transfer. It dynamically shifted the virtual center of mass in the model to mimic the weight transfer occurring during braking and acceleration. This proves the model isn’t just memorizing data; it’s finding physical adaptations to explain reality.

Conclusion

The Hyper Prediction Model (HyperPM) represents a significant step forward for model-based control. By moving beyond the assumption that system parameters must be constant, it bridges the gap between the speed of analytical models and the accuracy of data-driven methods.

Key Takeaways:

  1. Time-Varying is Key: Unmodeled dynamics (backlash, payload swing) are rarely static. Modeling them as a trajectory of changing parameters is more effective than a static guess.
  2. Future-Awareness: Predicting dynamics requires knowing the future plan. HyperPM leverages the planned control sequence to anticipate how the system’s response will change.
  3. Efficiency: HyperMPC retains the computational speed of standard MPC because the heavy neural network runs outside the optimization loop.
  4. Interpretability: Unlike a “black box” residual network, HyperPM modifies physical parameters (like mass or length), offering insight into what the model is “thinking.”

This approach opens exciting doors for robotics in complex environments—imagine delivery drones that adapt to wind gusts and shifting packages in real-time, or autonomous cars that adjust their internal physics models the moment they hit a patch of ice. By teaching our old models to be more dynamic, we make our robots safer, faster, and smarter.