💻 computer science

Interpreting Control Latents for System Identification via Conditional Flow Matching

This paper proposes using conditional flow matching to decode internal control latents from adaptive robot policies into distributions of physical models, thereby enabling online predictive tuning and robustness analysis of frozen policies without modifying the original controller.

Original authors: Dingqi Zhang, Ruiqi Zhang, Mark W. Mueller

Published 2026-08-26

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Dingqi Zhang, Ruiqi Zhang, Mark W. Mueller

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Robots that can adapt to their surroundings are a long-held dream of engineering. When a robot walks on sand, flies through a gust of wind, or carries a heavy load, the laws of physics governing its movement change. To handle this, modern engineers often teach robots to learn a hidden, internal code—a compact summary of what is happening right now. This code, called a latent representation, allows a single control program to adjust its behavior on the fly. If the robot gets heavier, the code changes, and the robot learns to push harder. If the air gets thick, the code shifts, and the robot learns to be more cautious. This approach has allowed machines to master complex tasks like walking on uneven ground or flying drones in unpredictable weather. However, a significant mystery remains: while these internal codes work, no one knows exactly what they mean in the real world. They are black boxes. Engineers can see the robot moving correctly, but they cannot look inside the code to see if it has figured out that the drone is heavier, or if it has simply learned a trick that happens to work. Without understanding the physical meaning of these codes, it is difficult to predict when a robot might fail, to fix it after a crash, or to safely certify it for use in critical situations.

A team of researchers at the University of California, Berkeley, has found a way to open this black box. They developed a method to translate these mysterious internal codes back into a set of physical models that describe the robot's actual body and how it moves. Instead of guessing a single set of numbers to explain the robot's behavior, their system generates a whole family of possible physical descriptions. Imagine a drone flying through the air. The researchers' system looks at the drone's recent history of movements and commands, then produces a cloud of possible physical realities that could explain those movements. One possibility might be a drone that is slightly heavier than usual; another might be a drone with slightly weaker motors. The system does not pick just one; it keeps all the plausible options alive at once. This approach acknowledges a fundamental truth about physics: different physical setups can sometimes look exactly the same when observed from the outside. A heavy drone with strong motors might fly just like a light drone with weak motors. By decoding the internal code into a range of possibilities rather than a single guess, the researchers created a tool that can be used to improve the robot's performance without ever changing the robot's original brain.

The researchers tested this idea on a quadrotor drone, a small flying robot with four propellers. They first trained a standard adaptive control system that could fly the drone even when the drone's weight or motor strength changed randomly. Once the drone was trained, they froze its control policy, meaning the drone's internal decision-making process could not be altered. They then applied their new decoding method to the drone's internal codes as it flew. The result was a stream of physical models that updated in real time. These models were not just abstract numbers; they were complete descriptions of the drone's mass, the length of its arms, and how its motors responded. The researchers used these decoded models to perform two practical tasks. First, they used the models to tune a high-level controller that guides the drone along a path. Because the decoder knew the drone's motors were slowing down, it could adjust the high-level commands to compensate, keeping the drone on course. Second, they used the models to test how robust the drone would be against sudden pushes or wind. By simulating the drone's reaction to these disturbances using the decoded models, they could predict how much the drone would drift before it actually happened.

The results showed that this method works remarkably well. When the researchers deliberately slowed down the drone's motors to stress the system, the standard approach struggled, but the system using the decoded models adjusted its high-level controller and reduced the error in tracking its path by 23 percent for position and 45 percent for heading. This improvement happened without retraining the drone or changing its core policy; the system simply understood the new physical reality through the decoded models. In another test, the researchers pushed the drone with random forces to see how well the system could predict the resulting drift. The decoded models created a tight envelope of prediction that closely matched the actual behavior of the drone in the lateral direction, meaning side-to-side movement. While the system was less accurate in predicting vertical movement, it successfully captured the general trend of how errors would grow under stronger disturbances. This ability to predict failure modes before they occur is a crucial step toward safer robotics.

