💻 computer science

CLASH: Collision Learning via Augmented Sim-to-real Hybridization to Bridge the Reality Gap

The paper introduces CLASH, a data-efficient framework that bridges the sim-to-real gap in contact-rich robotics by learning a parameter-conditioned impulsive collision surrogate model from limited real-world data and integrating it into a standard simulator, thereby significantly improving prediction accuracy, search efficiency, and the success rate of transferred control policies.

Original authors: Haotian He, Ning Guo, Siqi Shi, Qipeng Liu, Wenzhao Lian

Published 2026-03-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Haotian He, Ning Guo, Siqi Shi, Qipeng Liu, Wenzhao Lian

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 you are trying to teach a robot how to play a game of billiards. You want the robot to learn how to hit a ball so it rolls exactly where you want it to go.

The problem is, you can't just let the robot practice on a real table for weeks. It would take too long, the balls might get damaged, and the robot might break something. So, you decide to teach it in a video game simulation first.

The Problem: The "Video Game" vs. The "Real World"

In your video game (the simulator), the physics are pretty good, but they aren't perfect. The game engine has to make shortcuts to run fast.

The Reality Gap: In the game, when two balls hit, they might bounce off at a slightly wrong angle or lose a tiny bit of speed that they wouldn't lose in real life.
The Consequence: When you finally let the robot try the real shot, it misses because it learned the "game physics," not the "real physics."

The Solution: CLASH (The "Smart Translator")

The paper introduces a new method called CLASH (Collision Learning via Augmented Sim-to-real Hybridization). Think of CLASH as a smart translator or a specialized coach that bridges the gap between the video game and reality.

Here is how it works, using a simple analogy:

1. The "Base Coach" (Simulation Distillation)

First, the researchers train a neural network (a type of AI) on millions of fake collisions inside the video game.

Analogy: Imagine a coach who has watched every single billiard game in the history of video games. This coach knows the "rules" of the game engine perfectly. They learn the general patterns of how balls bounce, spin, and slide.
Result: This coach is great at the game, but they still have the same "video game blindness" regarding real-world friction and imperfections.

2. The "Real-World Tuning" (System Identification)

Next, they take the robot to the real world and let it hit a ball just 10 times.

Analogy: The coach watches these 10 real hits. They realize, "Ah, in the real world, the table is a bit stickier than in the game, and the balls lose speed faster."
The Magic: Instead of throwing away the coach and starting over, they tweak the coach's settings. They adjust the "friction" and "bounciness" numbers in the coach's brain to match reality. This is done very quickly using math (gradients).

3. The "Fine-Tuning" (Avoiding Overfitting)

Here is the tricky part. If you teach the coach only on those 10 real hits, they might memorize those specific 10 hits and fail at everything else (this is called "overfitting").

Analogy: It's like a student who memorizes the answers to 10 practice questions but fails the test because they didn't learn the concepts.
The Fix: CLASH uses a technique called "early stopping." It lets the coach learn from the real data just enough to fix the big mistakes, but then stops before the coach forgets the general rules it learned from the millions of video game hits. It keeps the "video game knowledge" but corrects the "real-world errors."

The Result: The "Hybrid Simulator"

Now, they combine the video game engine with this new, tuned coach.

How it works: When the robot is planning a move, the computer runs the simulation. For most things (like moving the arm), it uses the fast video game engine. But the moment a collision happens (when the ball hits another ball), it switches to the CLASH coach to calculate the bounce.
Why it's better:
1. Accuracy: The bounce is calculated based on real-world physics, not game shortcuts.
2. Speed: Because the coach is a simple AI model, it calculates the bounce faster than the complex video game engine does.

The Proof: Does it Work?

The researchers tested this in two ways:

The "Golf Shot" Test: They asked the robot to hit a block to a specific spot.
- Old Way: The robot missed often because the simulation was wrong.
- CLASH Way: The robot hit the target much more accurately because the simulation predicted the bounce correctly.
The "Learning to Push" Test: They trained a robot to push a block along a path without falling off.
- Old Way: The robot learned a strategy that worked in the game but failed in reality.
- CLASH Way: The robot learned a strategy that worked in the game and transferred perfectly to the real world, doubling its success rate.

Summary

CLASH is like taking a video game physics engine, teaching it the general rules of the universe, and then giving it a quick "reality check" with a tiny amount of real-world data. This creates a hybrid simulator that is fast, accurate, and allows robots to learn skills in a computer that actually work when they step into the real world. It solves the problem of "what works in the game doesn't work in real life" without needing thousands of expensive real-world experiments.

1. Problem Statement

The "sim-to-real" gap remains a critical bottleneck in robotics, particularly for tasks involving contact-rich dynamics like collisions.

The Core Issue: Standard physics engines (e.g., MuJoCo) often trade accuracy for computational speed. They rely on approximations (e.g., linearized friction cones, penalty-based contacts) to solve Non-linear Complementarity Problems (NCPs) efficiently. These approximations lead to significant discrepancies in post-impact trajectories, angular velocity changes, and frictional dissipation.
Limitations of Existing Solutions:
- System Identification: Tuning physical parameters alone cannot capture unmodeled effects (e.g., complex material compliance).
- Pure Residual Learning: Training neural networks directly on real-world data requires large datasets and often suffers from overfitting or poor generalization.
- Domain Randomization: Often fails when policies rely heavily on specific environmental parameters.
Goal: Develop a data-efficient framework that creates a high-fidelity simulator for collision dynamics using only a handful of real-world samples, enabling robust policy transfer.

