Model card: cover both robots (G2 + Piper)

README.md

@@ -6,108 +6,110 @@ tags:
   - openpi
   - pi0
   - lerobot
-  - bimanual
   - manipulation
+  - bimanual
 library_name: openpi
 pipeline_tag: robotics
 ---
 
-# G2 Dual-Arm — π₀ policy + LeRobot dataset
+# openpi_lab — real-robot π₀ checkpoints + the datasets they were trained on
 
-A π₀ (pi0) vision-language-action policy trained on an **AgiBot G2** dual-arm robot, together
-with the dataset it was trained on. The policy runs closed-loop on the real robot from live
-camera observations and completes the task.
+Two robots, each with its trained π₀ weights and the exact LeRobot dataset behind them.
+Everything here has been run on real hardware, not only in replay.
 
-**Task:** `Make a yogurt bowl with cereal and fruit.`
+```
+g2/model/        π₀, 30k steps            g2/dataset/     58 ep / 48,332 frames / 10 Hz
+piper/model/pi0/     π₀,  30k steps       piper/dataset/  125 ep / 71,702 frames / 30 Hz
+piper/model/pi05/    π₀.₅, 30k steps
+```
 
-| | |
-|---|---|
-| Robot | AgiBot G2, dual 7-DOF arms + 2 grippers |
-| Action / state | 16-D `[L_j1..j7, L_grip, R_j1..j7, R_grip]`, **absolute joint radians** + boolean gripper |
-| Cameras | `head` (400×640), `hand_left` / `hand_right` (528×640), RGB |
-| Control rate | **10 Hz** (dataset fps); robot servo runs at 30 Hz |
-| Action chunk | 50 |
+| | **G2** | **Piper** |
+|---|---|---|
+| Robot | AgiBot G2, **dual** 7-DOF arm | AgileX Piper, **single** 6-DOF arm |
+| Action / state | 16-D `[L_j1..7, L_grip, R_j1..7, R_grip]` | 7-D `[j1..j6, gripper]` |
+| Action space | absolute joint rad + boolean gripper | joint **delta** from episode start + absolute gripper (m) |
+| Cameras | head + hand_left + hand_right | head + hand |
+| Control rate | **10 Hz** | **30 Hz** |
+| Chunk | 50 | 16 |
+| Tasks | 1 (`Make a yogurt bowl with cereal and fruit.`) | 4 (pen→cup, carrot→bowl, blocks→drawer, stack bowls) |
 
-## Contents
+## Download
 