Perhaps the most convincing proof of the method's value came from a test where the researchers tried to mimic the drone's exact motor commands using only the decoded physical models. They recorded a flight path where the drone had to carry a sudden, off-center weight. The standard method of guessing a single set of physical parameters failed to reproduce the drone's smooth, adaptive motor movements. It produced jerky, incorrect commands that did not match the drone's actual behavior. In contrast, the method that decoded a distribution of possibilities successfully recreated the drone's motor commands with high precision. This demonstrated that the internal code was not just a vague signal for "fly harder," but a rich, structured representation of the physical world that could be translated back into concrete mechanical properties. The researchers found that the internal code was indeed encoding a set of physical truths, but because of the ambiguity of the physical world, those truths existed as a cloud of possibilities rather than a single point.

This work suggests that the internal languages of adaptive robots are not as opaque as previously thought. By treating the translation from code to physics as a process of generating many possible realities rather than finding one perfect answer, engineers can now inspect, diagnose, and improve robots that were previously considered unexplainable. The decoded models allow for a form of virtual testing where the robot's behavior can be analyzed and optimized in simulation before any changes are made to the real machine. While the current system is limited to specific types of flying robots and requires careful handling of noise, the approach opens a new path for making adaptive control systems transparent. It turns the black box of the robot's mind into a window, allowing engineers to see the physical world as the robot sees it, ensuring that these intelligent machines can be trusted to operate safely in the complex, changing world of the future.

Technical Summary: Interpreting Control Latents for System Identification via Conditional Flow Matching

Problem Statement

Latent-conditioned adaptive policies enable robots to operate across environments with varying dynamics by inferring a compact latent representation from sensorimotor history. However, a conceptual gap exists: these learned latents function as internal control signals rather than grounded physical models. Consequently, they lack inspectability, cannot be rolled out for analysis, and are opaque to safety certification or post-hoc diagnosis.

A primary obstacle to interpreting these latents is the ill-posed nature of the inverse mapping from observed behavior to physical parameters. In robotics, the relationship between behavior and dynamics is often non-injective; multiple physically distinct systems (e.g., a heavy vehicle with weak actuators vs. a light vehicle with strong actuators) can exhibit indistinguishable closed-loop behavior. Traditional approaches that regress a latent to a single point estimate of physical parameters fail to capture this physical non-identifiability, as a one-to-one mapping cannot represent the equivalence classes of plausible dynamics models consistent with a given latent.

Methodology

The authors propose a framework to interpret latent representations by explicitly modeling the one-to-many structure of the latent-to-parameter map. The approach consists of two main stages:

Unified Latent-Based Adaptive Control:
The authors train a control policy $\pi(a_t | s_t, z_t)$ conditioned on a latent variable $z_t$ . Unlike traditional two-stage training (where a privileged encoder is trained first, followed by a history-based encoder), this work employs unified joint optimization. The policy, a privileged encoder $\mu(\theta)$ , and a history-based encoder $\phi(\tau_{t-h:t})$ are optimized simultaneously.
- Objective: The joint loss function includes the reinforcement learning objective, alignment terms to ensure the history-based latent $\hat{z}_t$ predicts the privileged latent $z_\theta$ , and regularization terms to prevent representational collapse.
- Goal: This ensures the latent space is consistent across privileged and history-based representations, making the latent both control-sufficient and recoverable from sensorimotor history.
Generative System Identification via Conditional Flow Matching (CFM):
Instead of regressing the latent to a single parameter vector, the authors use Conditional Flow Matching to decode each operational latent $\hat{z}_t$ into a continuous distribution over physically distinct models, $p(\theta | \hat{z}_t)$ .
- Mechanism: A neural network $v_\psi$ learns a conditional vector field that transports a base distribution (Gaussian) to the empirical parameter distribution conditioned on the latent.
- Training: The model is trained on a dataset of parameter-latent pairs collected from the unified training process. The flow-matching objective minimizes the difference between the learned vector field and the target vector field (the difference between the sampled parameters and the base noise).
- Inference: Given a latent from sensorimotor history, physical parameters $\hat{\theta}$ are generated by integrating the learned vector field from a noise sample. This yields a distribution of dynamically consistent system models rather than a single point estimate.