2. Methodology: The CLASH Framework

The authors propose CLASH (Collision Learning via Augmented Sim-to-real Hybridization), a three-stage framework that integrates a learned surrogate model into a standard physics engine as a plug-in module.

A. System Overview

The framework treats collisions as short-duration impulsive contacts. It replaces the default collision resolution of a simulator (MuJoCo) with a learned, differentiable surrogate model only when a collision is detected, retaining the original engine for continuous dynamics.

B. Three-Stage Procedure

Simulation Distillation (Pre-training):
- A differentiable surrogate model (a 3-layer MLP) is pre-trained on a large-scale dataset ( $100,000+$ samples) generated by the imperfect simulator (MuJoCo).
- Input: Pre-collision state ( $S_{pre}$ ) and system parameters ( $P$ , including friction coefficients $\mu$ and damping ratios $e$ ).
- Output: Predicted post-collision state ( $S_{post}$ ).
- Objective: Distill the simulator's "physical priors" into the neural network, creating a reusable base model.
System Identification and Adaptation:
- Data Collection: A small set of real-world collision data is collected (e.g., 10 samples) using a motion capture system.
- Parameter Identification: With the neural network weights frozen, the system optimizes the physical parameters ( $P$ ) to minimize the error between the model's prediction and real-world data. This uses gradient-based optimization.
- Fine-tuning: With the identified parameters ( $P_{real}$ ) fixed, the network undergoes small-step, early-stopped fine-tuning (e.g., 10 iterations). This captures the remaining non-parametric residuals (unmodeled effects) without overfitting.
Hybrid Simulator Construction:
- The adapted surrogate model is integrated back into the physics engine.
- During simulation, whenever a collision occurs, the engine invokes the neural network to predict the post-impact state instead of using the engine's native solver.
- This hybrid simulator is used for downstream tasks: Model-Based Optimization (e.g., CMA-ES) and Reinforcement Learning (RL).

3. Key Contributions

Data-Efficient Hybridization: CLASH achieves high accuracy with minimal real-world data (as few as 10 samples) by leveraging simulation priors, avoiding the data hunger of pure data-driven approaches.
Plug-and-Play Integration: The method creates a hybrid simulator by replacing only the collision module, requiring no modification to the underlying physics engine's core dynamics.
Dual Optimization Strategy: It uniquely combines gradient-based system identification (for interpretable parameters) with residual learning (for unmodeled effects), balancing interpretability and accuracy.
Performance Gains: The framework significantly reduces the computational cost of collision-heavy planning while improving prediction fidelity.

4. Experimental Results

The authors evaluated CLASH on a Franka robotic arm manipulating various blocks (semi-cylinder, square, triangle) in both model-based optimization and reinforcement learning tasks.

A. Collision Model Accuracy

Metric: Prediction accuracy based on relative error thresholds.
Result: The CLASH model significantly outperformed baselines (MuJoCo, MJX, and a neural network trained only on real data).
- For the semi-cylinder, CLASH achieved 0.76 accuracy vs. MuJoCo's 0.64 and a raw NN's 0.42.
- It successfully avoided overfitting on scarce data, whereas the raw NN suffered from severe overfitting.

B. Model-Based Optimization (CMA-ES)

Task: Finding optimal impact points and velocities to hit a target.
Accuracy: The hybrid simulator reduced positioning errors by 35.10% (semi-cylinder), 26.58% (square), and 26.29% (triangle) compared to MuJoCo.
Efficiency: Replacing the collision solver with the learned model reduced the wall-clock time for CMA-ES search by 42–48%.

C. Reinforcement Learning (Sequential Pushing)

Task: A hierarchical RL policy to push a semi-cylinder along a path without leaving a safe zone.
Result: Policies trained with the CLASH hybrid simulator transferred much more robustly to the real world.
- Success Rate (SR): Doubled compared to MuJoCo-trained policies (e.g., 8/10 vs. 4/10 on Route 1).
- Sub-goal Completion Rate (SGCR): Significantly higher, indicating better handling of sequential decision-making under collision dynamics.

5. Significance and Impact

Bridging the Reality Gap: CLASH demonstrates that accurate sim-to-real transfer for collision-heavy tasks is achievable without massive real-world datasets, making it practical for real-world deployment.
Computational Efficiency: By using a fast neural network for collision resolution, the framework accelerates planning algorithms (like CMA-ES) that are typically bottlenecked by expensive physics calculations.
Modular Approach: The "plug-in" nature of the framework suggests a generalizable recipe for upgrading existing simulators. Future work could extend this to other inaccurate submodules (e.g., torsional friction, compliant contacts) or use scalable geometric representations (SDFs) to generalize across shapes.

In conclusion, CLASH offers a pragmatic and highly effective solution to the sim-to-real gap in robotics, specifically addressing the notoriously difficult problem of modeling impulsive collisions with high fidelity and low data requirements.