| # D3IL avoiding-v0: GlobMP as the projector of DiRecT's diffusion sampler |
|
|
| GlobMP replaces DiRecT's IPOPT projection inside DiRecT's own sampler, on the shared checkpoint of the D3IL `avoiding-v0` |
| benchmark with the twelve-constraint (hard) set: ten circular keep-outs (the enlarged pillar, the original pillars and three |
| virtual 2 cm keep-outs in the middle band) and two half-planes. Everything else (checkpoint, sampler, 32 sampling steps, |
| dynamics fit, normalizer, environment, scoring) is DiRecT's released code in `avoiding_baselines/`. |
|
|
| ## Result |
|
|
| On DiRecT's own evaluation episodes (seed 0, 100 episodes), GlobMP is safe in **0.95** of them and reaches the goal in |
| **0.98**, against DiRecT's 0.87 and 0.97 (paper Table, same checkpoint and constraint set), and every plan it returns is |
| feasible at every instant. Over four seeds (0-3, 400 episodes) GlobMP averages **0.865** and **0.968**, on par with |
| DiRecT's single seed; it is slower (safe rollouts take 78 steps against 61, and each plan takes longer to compute). |
| The setting is replanning every 4 steps (the execution horizon the paper states; DiRecT's released evaluation defaults |
| to 8), with the projector described below. |
|
|
| All GlobMP runs (100 episodes each; deadline = per projection / a plan's first projection, in s; time = seconds per plan |
| for a batch of 50 environments on the run's CPU workers, so it is comparable within this table only): |
|
|
| | run | seed | replan | margin (m) | deadline (s) | guidance steps | safety | goal | steps | time/plan (s) | |
| |---|---|---|---|---|---|---|---|---|---| |
| | T3_r4 | 0 | 4 | 0.02 | 3 / 12 | all | **0.95** | 0.98 | 77.9 | 15.1 | |
| | U1_seed1 | 1 | 4 | 0.02 | 3 / 12 | all | **0.88** | 0.96 | 76.1 | 17.0 | |
| | T4_effort | 0 | 8 | 0.02 | 5 / 20 | all | **0.85** | 0.96 | 75.6 | 32.8 | |
| | U2_seed2 | 2 | 4 | 0.02 | 3 / 12 | all | **0.82** | 0.98 | 76.5 | 17.1 | |
| | U8_seed3 | 3 | 4 | 0.02 | 3 / 12 | all | **0.81** | 0.95 | 77.1 | 17.5 | |
| | T1_r8 | 0 | 8 | 0.02 | 3 / 12 | all | **0.81** | 0.96 | 74.3 | 22.5 | |
| | U7_r3 | 0 | 3 | 0.02 | 3 / 12 | all | **0.75** | 0.93 | 76.3 | 15.0 | |
| | U4_last16 | 0 | 4 | 0.02 | 3 / 12 | last 16 | **0.74** | 0.96 | 69.0 | 10.3 | |
| | T2_m25 | 0 | 8 | 0.025 | 3 / 12 | all | **0.74** | 0.83 | 78.1 | 23.8 | |
| | U5_last8 | 0 | 4 | 0.02 | 3 / 12 | last 8 | **0.72** | 0.95 | 67.2 | 5.6 | |
| | U3_fastdl | 0 | 4 | 0.02 | 1 / 6 | all | **0.55** | 0.91 | 75.2 | 10.2 | |
| | U6_fastest | 0 | 4 | 0.02 | 1 / 6 | last 16 | **0.48** | 0.93 | 68.5 | 6.0 | |
|
|
| DiRecT's released evaluation replans every 8 steps (its default); the best GlobMP settings replan every 4. |
|
|
| ## What GlobMP solves at each projection |
|
|
| DiRecT projects the clean-trajectory estimate (16 transitions) onto the constraint set with the fitted linear dynamics, |
| minimizing 1/2 ||X - X_ref||^2 and imposing the keep-outs at the 16 states. `globmp_projector.py` solves the same |
| projection with GlobMP (the `globmp` package at the repository root): |
|
|
| * variables: the 15 future end-effector positions, joined by straight segments (C^0 spline of degree-1 pieces, the current |
| position fixed, the end free); actions and commanded positions are affine in them through the dynamics fit, so the |
| cost is DiRecT's own, over all channels; |
| * every keep-out (radius + margin) and both half-planes hold at every point of the motion, not only at the 16 states |
| (sphere and half-space blocks); |
| * the environment clips each action (dx in [-1.25, 1.25] cm, dy in [0, 1.25] cm per step): action bounds and an action-rate |
| bound (99th percentile of the 96 demonstrations) are imposed as linear blocks, so every plan is executable; |
| * margin recovery: a robot that starts a plan closer to a keep-out than the margin gets a plan that wins the margin back |
| (at most 1 cm per step) instead of grazing the keep-out; |
| * warm starts: within a plan the state is fixed, so the previous denoising step's solution is feasible for the next one; |
| Algorithm 2 then descends the new cost from a feasible start. A plan's first projection gets a longer deadline. |
|
|
| ## Setup |
|
|
| 1. Environment: `avoiding_baselines/env/direct-d3il.yml` (DiRecT's export). On drivers below CUDA 12.8 install the |
| `cu126` build of torch 2.11 instead of `cu128`; install the pip pins with `--no-deps` (the export is a full freeze) |
| and run with `PYTHONNOUSERSITE=1` and `LD_LIBRARY_PATH=$CONDA_PREFIX/lib`. |
| 2. `run/run_eval.sh` copies the checkpoint into DiRecT's `logs/`, applies `run/direct_hook.patch` (three lines in |
| `policy/direct.py`: `DIRECT_PROJECTOR=globmp` selects `GlobMPProjector`), and runs the evaluation: |
|
|
| ```bash |
| PY=<direct-d3il>/bin/python DEVICE=cuda:0 NWORK=28 bash run/run_eval.sh 0 1 2 3 # seeds 0-3, 100 episodes each |
| ``` |
|
|
| Results land in `avoiding_baselines/DiRecT/logs/avoiding-v0/eval/globmp_seed<s>/summary.json` (safety_rate, success_rate). |
|
|