Key Contributions

Distributional Decoding: The paper introduces a method to decode control latents into a distribution of physical models, addressing the non-identifiability problem where multiple systems induce similar behaviors.
Unified Training Pipeline: A joint optimization scheme ensures the latent representation remains consistent and recoverable, bridging the gap between privileged information and observable history.
Downstream Utility without Policy Modification: The decoded distributions enable two specific downstream tasks around a fixed low-level policy:
1. Online Predictive Tuning: Tuning high-level controller gains using parallel simulations of the decoded models.
2. Robustness Analysis: Estimating uncertainty envelopes for closed-loop responses under specified disturbances.

Experimental Results

The framework was instantiated on quadrotor systems with significant variations in mass, inertia, and motor constants.

Predictive Control Tuning:
- Nominal Performance: A high-level controller tuned online using decoded-model rollouts reduced position tracking RMSE by 34% compared to standard gains, closing most of the gap to a hand-tuned baseline, though it did not surpass the hand-tuned Baseline performance.
- Perturbed Actuator Dynamics: When actuator time constants were increased (simulating slower motors), the CFM-tuned controller reduced position RMSE by 23% and heading RMSE by 45% relative to the hand-tuned Baseline. This demonstrated the decoder's ability to identify slower dynamics from the latent and adjust the high-level controller accordingly.
- Hardware Deployment: On real hardware tracking 3D lemniscate trajectories, the CFM-tuned controller achieved tracking accuracy comparable to a hand-tuned baseline while reducing peak position errors and error standard deviation.
Robustness Analysis:
- Step Disturbances: The decoded model ensemble provided a calibrated uncertainty envelope for lateral tracking errors under constant force disturbances, closely bracketing the true system response. Vertical error estimation was less accurate, highlighting a specific limitation.
- Gaussian Disturbances: Under i.i.d. Gaussian force disturbances, the decoded ensembles correctly predicted the growth trend of lateral tracking errors as disturbance magnitude increased, providing a reliable robustness envelope.
Ablation Study (Distributional vs. Deterministic):
- An ablation comparing the CFM decoder against a deterministic regression baseline (predicting a single parameter vector) revealed that the distributional approach significantly outperformed the deterministic one in action prediction.
- On aggressive flight trajectories, the CFM decoder achieved a Pearson Correlation Coefficient (PCC) of ~0.72 with the policy's motor commands, whereas the regression baseline achieved a PCC of 0.077 (compared to 0.202 for the Random baseline). This confirms that the latent-to-parameter map is not a well-defined function in highly excited regimes and requires a distributional representation to capture the policy's behavior.

Significance and Claims

The paper claims that control latents can be converted into physical model ensembles, transforming opaque internal representations into interpretable tools for tuning, robustness analysis, and diagnosis of frozen adaptive policies.

Interpretability: The work demonstrates that latents are not just black-box signals but can be decoded into distributions of physically meaningful dynamics.
Safety and Diagnosis: By providing a distribution of plausible models, the framework supports safety certification and diagnosis without requiring further hardware experiments or policy retraining.
Limitations: The authors modestly note that the recovered models are sensitive to observation and state-estimation noise. Furthermore, current validation is limited to quadrotor platforms with structured parametric models; systems with strong nonlinearities, contacts, or hybrid dynamics may require richer model classes.

The authors conclude that this approach offers a pathway to active probing of adaptive policies, where decoded failure latents could be used to identify weak regions in the policy's training distribution for future improvement.