🤖 machine learning

ConFlow: Constraints-Guided Learning with Flow Matching for Motion Generation

The paper proposes ConFlow, a constraint-guided flow matching framework that integrates task-specific constraints directly into the training objective via differentiable functions and conditional Gaussian processes, thereby improving motion generation quality and constraint satisfaction while closing the training-inference gap without relying solely on inference-time guidance.

Original authors: Nutan Chen, Jianxiang Feng, Marvin Alles, Botond Cseke

Published 2026-07-17

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Nutan Chen, Jianxiang Feng, Marvin Alles, Botond Cseke

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

Imagine a world where robots don't just follow rigid, pre-programmed instructions but can learn to move with the fluid grace of a dancer. This is the exciting frontier of robot motion generation, a field where scientists teach machines how to navigate complex environments without bumping into walls, each other, or themselves. For a long time, the best way to teach a robot was to show it thousands of perfect examples, like a master chef showing an apprentice the perfect way to chop vegetables. But what if you only have a few perfect examples, or what if the robot needs to learn how not to do something (like crashing) just as much as how to do it right?

Enter Flow Matching, a clever new way of teaching robots. Think of it like a river flowing from a calm lake (random noise) into a bustling city (the desired movement). The robot learns the "current" of the river so it can swim from the lake to the city smoothly. Usually, if the river hits a rock (an obstacle), the robot tries to steer around it only at the very last second while it's already swimming. This paper suggests that waiting until the last second is risky and inefficient. Instead, why not teach the river itself to flow around the rocks from the very beginning?

This is the story of ConFlow, a new method that changes how we teach robots to move. Instead of just showing robots the "right" way to go and hoping they figure out the "wrong" way later, ConFlow teaches the robot's brain to understand the rules of the game while it's learning. It uses a special kind of mathematical "map" called a Gaussian Process to ensure the robot's movements are smooth and start and end exactly where they should. It also learns from "bad" examples—times when the robot crashed—to understand what to avoid. The result? Robots that are safer, smoother, and better at avoiding collisions, even when they haven't been explicitly told to be careful at every single step.

The Problem: The "Last-Minute" Panic

In the past, when scientists trained robots to move, they used a method where the robot learned a general path and then, right before it moved, a "guide" would shout, "Hey, there's a wall! Turn left!" This is called inference-time guidance. It's like teaching a driver to drive on a straight road and then, only when they are about to hit a tree, handing them a steering wheel and yelling "Turn!"

The problem with this approach is that the robot's brain (the model) wasn't actually trained to respect the tree. It was trained to drive straight, and the steering correction is a patch applied later. This often leads to jerky, unnatural movements or, worse, the robot panicking and crashing because it didn't understand the rules of the road until it was too late. It's a mismatch between what the robot learned in school (training) and what it has to do in the real world (deployment).

The Solution: Teaching the Rules from Day One

The authors of this paper, Nutan Chen, Jianxiang Feng, Marvin Alles, and Botond Cseke, propose ConFlow (Constraints-Guided Flow Matching). Instead of waiting until the robot is moving to tell it to avoid obstacles, ConFlow teaches the robot to avoid obstacles while it is learning how to move.

They do this in two main ways:

Learning from Mistakes (Negative Supervision):
Usually, robots are only shown "good" examples (perfect paths). ConFlow is special because it also looks at "bad" examples—paths where the robot crashed or violated rules. Think of it like a student learning to play soccer. Instead of just watching the pros score goals, the student also watches replays of their own mistakes, like tripping over the ball. The paper shows that by feeding the robot these "bad" examples, it learns to recognize what not to do. The robot learns a "constraint" (a rule) that says, "If you get too close to another robot, push away." This rule is baked into the robot's brain during training, not just applied as a patch later.
The Smooth Map (Conditional Gaussian Process):
Standard methods often start with a "random noise" map, which is like trying to draw a perfect circle by starting with a chaotic scribble and hoping to smooth it out. ConFlow replaces this random scribble with a Conditional Gaussian Process (GP). Imagine a rubber band stretched between the start point and the finish line. No matter how you wiggle it, it always stays connected and smooth. This "rubber band" ensures that the robot's path is naturally smooth and always starts and ends at the correct places. It's like giving the robot a pre-drawn, smooth highway instead of a messy dirt road.

