HAMPER — G1 basket pickup policy

Pretrained weights for HAMPER: a Unitree G1 humanoid that walks up to a basket on the floor, threads its forearm through the handle, lifts it, and carries it away. Trained with PPO (rsl_rl) in Isaac Lab through a staged curriculum, on a single RTX A6000.

These weights only work with the HAMPER repository at a matching commit. The checkpoint is half of the controller: the other half is the state machine in basket_pickup/commander.py, which sequences approach → squat → thread → lift → carry and presents the policy with the same commands and stage flag it trained under. The observation and action layouts are frozen in interface.py; running the network under any other layout produces garbage rather than an error. Pinned stack: Isaac Sim 5.1.0, Isaac Lab v2.3.2, rsl_rl 3.1.2, torch 2.7.0+cu128 (see configs/versions.lock in the repository). Scope: simulated whole-body loco-manipulation with a hybrid PPO + state-machine controller; basket pose is read from the simulator with synthetic noise — vision-based perception and sim-to-real transfer are out of scope. SHA-256 hashes of these files are in the repository's results/manifest.json.

Files

File	What it is	Cumulative PPO updates	Checkpoint index
chain.pt	The final policy — the full task	9,500 (2,000 on the chain stage)	model_9495
stage_thread.pt	Parent of chain.pt: walk + carry + lift + thread	7,500	model_7496
stage_lift.pt	Parent of stage_thread.pt: walk + carry + lift	5,500	model_5497
stage_carry.pt	Parent of stage_lift.pt: walk + carry	3,500	model_3498
generalist.pt	Root of the chain: squat-capable walking with a commanded hand target; no basket	2,000	model_1999
banks/standing_states.pt (+ .json)	5,000 harvested standing states used to initialize episodes	—	—
banks/squat_states.pt (+ .json)	5,000 harvested squatting states used to initialize the lift and thread stages	—	—
hero_video.mp4	60 s demo: full chain, threading close-up, robustness, failure case, ablation	—	—

Checkpoint indices are rsl_rl iteration indices, which undercount cumulative updates by one per resume; the update column is the number of PPO updates. The staged pipeline additionally used a separate 1,500-update reach policy plus state-bank harvesting to produce the banks above.

Each checkpoint is an rsl_rl OnPolicyRunner save (actor, critic, optimizer state). The banks are required for evaluating or fine-tuning any stage other than plain walking: episodes of the carry, lift, thread and chain stages start from bank states.

Results (chain.pt with the repository's commander)

All numbers use this one checkpoint (training seed 42); the baseline uses three evaluation seeds of 500 episodes each; the 15 s, held-out and training-conditions checks use one seed each. Strict full-chain success requires reaching the carry phase, keeping the elevated basket to episode timeout, and moving it at least 1.0 m after the carry begins.

• Strict, 10 s episodes (the training horizon): 1,216 of 1,500 — 81.1 % (95 % Wilson CI 79.0–83.0 %; per-seed 80.8 / 81.0 / 81.4 %). The shortfall against the softer metric is the episode clock: carry distances have a median of 1.4 m (10th percentile 0.87 m), and with 15 s episodes on the same spawn distribution (one evaluation seed, 500 episodes) strict success is 99.4 % (median carry distance 3.2 m).
• Reached the carry phase and retained the elevated basket through timeout (no distance requirement): 1,476 of 1,500 — 98.4 % (97.6–98.9 %; per-seed 98.4 / 97.8 / 99.0 %).

We observed zero falls, zero basket knock-away events, and three transient retention-latch loss events (0.002 per episode); an episode can re-establish retention after a latch loss.

Per-stage evaluation — reached-phase/retention metrics, no carry-distance requirement (strict full-chain numbers are above):

	Walk	Carry	Lift	Thread	Full chain (reached-carry)
Success	98.9 %	95.9 %	98.9 %	82.2 %	98.4 %

Robustness (one policy, no retraining): mean success per tested handle opening stayed at or above 95.5 % across 15–35 cm (lowest single evaluation seed: 94.6 %, at 35 cm; trained on 25 cm) and was flat across basket masses of 0.3–1.5 kg (trained on 0.4–1.0 kg). Among the variables tested, basket-pose noise had the largest effect. The noise is bounded uniform per Cartesian coordinate with the stated half-width (the policy and the state machine share the observation model and bounds but draw independent samples): above 97 % up to a 5 cm half-width, 23.5 % at 10 cm (time-outs, not falls; sweep numbers use the reached-carry metric). On a spawn distribution the state machine was never tuned on (basket 1–3 m away, ±90°, one evaluation seed, 15 s episodes) the chain reaches 98.2 % strict success over 500 episodes.

Things the numbers do not show: the 3 seeds are evaluation seeds of one trained policy (retraining variance was not measured); the evaluation environment turns off Isaac Lab's proprioceptive noise and pushes (under full training conditions the chain scores 87.6 % strict / 100 % reached-carry over 500 episodes, one evaluation seed); the state machine's constants were tuned on the training spawn distribution. The repository README has the full discussion, sweep plots, and ablations.

How to run

Set up the repository as described in its README (Isaac Sim, Isaac Lab v2.3.2, uv pip install -e source/basket_pickup), then from the repository root:

hf download WillXH/HAMPER --local-dir weights
cp weights/banks/* banks/                     # the stage evaluations need the state banks

# full task, 200 episodes, records a video next to the checkpoint
python scripts/eval_stage.py --checkpoint weights/chain.pt --stage D_CHAIN
# individual stages
python scripts/eval_stage.py --checkpoint weights/chain.pt --stage C_THREAD    # or B_LIFT, A_CARRY, LOCO

To fine-tune from a stage checkpoint, rsl_rl expects it inside a run directory under logs/rsl_rl/basket_pickup/:

mkdir -p logs/rsl_rl/basket_pickup/hf_stage_thread
cp weights/stage_thread.pt logs/rsl_rl/basket_pickup/hf_stage_thread/model_7496.pt
python scripts/rsl_rl/train.py --task Basket-Pickup-v0 --headless --num_envs 4096 \
  --resume --load_run hf_stage_thread --checkpoint model_7496.pt --max_iterations 2000 --run_name my_chain

License

Weights: MIT. The G1 robot description and Isaac Lab are BSD-3-Clause (NVIDIA / Unitree); rsl_rl is BSD-3-Clause.