Moduł 18 · Ewaluacja i wdrożenie

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: iqi+1qi\sum_i \|q_{i+1} - q_i\|.
  • Smoothness: iqi+12qi+qi12\sum_i \|q_{i+1} - 2 q_i + q_{i-1}\|^2 — kara za drugą różnicę, mniejsze = gładsze.
  • Clearance: mintΦ(qt)\min_t \Phi(q_t) 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)
AlgorytmSuccess rateCzas (ms)Długość ścieżkiSmoothness ↓Clearance ↑
RRTlicząc...
RRT-Connectlicząc...
RRT*licząc...
PRMlicząc...
CHOMPlicząc...
Czytanie metryk: success rate — frakcja udanych biegów z 5 prób (różne seedy); czas — średni czas wykonania (mniej = szybciej); długość — euklidesowa długość ścieżki (mniej = krótsza); smoothness— Σ‖q''‖² (mniej = gładsza trajektoria); clearance — min SDF wzdłuż ścieżki (więcej = bezpieczniej od przeszkód). Wszystkie średnie liczone z udanych biegów; czas — z wszystkich. Nieudane biegi (success=false) zaznaczone jako „—".

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ędzieJęzykKluczowe cechyWsparcie PandyLicencja
MuJoCo (Google DeepMind)C/C++ + Python
  • Najlepsza dokładność soft contact + szybkość dla manipulatorów
  • WASM build dostępny (mujoco_wasm) → uruchamia się w przeglądarce
  • Wbudowane planery (mujoco_mpc): iLQG, predictive sampling
MJCFApache 2.0
NVIDIA Isaac Sim / Isaac LabPython (PhysX backend)
  • Akcelerowane GPU — tysiące równoległych instancji dla RL
  • Photorealistic rendering (RTX), USD scenes
  • Bezpośrednia integracja z cuRobo dla GPU collision
natywnekomercyjna (free dla badań)
Drake (Robot Locomotion Group, MIT)C++ + Python
  • Najlepsza implementacja contact-implicit trajectory optimization
  • Multibody dynamics z hydroelastic contact
  • Pełna integracja z optymalizatorami (SNOPT, IPOPT, Gurobi)
URDF/glTFBSD-3
PyBullet (Bullet Physics)Python (Bullet C++ backend)
  • Najprostsza składnia, popularny w RL community
  • Wolniejszy niż MuJoCo/Isaac, ale wystarczy do prototypowania
  • OpenAI Gym integrations
URDF/glTFZlib
CoppeliaSim (V-REP)Lua, Python, C++
  • Najlepsze GUI dla scenariuszy edukacyjnych
  • Wiele wbudowanych planerów (OMPL frontend)
  • Wolniejsza fizyka niż MuJoCo/Isaac
URDF/glTFedukacyjna (free)
Gazebo (Ignition / Gazebo Sim)C++ + Python + ROS
  • Standard dla ROS2 — pełna integracja z MoveIt2
  • Wybór silników fizyki (DART, Bullet, ODE, Simbody)
  • Sensor models (kamery, LiDAR) gotowe z ROS
URDF/glTFApache 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ędzieJęzykKluczowe cechyWsparcie PandyLicencja
MoveIt2C++ + Python + ROS2
  • Najpopularniejszy stack dla manipulatorów (defacto standard)
  • Backend: OMPL (sampling) + STOMP / CHOMP / TrajOpt (optymalizacja)
  • Pełna integracja z ROS2: collision, kinematics, planning, execution
natywneBSD
OMPL (Kavraki Lab, Rice)C++ (Python bindings)
  • Najpełniejsza implementacja sampling-based: 30+ wariantów
  • Standard benchmark dla planerów próbkowych
  • Backend dla MoveIt2 (domyślny algorytm: RRTConnect)
via pluginBSD
cuRobo (NVIDIA)Python + CUDA
  • GPU-accelerated motion planning — najszybszy stack w 2024
  • Pełne RRT-Connect dla Pandy w &lt; 50 ms (vs ~500 ms CPU)
  • Integracja z Isaac Lab
natywneApache 2.0
Tesseract RoboticsC++ + Python + ROS
  • Specjalizacja: planowanie ścieżek dla produkcji (welding, painting)
  • Trajopt natywnie zintegrowany
  • ROS-independent (działa bez ROS)
URDF/glTFApache 2.0
Drake PlannerC++ + Python
  • Trajectory optimization stack z najsilniejszym wsparciem dla dynamics
  • Contact-implicit, mixed-integer for footstep planning
  • Integracja z OcaSADi/Mathematical Programming
URDF/glTFBSD-3
Pinocchio + HPPC++ + Python
  • Pinocchio: najszybsza implementacja RNEA, jakobianów, manifolds
  • HPP: bidirectional RRT + path optimization (LAAS/CNRS)
  • Stosowany w Humanoid Path Planner dla TALOS, HRP-2
URDF/glTFBSD-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ń:

  1. Identyczny zbiór zadań: użyj MotionBenchMaker / MπNets — nie wymyślaj własnych „losowych" scenariuszy.
  2. Deterministyczny seed: dla każdego biegu zapisz seed; w papersach raportuj N=100+ seeds z mean ± std.
  3. Identyczne stop criteria: time budget OR max iterations OR cost threshold — wybierz JEDNO i trzymaj konsekwentnie.
  4. Identyczny hardware: CPU vs GPU różnią się 10-100×. Raportuj specs (CPU model, GPU, RAM).
  5. Code release: GitHub repo z exact parametrami + Dockerfile dla reprodukowalności.
  6. 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:

  1. Domain randomization: w sim trenuj policy z losowanymi parametrami (tarcie, masy, kamera noise) → policy uczy się być robust
  2. System identification: zmierz fizyczne parametry robota (impulse response, friction), aktualizuj symulator
  3. Online adaptation: meta-RL / adaptive control dostosowuje się w trakcie wykonania
  4. 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 =iqi+1qi= \sum_i \|q_{i+1} - q_i\|
  • Smoothness =0Tq...(t)2dt= \int_0^T \|\dddot q(t)\|^2 \, dt (jerk-square integral)
  • Clearance =mintΦ(q(t))= \min_t \Phi(q(t)) (SDF along path)
  • Energy =0Tτ(t)q˙(t)dt= \int_0^T \tau(t)^\top \dot q(t) \, dt
  • Manipulability =mintw(q(t))= \min_t w(q(t))

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).