Ewaluacja, benchmarki i środowiska
Metryki (success rate, ∫jerk², clearance, energy), MotionBenchMaker, MπNets, OMPL, OCRTOC. Symulatory: MuJoCo, Isaac, Drake, PyBullet.
TL;DR
W modułach 05-10 i 14 widzieliśmy kilkanaście planerów. Każdy z nich ma jakąś intuicję — który jest obiektywnie najlepszy? Odpowiedź: żaden. Każdy ma kompromis: szybkość vs jakość, jednostkowy vs wielokrotny, optymalność vs prostota. Ten moduł podaje liczby — w tabeli niżej widzisz 5 planerów na 3 mapach testowych, z 5 seeds per kombo. Pełna metodologia: success rate, mean planning time, path length, smoothness, clearance.
Drugie zadanie tego modułu: katalogowanie ekosystemu — symulatory (MuJoCo, Isaac, Drake, PyBullet, Gazebo), frameworki planistyczne (MoveIt2, OMPL, cuRobo), benchmark suites (MotionBenchMaker, MπNets, OCRTOC). Bez tego nie ma jak porównać wyników z literaturą ani reprodukować eksperymentów.
Live benchmark — 5 planerów × 3 mapy
Tabela poniżej generuje się na żywo w przeglądarce — uruchamiamy każdy planer 5 razy (różne seeds) na każdej z 3 map testowych. Total: 75 biegów. Po załadowaniu strony chunked compute wykonuje je jeden po drugim, aktualizując progress bar.
Metryki:
- Success rate: ile z N seeds biegów znalazło kolizjonowolną ścieżkę.
- Czas: średni czas wykonania (ms).
- Długość ścieżki: .
- Smoothness: — kara za drugą różnicę, mniejsze = gładsze.
- Clearance: wzdłuż ścieżki — minimalna odległość od najbliższej przeszkody. Większe = bezpieczniej.
Co zauważyć:
- RRT-Connect niemal zawsze najszybszy.
- RRT* daje krótsze ścieżki (asymptotic optimality), ale wolniejszy.
- PRM wolniejszy w „learning phase" ale gdyby było wiele zapytań, koszt amortyzuje się.
- CHOMPstartując od linii prostej, dla łatwych map konwerguje szybko; dla trudnych (narrow-passage) może utknąć w lokalnym minimum (success rate < 100%).
Live benchmark: 5 planerów × 3 mapy × 5 seeds
⟳ 0% (0 / 75)| Algorytm | Success rate | Czas (ms) | Długość ścieżki | Smoothness ↓ | Clearance ↑ |
|---|---|---|---|---|---|
| RRT | licząc... | ||||
| RRT-Connect | licząc... | ||||
| RRT* | licząc... | ||||
| PRM | licząc... | ||||
| CHOMP | licząc... | ||||
Uwaga: liczby są dla map 2D (toy benchmark dla intuicji). Dla realistycznych zadań 7D Pandy patrz MotionBenchMaker / MπNets dataset poniżej.
Profesjonalne benchmark suites
Powyższe demo używa naszych 3 toy maps — dobre dla intuicji, ale niewystarczające do publikacji wyników. Standardy w robotyce:
OMPL Benchmark
Standard de facto dla porównywania planerów próbkowych. OMPL ma wbudowane Benchmark framework — wystarczy zdefiniować problem (start, goal, geometria), wybrać planery, ustalić czas/iteracje, OMPL uruchamia setki biegów i generuje raport z mean ± std. Stosowane w 90% papersów o sampling-based.
MotionBenchMaker
Chamzas et al. 2022— zestaw 40+ realistycznych scenariuszy manipulacyjnych dla 5 robotów (Panda, Baxter, Fetch, UR5, Kuka). Każdy scenariusz: kompletna scena 3D (URDF+SDF) + zadanie pick&place. Standardowy benchmark dla 7-DOF planowania. KavrakiLab/motion_bench_maker.
MπNets Dataset
Fishman et al. 2022 — 3.6M pre-computed expert trajectories Pandy dla różnych scen, użyte do treningu Motion Policy Networks. Można też używać jako benchmark — porównaj generated trajectories z expertami. fishbotics/motion-policy-networks.
cuRobo Benchmark
Sundaralingam et al. 2023 — benchmark dla GPU-accelerated planning. cuRobo pokazuje 50-100× speedup vs CPU planery na typowych zadaniach Pandy.
OCRTOC (Open Cloud Robot Table Organization Challenge)
Konkurencyjny benchmark od Alibaba/Tsinghua — robot musi przearanżować obiekty na stole zgodnie ze specyfikacją. ocrtoc.org.
Symulatory fizyki
Każdy planer testujemy najpierw w symulacji — sim-to-real gap jest realnym problemem, ale brak symulacji oznacza zero iteracji. Sześć najpopularniejszych opcji:
Symulatory fizyki
| Narzędzie | Język | Kluczowe cechy | Wsparcie Pandy | Licencja |
|---|---|---|---|---|
| MuJoCo (Google DeepMind) | C/C++ + Python |
| MJCF | Apache 2.0 |
| NVIDIA Isaac Sim / Isaac Lab | Python (PhysX backend) |
| natywne | komercyjna (free dla badań) |
| Drake (Robot Locomotion Group, MIT) | C++ + Python |
| URDF/glTF | BSD-3 |
| PyBullet (Bullet Physics) | Python (Bullet C++ backend) |
| URDF/glTF | Zlib |
| CoppeliaSim (V-REP) | Lua, Python, C++ |
| URDF/glTF | edukacyjna (free) |
| Gazebo (Ignition / Gazebo Sim) | C++ + Python + ROS |
| URDF/glTF | Apache 2.0 |
Reguła wyboru
- Manipulacja stacjonarna (Panda na stole) → MuJoCo (dokładny soft contact, szybki, otwarty)
- RL na dużą skalę (tysiące rolloutów) → Isaac Lab (GPU parallel)
- Contact-rich (chwytanie, łapanie, in-hand manipulation) → Drake (najlepsze hydroelastic contact)
- Szybki prototyp w Pythonie → PyBullet
- Integracja z ROS2 → Gazebo Sim
- Demo edukacyjne z GUI → CoppeliaSim
Frameworki planistyczne
Algorytmy z modułów 05-10 są w tych bibliotekach gotowe do użycia — typowo niekorzystne reimplementować ręcznie.
Frameworki planistyczne
| Narzędzie | Język | Kluczowe cechy | Wsparcie Pandy | Licencja |
|---|---|---|---|---|
| MoveIt2 | C++ + Python + ROS2 |
| natywne | BSD |
| OMPL (Kavraki Lab, Rice) | C++ (Python bindings) |
| via plugin | BSD |
| cuRobo (NVIDIA) | Python + CUDA |
| natywne | Apache 2.0 |
| Tesseract Robotics | C++ + Python + ROS |
| URDF/glTF | Apache 2.0 |
| Drake Planner | C++ + Python |
| URDF/glTF | BSD-3 |
| Pinocchio + HPP | C++ + Python |
| URDF/glTF | BSD-2 |
Typowy stack 2024
- Manipulacja z ROS2: MoveIt2 (planning) + Gazebo (sim) + RViz (viz). Działa out-of-the-box dla Pandy (panda_moveit_config).
- RL / GPU: Isaac Lab + cuRobo (collision + trajectory init).
- Trajectory optimization dla produkcji: Tesseract Robotics (welding/painting) lub Drake (research).
- Humanoid / floating-base: Pinocchio + HPP + TSID/OpenSoT (stack of tasks).
Reprodukowalność i protokoły porównań
Większość papersów w robotyce ma kiepską reprodukowalność — wyniki zależą od implementacji, parametrów, hardware. Praktyki podnoszące jakość porównań:
- Identyczny zbiór zadań: użyj MotionBenchMaker / MπNets — nie wymyślaj własnych „losowych" scenariuszy.
- Deterministyczny seed: dla każdego biegu zapisz seed; w papersach raportuj N=100+ seeds z mean ± std.
- Identyczne stop criteria: time budget OR max iterations OR cost threshold — wybierz JEDNO i trzymaj konsekwentnie.
- Identyczny hardware: CPU vs GPU różnią się 10-100×. Raportuj specs (CPU model, GPU, RAM).
- Code release: GitHub repo z exact parametrami + Dockerfile dla reprodukowalności.
- Tail vs mean: dla real-time MPC raportuj p99 latency, nie tylko mean. „Mean 5 ms" z p99 = 200 ms NIE jest real-time.
Sim-to-real i kalibracja
Wszystko powyżej ewaluuje w symulacji. Realny robot zwraca inne wyniki. Sim-to-real gap bierze się z:
- Modelowanie: nieliniowości fizycznej (tarcie, luzy mechaniczne, deformacja)
- Sensors: kamera ma szum, latency, brakuje klatek; encoderowy odczyt joints może drifować
- Aktuatory: motorom Pandy odpowiada dynamika z opóźnieniem ~10ms (PD inside firmware), w sim często idealne
- Calibration: deklarowana kinematyka Pandy może różnić się od fizycznej o mm (offset baz)
Strategie redukcji gap:
- Domain randomization: w sim trenuj policy z losowanymi parametrami (tarcie, masy, kamera noise) → policy uczy się być robust
- System identification: zmierz fizyczne parametry robota (impulse response, friction), aktualizuj symulator
- Online adaptation: meta-RL / adaptive control dostosowuje się w trakcie wykonania
- Direct sim-to-real transfer: dla planowania motion (nie RL) gap jest mniejszy — symulacyjna trajektoria zwykle działa też w realu z drobną kalibracją kinematyki
Ściąga
Standard set metryk
- Success rate = N_success / N_total
- Planning time — mean ± std (lub p50/p99 dla real-time)
- Path length
- Smoothness (jerk-square integral)
- Clearance (SDF along path)
- Energy
- Manipulability
Domyślne stosy (2024)
- Manipulacja ROS2: MoveIt2 + Gazebo
- RL/GPU: Isaac Lab + cuRobo
- Research trajopt: Drake
- Humanoid: Pinocchio + HPP + TSID
Reproducible benchmark checklist
- identyczny dataset zadań (MotionBenchMaker)
- deterministyczny seed, N ≥ 100 prób
- tylko jeden stop criterion (czas LUB iter LUB cost)
- specs hardware + Dockerfile
- mean ± std (oraz p99 dla real-time)
Referencje
- Chamzas et al., „MotionBenchMaker: A Tool for Generating and Benchmarking Motion Planning Datasets" (IEEE RA-L 2022). GitHub.
- Fishman et al., „Motion Policy Networks" (CoRL 2022) — MπNets dataset.
- Sundaralingam et al., „cuRobo: Parallelized Collision-Free Robot Motion Generation" (ICRA 2023).
- Moll, Sucan, Kavraki, „Benchmarking Motion Planning Algorithms: An Extensible Infrastructure for Analysis and Visualization" (IEEE RAM 2015) — OMPL Benchmark.
- Todorov, Erez, Tassa, „MuJoCo: A physics engine for model-based control" (IROS 2012).
- Makoviychuk et al., „Isaac Gym: High Performance GPU-Based Physics Simulation For Robot Learning" (NeurIPS 2021).
- Tedrake & the Drake Development Team, „Drake: Model-based design and verification for robotics" (2019).
- Coleman, Sucan, Chitta, Correll, „Reducing the Barrier to Entry of Complex Robotic Software: a MoveIt! Case Study" (JOSER 2014).
- Carpentier et al., „The Pinocchio C++ library: A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives" (SII 2019).
- Liu, Mateti, Yi & Rosell, „OCRTOC: A Cloud- Based Competition and Benchmark for Robotic Grasping and Manipulation" (IEEE RA-L 2022).