Anonymous model-weight release
This archive contains 15 Stage-2 policies and 3 paired action encoder/decoder files. All model tensors (including online and EMA networks) are retained at their original precision. Optimizer, scheduler, scaler and sampler state are omitted. This is an inference-weight export, not an exact training-resume checkpoint.
Contents
iclr27_release/
βββ README.md
βββ LICENSE
βββ manifest.json
βββ SHA256SUMS
βββ validation_report.json
βββ requirements.txt
βββ main_encoder/
β βββ model.pth
β βββ config.json
βββ main_multitask/
β βββ model.pth
β βββ config.json
βββ single_task/
β βββ click_mouse/ # 30K
β βββ fold_glasses/ # 30K
β βββ hammer_nail/ # 30K
β βββ pick_bucket/ # 30K
β βββ pinch_tongs/ # 30K
β βββ water_plant/ # 30K
β βββ bimanual_assembly/ # 50K
β βββ bimanual_hanoi/ # 50K
β βββ bimanual_microwave_cook/ # 50K
β βββ bimanual_photograph/ # 50K
β βββ bimanual_unlock_ipad/ # 50K
βββ ablations/
β βββ raw_action/
β βββ action_mae/
β βββ action_ibot/
βββ assets/
β βββ codecs/ # MAE/iBOT paired codecs and configurations
β βββ normalizers/ # Action and task-specific state statistics
β βββ latent_stats/ # Correct statistics for each Stage-2 model
βββ evaluation/
β βββ protocol.json
β βββ results.json
βββ load_release.py
βββ release_support.py
βββ verify_release.py
βββ download_vision.py
βββ runtime_src/ # Minimal policy inference implementation
βββ third_party/vjepa2/ # Matching minimal upstream source and licenses
βββ external_dependencies.json
Every Stage-2 model directory contains model.pth and config.json. main_encoder/model.pth contains both the main action encoder and its paired decoder. MAE and iBOT need different paired codecs; their small dependency set is included under assets/codecs/.
Model index
The following results are reference summaries of existing seed-0, 50-episodes-per-task evaluations. They use the execution protocol in evaluation/protocol.json. They are not new benchmark reruns and should not be substituted for historical paper numbers evaluated under another execution protocol.
| Model id | Stage-2 training step | Codec | Reference successes / episodes |
|---|---|---|---|
main_multitask |
120000 | main | 357 / 550 |
single_task/click_mouse |
30000 | main | 41 / 50 |
single_task/fold_glasses |
30000 | main | 21 / 50 |
single_task/hammer_nail |
30000 | main | 29 / 50 |
single_task/pick_bucket |
30000 | main | 37 / 50 |
single_task/pinch_tongs |
30000 | main | 41 / 50 |
single_task/water_plant |
30000 | main | 48 / 50 |
single_task/bimanual_assembly |
50000 | main | 1 / 50 |
single_task/bimanual_hanoi |
50000 | main | 27 / 50 |
single_task/bimanual_microwave_cook |
50000 | main | 30 / 50 |
single_task/bimanual_photograph |
50000 | main | 39 / 50 |
single_task/bimanual_unlock_ipad |
50000 | main | 8 / 50 |
ablations/raw_action |
120000 | main | 117 / 550 |
ablations/action_mae |
120000 | action_mae | 252 / 550 |
ablations/action_ibot |
120000 | action_ibot | 240 / 550 |
The eleven single-task policies above are the archived rand-obj single-task comparison models. The main multi-task model and all three ablation models are Stage-2 120K versions.
Install and verify
Use Python 3.10 or newer with a compatible PyTorch installation. The tested package versions are listed in validation_report.json.
python -m pip install -r requirements.txt
python verify_release.py
python verify_release.py --checksums
python load_release.py --list
The checksum command reads all release files, so it can take a few minutes.
Use the main action encoder independently
import torch
from load_release import load_codec_networks
encoder, decoder = load_codec_networks("main", device="cpu")
normalized_actions = torch.zeros(1, 30, 324) # Smoke input only
valid_mask = torch.ones_like(normalized_actions, dtype=torch.bool)
with torch.no_grad():
tokens = encoder(normalized_actions, valid_mask=valid_mask)
print(tokens.shape) # [1, 30, 512]
The main encoder uses last_k=2. Its input must use the released absolute-D324 action normalizer. These outputs are unstandardized codec tokens; Stage-2 latent normalization uses the model-specific files in assets/latent_stats/. The MAE and iBOT codecs can be loaded with load_codec_networks("action_mae") and load_codec_networks("action_ibot") respectively.
Archived iBOT metadata: the experiment label is Action-iBOT, while its original paired codec declares both siglip=true and ibot=true. These declarations have been preserved verbatim rather than rewritten as an iBOT-only objective. The main and MAE codec objective metadata are also retained in manifest.json and the codec files.
RGB inference
The frozen visual backbone is V-JEPA 2.1 ViT-L/16, 384 resolution. Its matching minimal source is bundled; its third-party weights are an external prerequisite. external_dependencies.json records the exact source revision, weight URL, size, checkpoint key and SHA256. Obtain the weights from the official upstream distribution:
python download_vision.py --output ../vjepa2_1_vitl_dist_vitG_384.pt
python load_release.py --model main_multitask --device cuda --vjepa-weights ../vjepa2_1_vitl_dist_vitG_384.pt
You can also pass an already downloaded file. The downloader verifies its SHA256 and keeps it outside the release directory. An alternative matching source directory can be supplied with --vjepa-repo. See the upstream V-JEPA repository for the original model and licenses.
For programmatic RGB inference:
from load_release import load_policy
policy = load_policy(
"main_multitask",
device="cuda",
vjepa_weights="../vjepa2_1_vitl_dist_vitG_384.pt",
)
# Use infer.policy.base.PolicyObservation for observations.
# policy.predict(observation).action returns an absolute-D324 [30,324] chunk.
RGB input is uint8 [3,H,W,3] in the camera order first_person, wrist_left, wrist_right. Proprioception is absolute D324 [324], not pre-normalized. Supply causal observation history using the native PolicyObservation interface. The source policy retains the original history sampling and normalizer checks. Raw Action generates normalized D324 targets directly; latent policies decode D198 targets and restore the absolute D324 runtime packet.
Precomputed-feature inspection
No visual weights are needed to inspect a model through the precomputed-feature path:
python load_release.py --model main_multitask --features-only
For a tensor-level smoke check:
import torch
from load_release import load_policy, predict_from_features
policy = load_policy("main_multitask", features_only=True)
features = torch.zeros(1, 3, 576, 1024)
state = torch.zeros(1, 324) # Already normalized for this low-level interface
output = predict_from_features(policy, features, state, seed=0)
This low-level interface returns normalized decoder-space actions: [B,30,198] for latent policies and [B,30,324] for Raw Action. It does not replace RGB feature extraction, D324 restoration or denormalization. Use policy.predict with an RGB-loaded policy for that complete chain.
Validation and scope
- Every exported Stage-2 and codec parameter tensor was compared with its archived source and found exactly equal.
- All 15 Stage-2 policies loaded and produced finite one-step sampled outputs on CPU.
- Main multi-task, one single-task and all three ablations matched their original checkpoints bit for bit in full 10-step sampling on identical synthetic dense features and fixed noise.
- Main multi-task completed the full RGB-to-absolute-D324 inference chain using the bundled upstream source and the specified external visual weights.
- All three action encoders loaded independently and produced
[1,30,512]outputs. - Relocation was checked by moving this whole directory and loading it while its original location was absent.
These are packaging and numerical checks, not replacement success-rate benchmarks. The simulator, training datasets, full training source, optimizer state and raw training logs are outside this weight release. The included policy returns action chunks; benchmark scheduling and environment resets require the original evaluation environment. Package paths are resolved relative to this directory; the source archive's private host paths are not required.
License
The model artifacts in this release are licensed under CC BY-NC 4.0 (Attribution-NonCommercial 4.0 International). Commercial use is not licensed. Noncommercial copying, sharing and adaptations are permitted subject to the license terms, including attribution and indicating changes. See LICENSE for the scope, attribution notice and full legal code.
For attribution, use Anonymous model release (modelarchivek7m29) and link to https://huggingface.co/modelarchivek7m29/model-checkpoints. This attribution uses the anonymous release identity and does not require disclosing author identities during review.
The model-artifact license covers the supplied checkpoints, configurations,
normalizers, latent statistics and evaluation summaries; it does not relicense
source code or third-party components. Existing source-file notices remain
applicable. The bundled V-JEPA source retains its upstream license notices
under third_party/vjepa2/; external visual-backbone weights retain their own
applicable terms.