The Experiment: Two Robots Swapping Places

To test their idea, the researchers set up a simulation with two robots in a 2D room. The goal was simple: the robots had to swap places. To make it tricky, they added a twist: about 30% of the training data showed the robots crashing into each other.

They compared their new ConFlow method against the old standard (Flow Matching with a random noise start) and a version that only saw "good" examples. They tested the robots in three scenarios:

No Guidance: The robot just moves on its own.
Robot-Avoidance Guidance: The robot gets a nudge to avoid the other robot.
Obstacle-Avoidance Guidance: The robot gets a nudge to avoid a wall.

The Results: Smoother and Safer

The results were clear. The robots trained with ConFlow crashed much less often than the others.

When no extra guidance was given, the standard method crashed about 3.1% of the time (0.031), while ConFlow crashed only 1.6% of the time (0.016). This suggests that the robot had truly learned to avoid collisions, rather than just reacting to them at the last second.
When they added guidance, ConFlow was even better, crashing only 0.4% of the time compared to the standard method's 2.0%.
The "smoothness" of the movement also improved dramatically. The standard method produced jerky paths with lots of local wiggles, while ConFlow produced paths that were 46% less likely to collide and much smoother, with fewer local oscillations.

The paper also found that using the "bad" examples (negative data) was crucial. If they only used the "good" examples, the robot did okay, but not as good as when it learned from its mistakes. Interestingly, if they just threw the "bad" examples into the standard method without the special ConFlow training, the robot actually got worse, getting confused by the mixed signals. This proves that you can't just mix good and bad data; you need a special way to teach the robot how to learn from the bad data.

Why This Matters

The big takeaway from this paper is that we shouldn't treat the "rules of the road" (constraints) as an afterthought. By baking safety and smoothness directly into the training process and using a smart, smooth starting point (the Conditional Gaussian Process), robots can learn to move more naturally and safely.

The authors suggest that this approach bridges the gap between what a robot learns in the lab and what it needs to do in the real world. While the paper focuses on a simulation of two robots swapping places, the method suggests a promising path for teaching more complex robots—like arms that assemble cars or drones that fly through forests—to be safer and more reliable without needing millions of perfect examples. It's a step toward robots that don't just follow orders, but understand the spirit of the rules.

Technical Summary: ConFlow – Constraints-Guided Learning with Flow Matching for Motion Generation

Problem Statement

Recent advances in generative modeling, particularly Flow Matching (FM) and diffusion models, have enabled learning-based robot motion generation. However, a critical limitation exists in current frameworks: the misalignment between the training objective and the constraints enforced at deployment. Standard approaches train on available data (often expert demonstrations) and rely on inference-time guidance to enforce task-specific constraints (e.g., obstacle avoidance). This creates a "training–inference gap," where the underlying learned distribution may not inherently satisfy constraints, leading to infeasible or physically implausible out-of-distribution behaviors when guidance is imperfect or unavailable.

Furthermore, robotics applications often suffer from data scarcity. Collecting large-scale expert demonstrations is costly and labor-intensive. While non-expert or negative demonstrations (trajectories violating constraints) are abundant, they are typically discarded or underutilized because standard generative models struggle to distinguish feasible from infeasible motions without explicit supervision.

Methodology

The paper proposes ConFlow, a constraint-guided flow matching framework designed to close the training–inference gap by integrating constraints directly into the learning process. The methodology consists of three core components:

1. Constraint-Guided Training Objective

Instead of applying constraints only during sampling, ConFlow modifies the standard Flow Matching loss function to incorporate constraint information during training.

