File size: 14,470 Bytes
0c3dd1d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 | # Case 1 (ART scale vehicle): reproduction package
This folder reproduces the Case 1 results of the paper: the recovery tests (test randomization, TR) of four
controllers (MPC, NN-MPC, PID, NN-HD) in the Chrono digital twin of the 1/6-scale ART vehicle, and their comparison
with 60 physical runs (Sim2Real).
| Stage | Folder | What it does | Needs the 20 GB logs? |
|---|---|---|---|
| 0 | `runner/` | Lock-step simulation runner and the batch (episode-list) generator | runs only in the Docker image |
| 1 | `extract/` | Simulation logs -> one row of metrics per episode (`data/per_start/`) | yes |
| 2 | `physical/` | Physical and nominal-simulation logs -> per-run MAE, Tables II-III | no (14 MB, GitHub) |
| 3 | `analysis/` | Baseline orders; Tables I, IV, V, sensitivity, pair tests, Hoeffding | no |
| 4 | `mpc_failures/` | MPC failures from large heading errors | stage 4a only |
`data/` holds the small intermediate files, so stages 3 and 4b run in seconds without the raw logs.
`results/` holds the outputs that these commands produce.
## Environment
- Python 3.12.14 with `numpy==2.5.2` and `matplotlib==3.11.1` (`requirements.txt`; matplotlib only for the
figure of stage 4). Stages 1-4 are plain scripts; all inputs and outputs are given as arguments.
- The runner (stage 0) runs inside the Docker image `uwsbel/ros:iros2024`
(`uwsbel/ros@sha256:60118a64d8e751c1adafef1abebebbc504a5814d63eae5bb46120de5f7b4554c`, image Id
`sha256:73882e33184a5e9a586b5ce5167731ce0c569337104b273b05709a607730fa29`; controller commit `af8585558aab`,
Chrono fork commit `9d26ff7`). The released batches were run with 12 workers on one AMD Ryzen 7 5800X host.
```bash
python3.12 -m venv .venv && .venv/bin/pip install -r requirements.txt
PY=.venv/bin/python # all commands below are run from this folder (code/case1)
```
## Inputs
- Simulation logs: `simulation_logs/case1_<batch>.tar.gz` of this dataset (layout
`<batch>/episodes/<episode_id>/{episode_config.json, summary.json, ticks.csv.gz, state100.csv.gz, ...}`).
The paper uses B01, B03, B04, B05, B06 and B07. Unpack them so that the batch folders sit under `logs/runs/`:
`mkdir -p logs/runs && tar xzf case1_B01_main_tr.tar.gz -C logs/runs` (and the same for the other five).
- Physical runs and nominal-simulation logs: folder `2024/PathFollowingSim2real/TestingData` of
https://github.com/uwsbel/sbel-reproducibility (commit `1a098f37b6cdc69643bed9d9bf223ee2268e9fbc`):
`rd_path` (Path 1), `syn_path` (Path 2), `lot17` (Path 3); five runs per controller and path, and one nominal
simulation `sim_<controller>.csv` per path. The SHA256 of every physical log is in `data/physical_runs.csv`
(`log_sha256`).
- Reference waypoints of the Docker image (`/sbel/Desktop/waypoints_paths`): `data/waypoints/`.
## Stage 0: runner and batch definitions (`runner/`)
Not runnable without the Docker image; the released logs are the output of this code.
- `src/art_lockstep.cpp`: lock-step physics server. Vehicle and terrain setup are copied from the released
`demo_ROS_dART.cpp` and linked against the Chrono libraries of the image. `build.sh` builds it inside the image
(`build/art_lockstep`).
- `art_runner/`: episode loop with the ros_emulated latency schedule (25 Hz state publication, 10 Hz controller and
driver handlers, per-controller compute delay), bridge that runs the released controller code
(`path_follower.py`, `mpc_wpts.py`, NN checkpoints) unchanged with stubbed rclpy executors, plug-ins (the NN-HD
variants use `plugin:wrapped_released` with a steering scale), metrics and logging. Log columns:
`schemas/log_schema.md`; config fields: `schemas/episode_config.schema.json`.
- `campaign.py` + `run_campaign.sh`: batch driver (supervised worker pool, resume, provenance digest) and its
network-isolated container launcher: `bash runner/run_campaign.sh EPISODES.json OUTDIR 12`.
- `default_config.json` + `default_episode.py`: runner defaults and episode builders.
- `batches/generate_lists.py`: builds the episode lists of B01, B03-B07 (seeds, scenario tables, CRN mapping;
see its docstring). `python3 runner/batches/generate_lists.py --out-root lists` writes
`lists/<batch>/episodes.json`, the scenario tables and `generation_meta.json` (about 2 s; numpy only).
`batches/steering_bias.json` holds the steering-bias levels of D2a/D2b (0.013, 0.026).
Why the omitted modules of the original demo do not change the dynamics: the sensor manager (GPU camera, lidar),
the ROS manager and its read-only handlers, the soft-real-time busy wait and the visual assets (waypoint boxes
without collision) read the state but write no force or state; the only writer is the driver-inputs handler, which
the runner reproduces. As a check, the original binary driven by an open-loop ROS publisher produced 263 pose messages
that are bitwise identical to the server's states.
Batches used by the paper (episode counts as in the archives; V6 = MPC, NN-MPC, PID and NN-HD with
`ctrl_label` nnhdx175, nnhdx150, nnhdx100; V5 = V6 without nnhdx100):
| Batch | Content | Episodes |
|---|---|---|
| B01 | S2 recovery tests, 400 starts x V6, logged 40 s, scored at H = 15/25/40 s | 2,400 |
| B03 | Nominal simulation on Paths 1-3 x V6, controller phase {0, 20, 40, 60, 80} ms (phase 0 = `nominal_role` primary) | 90 |
| B04 | Monte Carlo (RF-A): start jitter dx, dy in [-0.2, 0.2] m, dyaw in [-0.067, 0.067] rad, random phase; 20 runs per path x V5 | 300 |
| B05 | RF-B: B04 runs plus D5 (delay 0.10 s, steering bias 0.013, pose noise 0.02 m / 0.01 rad) | 300 |
| B06 | Offset ranges S0, S1, S3, S4 (+ lateral-only, heading-only, Beta(3,3) shape), 200 starts each x V5, 25 s | 9,000 |
| B07 | Channel conditions D1a-D5 on the first 200 S2 starts x V5, 25 s | 9,000 |
The other archives (B02, B04w, B08-B13) are not used for the paper's results; their list generator is not included.
Note on `default_config.json`: the released episode configurations carry `tags.default_config_sha256 =
c63a5bab...f980`, the hash of the original version of this file. The copy here has the same values for every field
that the builders read and shorter descriptive text, so lists generated with it carry a different
`default_config_sha256`. Any change to the runner files also changes the runner code digest in `summary.json`.
## Stage 1: extract per-episode metrics (`extract/extract_metrics.py`)
```bash
for b in B01_main_tr B03_nominal B04_rf_a B05_rf_b B06_severity_shape B07_dist_recovery; do
$PY extract/extract_metrics.py --out data/per_start --batch $b --workers 14 --run-label-root logs logs/runs/$b
done
$PY extract/extract_metrics.py --selftest
```
- Inputs: unpacked batch folders; `data/waypoints/` (default waypoint directory).
- Outputs: `data/per_start/<batch>/recovery_part*.csv.gz` (B01, B06, B07) and `fullpath_part*.csv.gz` (B03-B05),
one row per episode, plus `MANIFEST.json` and, if an episode cannot be read, `errors_part*.jsonl`. Column
definitions are in the module docstring. The rank analysis uses `T25_trk100_L010H010_first` (bounded first entry
into the 0.10 m / 0.10 rad tube, H = 25 s) and the other tube and horizon columns for the sensitivity; the
baselines use `mae_lat_m`, `mae_head_rad`.
- Runtime (14 workers): B01 71 s, B06 163 s, B07 157 s, B03-B05 3-10 s each. Unpacking the six archives needs
about 10 GB of disk.
- `data/per_start/` in this package was produced by exactly these commands from the released archives
(`MANIFEST.json` files are not included). Rows are written in shards of 2000 as the workers finish, so a rerun
can put a row into a different shard; the set of rows and every value are the same.
## Stage 2: physical runs and nominal simulations (`physical/physical_runs.py`)
```bash
$PY physical/physical_runs.py <sbel-reproducibility>/2024/PathFollowingSim2real/TestingData data/waypoints results
cp results/physical_runs.csv results/nominal_sim_runs.csv data/
```
- Outputs: `physical_runs.csv` (60 runs: run MAEs and start quantities), `nominal_sim_runs.csv` (12 nominal runs),
`tables_II_III.json` / `.tex` (mean and SD of the five run MAEs, nominal-simulation MAE),
`physical_pair_bootstrap.json` (run-bootstrap interval of each pair difference), `physical_summary.json`
(start spread). In this package, the two CSV files are in `data/` and the other outputs in `results/`.
- Runtime: about 3 s.
## Stage 3: analysis (`analysis/`)
```bash
$PY analysis/baseline_orders.py data/per_start data/nominal_sim_runs.csv data/baseline_orders.json
$PY analysis/case1_rank_analysis.py data/per_start data/physical_runs.csv data/baseline_orders.json results \
> results/case1_rank_analysis_console.txt
```
- `baseline_orders.py` (about 1 s): predicted order of each baseline per path and metric (ascending run MAE):
`M-NOM` (B03, phase 0), `NOM-archived-2024` (nominal simulations of Tables II-III), `RF-A` (B04, mean of 20 runs),
`RF-B` (B05). For the Chrono batches, the NN-HD column is `ctrl_label` nnhdx175 on Paths 1-2 and nnhdx150 on
Path 3.
- `case1_rank_analysis.py` (about 4 s): per-start ranks of the settling times (ties shared, failures = H), TR order
by ascending mean rank, Kendall tau against the six physical orders, 2000 bootstrap replicates (seed 20261105),
exact permutation tests (252 allocations) with Holm adjustment, sensitivity and ablation. Output:
`results/case1_rank_analysis.json`. The TR order of Path 1-2 targets uses the nnhdx175 column and that of Path 3
targets the nnhdx150 column; the rank percentages of Table I use nnhdx175.
## Stage 4: MPC failures (`mpc_failures/`)
```bash
$PY mpc_failures/first_tick.py logs/runs/B01_main_tr data/b01_mpc_first_tick.csv # 4a, needs B01 logs
$PY mpc_failures/d3_range.py data/per_start data/b01_mpc_first_tick.csv \
results/mpc_failures.json results/mpc_failure_geometry.png # 4b
```
- 4a (under 1 s on the unpacked B01): first controller tick of each of the 400 MPC episodes (`e0`, `et0`-`et2`).
- 4b (about 1 s): classifies the 400 MPC starts (divergence / no entry / reached the tube) and counts the starts
beyond the e_long = 0 boundary and beyond the ridge of the released MPC stage cost; writes a two-panel figure.
## Paper item -> script -> output
| Paper item | Script | Output file : key |
|---|---|---|
| Table I (rank %, mean rank, failed %, mean ST, tau per offset range S0-S4) | `analysis/case1_rank_analysis.py` | `case1_rank_analysis.json` : `offset_sweep` (`rank_pct`, `mean_rank`, `fail_pct`, `n_all_recover`, `mean_st_all_recover`, `mean_tau_vs_physical`) |
| Text on Table I: S2 pairwise win rates 0.90-0.91, NN-MPC beats PID 0.75 [0.71, 0.80] | same | `offset_sweep[S2].pairwise_win_rate_ci95` |
| Tables II-III (mean +- SD of five run MAEs; nominal simulation) | `physical/physical_runs.py` | `tables_II_III.tex`, `tables_II_III.json` |
| Physical starts within 0.28 m, initial lateral error <= 0.24 m | same | `physical_summary.json` |
| Point orders of Tables II-III (physical orders) | `analysis/case1_rank_analysis.py` | `physical_order` |
| Table IV (tau per path and metric, mean tau [95 % CI], best selected, resolved pairs correct) | same (+ `analysis/baseline_orders.py`) | `method_comparison` (rows `TR (rank rule, S2)`, `Nominal simulation (2024 archive)` = nominal simulation of Tables II-III, `Monte Carlo, start jitter (RF-A)`, `Monte Carlo, jitter + disturbances (RF-B)`; row `Nominal simulation` = B03) |
| NN-MPC physical MAE 1.95-2.65 x MPC on Paths 1-2 | same | `method_comparison[...].selected_error_ratio_to_best` |
| TR minus nominal simulation +0.56, all 2000 replicates | same | `tr_minus_nominal_tables_II_III` |
| 32 of 36 pairs resolved; adjusted p = 0.294 and 0.056; TR orders 30/32 | same | `physical_pairwise_tests` (`p_perm`, `p_holm`), `method_comparison[TR...].resolved_pairs_correct` |
| Path 3 NN-MPC - PID lateral: 0.0249 m, [-0.0101, 0.0615] m | `physical/physical_runs.py` | `physical_pair_bootstrap.json` : `pairs.P3_lateral` |
| Sensitivity: horizons 15/25/40 s and nine tubes | `analysis/case1_rank_analysis.py` | `tube_horizon_sensitivity` |
| Number of starts: 94.2 % (10), 99.9 % (25), 100 % (>= 50) | same | `trial_number_sensitivity` |
| Hoeffding: smallest adjacent mean-rank gap 0.511 (n bound 350) | same | `hoeffding` |
| Hoeffding: epsilon_n = 0.239 for K = 4, n = 400, alpha = 0.05 | formula | `$PY -c "import math; print(3*math.sqrt(math.log(2*4/0.05)/(2*400)))"` -> 0.2389 |
| Table V (ablation by channel, D1a-D5) and "MPC fails from 8.5-10.5 %" | `analysis/case1_rank_analysis.py` | `ablation_by_channel` (`order`, `mpc_first_pct`, `mean_tau_vs_physical`, `fail_pct`) |
| MPC failures: 33/400 (29 divergences + 4 wheel-lock), boundary about 20-30 deg, 318 starts inside the boundary, none diverges | `mpc_failures/d3_range.py` | `mpc_failures.json` : `summary` (`div`, `noentry`, `all.beyond_ridge` = 82, `boundaries_deg_away`, `divergence_rate_inside`) |
## Verification of this package
The package was run in a fresh copy and compared with the outputs that the paper was produced from:
- `results/case1_rank_analysis.json`: every number equal (926 numeric leaves); only the free-text `label` differs.
- `data/physical_runs.csv`: all 60 rows equal in all 21 columns; nominal-simulation MAEs, Tables II-III and the 36
pair-bootstrap intervals bit-identical.
- `data/baseline_orders.json`: orders and scores bit-identical for all four baselines and six targets.
- `data/per_start/`: extracted from the released archives; all 21,090 rows of the six batches equal in every metric
column. Differences are only in identity fields that the release changed: `tags_json` (`ctrl_desc` text, internal
tags removed), `config_hash` (recomputed for the released config) and `summary_sha256` (rewritten `summary.json`).
All rows have `chk_all = 1` (extractor values agree with the runner summaries).
- `runner/batches/generate_lists.py` regenerates all 21,090 released episode configurations of B01 and B03-B07
exactly (after the runner's `config.normalize`), except `tags.default_config_sha256` (see Stage 0).
- `results/mpc_failures.json`: every number equal (2024 numeric leaves).
## Notes
- The steering-bias level 0.013 of D2a enters as a constant (`runner/batches/steering_bias.json`); the script that
estimated it from the archived logs is not part of this package.
- The physical and nominal-simulation logs are not copied here; they are public in the GitHub repository above.
|