-```
-params/                       π₀ weights (12 GB, JAX/orbax)
-assets/                       norm stats bundled with the checkpoint
-_CHECKPOINT_METADATA
-dataset/g2_dualarm_yogurt_rs10/   LeRobot v2.1 — 58 episodes / 48,332 frames / 10 Hz
+```bash
+hf download siyuhsu/openpi_lab --include "g2/model/*"       --local-dir ./g2_ckpt
+hf download siyuhsu/openpi_lab --include "piper/model/pi0/*" --local-dir ./piper_pi0
+hf download siyuhsu/openpi_lab --include "g2/dataset/*"     --local-dir ./g2_data
 ```
 
-## Training
+## Serving
 
-| | |
-|---|---|
-| Config | `pi0_g2_dualarm` (openpi) |
-| Steps | 30,000, batch 32, 1× H200 |
-| Wall time | 17 h 06 m |
-| Final loss | 0.0047 (from 0.3207) |
-
-Actions are converted to deltas at train time via `make_bool_mask(7, -1, 7, -1)` — 7 joint
-dims as deltas, gripper kept absolute, per arm.
+```bash
+# G2
+python examples/g2_dualarm/g2_serve_openpi.py --config pi0_g2_dualarm \
+    --ckpt-dir ./g2_ckpt/g2/model --port 8000
+# Piper
+python examples/piper/code/piper_serve_openpi.py --config pi0_piper_4task \
+    --ckpt-dir ./piper_pi0/piper/model/pi0 --port 8000
+```
 
-## Dataset notes (read before training on it)
+Each server publishes its deployment contract in the connect-time metadata
+(`action_chunk_size`, `action_rate_hz`, `robot_servo_hz`, `action_space`, `reset_pose`).
 
-* **`_rs10` = resampled to a uniform 10 Hz grid.** The raw recordings are badly jittered
-  (only 13.6% of inter-frame gaps fall within ±20% of the median) because the on-robot
-  *disk writer* — not the cameras or the control loop — is the bottleneck: the control loop
-  runs at a rock-steady 29.5–29.9 Hz and the cameras at ~30 Hz, but 60–65% of frames are
-  dropped before they reach disk. Naive contiguous re-indexing distorts episode duration by
-  −18%…+35%; the resampled variant is accurate to +0.06%.
-* **The right gripper's position sensor is dead** (constant 0.2173 across all 60 episodes),
-  so both gripper dims come from the *command* boolean, not from a sensor.
-* **Gripper polarity in this dataset: `1.0` = OPEN, `0.0` = CLOSED.** The underlying raw
-  field is named `gripper_closed`, and **the name is backwards relative to the physical
-  behaviour**. Verified from the physical semantics: in episode 27 the right gripper dim
-  flips `1.0 → 0.0` at step 54, exactly as the right arm reaches its deepest point — the
-  grasp. If you drive real hardware, confirm your wire convention separately; on this robot
-  the DDS tool wire is the opposite (`1.0` = CLOSED), so the mapping is an inversion.
-* 2 of 60 recorded episodes are excluded (camera dropouts mid-episode, broken on the robot).
+> ⚠️ **Advance the action chunk at the DATASET rate, not the servo rate.** G2 is 10 Hz,
+> Piper is 30 Hz. Actions are absolute (G2) or delta-from-start (Piper) joint targets;
+> stepping G2's chunk at 30 Hz would execute it 3× too fast.
 
-## Evaluation
+## Results
 
-Offline replay against a live server, 120 frames over 12 episodes:
+**G2** — offline replay against a live server, 120 frames / 12 episodes:
 
 | metric | value | threshold |
 |---|---|---|
 | joint MAE | **0.28°** (worst 0.95°) | < 5° |
 | gripper agreement | **99.8%** | > 90% |
 | delta direction cosine | **0.999** | > 0.8 |
-| first-step jump | 1.47° (worst 5.43°) | worst < 15° |
-
-On real hardware the policy was validated in four stages — dry-run → ground-truth replay →
-policy-replay on dataset observations → live closed loop — and completes the task in the
-last stage.
-
-## Using the weights
-
-```bash
-# serve (openpi)
-python examples/g2_dualarm/g2_serve_openpi.py \
-    --config pi0_g2_dualarm --ckpt-dir <this repo>/  --port 8000
-```
-
-The server publishes the deployment contract in its connect-time metadata:
-`action_chunk_size=50`, `action_rate_hz=10.0`, `robot_servo_hz=30.0`,
-`action_space="absolute_joint_rad_plus_gripper_cmd"`, plus a `reset_pose`.
-
-> ⚠️ **Advance the chunk at 10 Hz, not at the servo rate.** Actions are absolute joint
-> targets; stepping them at 30 Hz executes the trajectory 3× too fast.
-
-## Caveats
 
-* Single task, single scene, 58 demonstrations. Expect it to be brittle outside the
-  recorded prop layout.
-* The policy is stochastic (flow matching): identical input gives joint outputs differing
-  by ~1.2°. Do not use repeated inference as a determinism check.
-* **Do not JPEG-compress observations to save bandwidth.** Measured on this checkpoint,
-  JPEG q92/q85 flips the *gripper decision* outright (|Δ| = 1.007 on a boolean dim, 3 of 6
-  trials) while joint dims move only ~2°. The mean error hides this completely.
+Validated on hardware in four stages — dry-run → ground-truth replay → policy-replay on
+dataset observations → live closed loop — and completes the task in the last stage.
+
+**Piper** — replay eval, all 4 tasks GO: pi0 joint MAE 0.74° / cos 0.940; pi0.5 0.44° / cos 0.995.
+Real-robot success rates over 160 rollouts (10 per model × task × condition):
+
+| model | in-dist | OOD-L1 | overall |
+|---|---|---|---|
+| baseline QwenOFT | 55% | 30% | 42.5% |
+| ctxdemo QwenLAP | 80% | 75% | 77.5% |
+| **π₀** | **85%** | **80%** | **82.5%** |
+| π₀.₅ | 80% | 60% | 70% |
+
+## Things that will bite you
+
+* **G2 gripper polarity is inverted between dataset and wire.** In the dataset `1.0` = OPEN,
+  `0.0` = CLOSED — the raw field is called `gripper_closed` and **the name is backwards**
+  relative to the physical behaviour. Verified from physical semantics: in episode 27 the
+  right gripper dim flips `1.0 → 0.0` at step 54, exactly as the arm reaches its deepest
+  point (the grasp). On that robot's DDS tool wire the convention is the opposite again.
+  Confirm your own wire convention before driving hardware.
+* **G2's right gripper position sensor is dead** (constant 0.2173 in all 60 episodes), so
+  both gripper dims come from the *command* boolean, not a sensor.
+* **G2 `_rs10` = resampled to a uniform 10 Hz grid.** Raw recordings are badly jittered —
+  but the cause is the on-robot **disk writer**, not the cameras or the control loop
+  (control runs at a steady 29.5–29.9 Hz; 60–65% of frames never reach disk). Naive
+  contiguous re-indexing distorts episode duration by −18%…+35%; resampling is +0.06%.
+* **Do not JPEG-compress observations to save bandwidth.** Measured on the G2 checkpoint,
+  q92/q85 flips the *gripper decision* outright (|Δ| = 1.007 on a boolean dim, 3 of 6
+  trials) while joint dims move only ~2°. Mean error hides this completely.
+* **These policies are stochastic** (flow matching): identical input gives joint outputs
+  differing by ~1.2°. Repeated inference is not a determinism check.
+* Piper's `action` is the recorded teleop target and **leads the state by ~3 frames**;
+  G2's satisfies `action[t] == state[t+1]` exactly. Do not assume one convention for both.
+
+## Scope
+
+Single scene per task, 58 (G2) / 125 (Piper) demonstrations. Expect brittleness outside the
+recorded prop layout.
 
 ## Code
 
-Evaluation stack, real-robot client and the staged validation tooling:
-`examples/g2_dualarm/` in the accompanying openpi fork.
+`examples/g2_dualarm/` and `examples/piper/` in the accompanying openpi fork, including the
+real-robot clients, the staged validation tooling and the hardware-verification scripts.