Mechanism: The standard velocity regression target $u_t$ is augmented with a constraint-induced correction term. The loss function becomes:
$L_{CG} = \text{MSE}(u_\theta^t - u_t - \lambda_c M(x_1) u_t^c)$
where $u_t^c = \nabla_{x_t} C(x_t)$ is the gradient of a differentiable constraint function $C(\cdot)$ , and $M(x_1)$ is a binary indicator that activates the correction only for negative demonstrations (trajectories violating constraints).
Constraint Function: For collision avoidance, the authors use a SoftPlus formulation rather than ReLU-based penalties to ensure smooth gradients. The function penalizes trajectories where the distance between robots (or robot links) falls below a safety radius $r$ .
Negative Supervision: The framework utilizes a dataset $D = D^+ \cup D^-$ , where $D^-$ contains infeasible trajectories. By activating the correction term only for $D^-$ , the model learns to suppress constraint-violating behaviors without over-regularizing feasible trajectories.

2. Constraint-Injected Source Distribution

Standard Flow Matching typically uses a standard Gaussian source distribution ( $p_0$ ), which assumes independent noise across trajectory waypoints. This can lead to high-frequency artifacts and a lack of inherent smoothness.

Gaussian Process (GP) Prior: ConFlow replaces the standard Gaussian prior with a Conditional Gaussian Process (CGP).
Smoothness: The GP encodes temporal correlations between neighboring waypoints, ensuring that the initial source trajectories are inherently smooth.
Boundary Conditions: The GP is conditioned on the start ( $q_{start}$ ) and goal ( $q_{goal}$ ) states. This ensures that the source distribution $p_0$ already satisfies boundary constraints, allowing the learned flow to focus on refining intermediate trajectory variations rather than correcting endpoint mismatches.

3. Inference

Unlike guidance-based methods that require heavy computation and repeated gradient evaluations at runtime, ConFlow learns a constraint-aware velocity field during training.

Standard Sampling: Inference follows the standard ODE integration of the learned flow, starting from the conditional GP source.
Optional Guidance: While the model is trained to be constraint-aware, optional inference-time guidance can still be applied for additional safety in challenging scenarios, though the paper demonstrates robustness even without it.

Key Contributions

The paper outlines four primary contributions:

Constraint-Guided Learning Paradigm: A novel approach that transfers inference-time guidance logic into the training objective, mitigating the mismatch between training and deployment.
Flow Matching Instantiation: The integration of a constraint-aware training objective with a GP-based source distribution within a flow matching framework.
Non-Expert Data Utilization: An extension of the framework to effectively use infeasible demonstrations as negative supervision, improving data efficiency and generalization without requiring additional expert data collection.
Empirical Validation: Validation on a multi-robot obstacle avoidance task, demonstrating improved constraint satisfaction and motion quality compared to standard baselines.

Experimental Results

The authors evaluated ConFlow on a two-robot navigation task where robots exchange positions in a 2D workspace. The dataset included both collision-free and collision-inducing trajectories.

Collision Rates: ConFlow (trained on both positive and negative data) achieved the lowest robot-collision rates across all settings. Notably, without any inference-time guidance, ConFlow achieved a collision rate of 0.016, significantly lower than the standard Flow Matching baseline (0.031) and the variant trained only on positive data (0.043).
Robustness: The method remained robust even when inference-time guidance was disabled, suggesting that collision avoidance behavior was successfully internalized during training.
Source Distribution Impact: Replacing the standard Gaussian prior with the Conditional GP (CGP) reduced the robot-collision rate by nearly 46% (from 0.0288 to 0.0156) and substantially improved trajectory smoothness and endpoint accuracy.
Negative Data Utility: While naively mixing positive and negative data in standard Flow Matching degraded performance, ConFlow successfully leveraged negative data to improve constraint satisfaction.

Significance and Claims

The paper claims that ConFlow represents a shift from treating constraints as post-hoc corrections to embedding them structurally within the generative model. By jointly designing the training objective and the source distribution, ConFlow effectively reduces the training–inference gap.

The authors argue that this approach is particularly significant for robotics because:

It improves safety and reliability by internalizing constraints, reducing reliance on potentially imperfect inference-time guidance.
It enhances data efficiency by utilizing abundant non-expert (negative) demonstrations, addressing the bottleneck of expensive expert data collection.
It produces smoother, higher-quality trajectories by leveraging the structural priors of Gaussian Processes.

The work suggests that embedding task-relevant structure directly into flow-based generative models is a promising direction for safer and more capable robot motion generation. Future work is proposed to extend this to higher-dimensional systems (e.g., articulated manipulators) and real-world platforms.