Common setup

Getting started

Prepare a clean KinRT environment and verify every external input before launching a long training run. This page stops at a one-step software smoke test; benchmark-specific commands follow on the RoboTwin and DIYRobot pages.

Audience: first-time userPlatform: Linux GPU hostRuntime: Python 3.11+, CUDA 12, uv

Check the prerequisites

The validated release path uses Ubuntu, an NVIDIA CUDA stack, and the pinned Python workspace. Verify the supported combinations below before installing the command-line dependencies.

System / GPU	KinRT training	RoboTwin GPU simulation	DIYRobot deployment
Ubuntu 22.04 / NVIDIA	Supported path	Supported path	Supported path
Other Linux / NVIDIA	Compatibility-dependent	Follow RoboTwin support	Hardware-dependent
Windows / NVIDIA	Not documented	Not documented	Not supported
WSL2 / NVIDIA	Not validated	Not validated	Do not use
macOS / Apple silicon	Not supported	Not supported	Not supported

Also install FFmpeg and reserve storage for datasets, base parameters, normalization assets, router labels, checkpoints, and evaluation videos. FULL requires substantially more trainable GPU memory than LoRA.

python3 --version
nvidia-smi
git lfs version
ffmpeg -version
uv --version

Expected gate

Python is at least 3.11, the GPU is visible, and all four command-line tools return without error.

Understand what is included

The release contains one KinRT/OpenPI policy workspace. FULL and LoRA are configuration choices in the same registry; the RoboTwin environment and all large artifacts remain external.

Path	Purpose	Use directly?
`policy/pi05`	KinRT training, serving, and all retained OpenPI configs	Yes
`script`	RoboTwin evaluation overlay	Copy into a compatible simulator checkout
`configs/PAPER_MODELS.json`	Paper model evidence and checkpoint mapping	Reference
`manifests/`	Unified source inventory and provenance	Validation

Not a data release

No private dataset, router-label array, base weight, trained checkpoint, simulator asset, or calibration file is embedded in this package.

Choose FULL or LoRA

Both variants implement KinRT. Choose by optimization budget, not by routing behavior.

Property	FULL	LoRA
RoboTwin config	`kinrt_full`	`kinrt_lora`
PaliGemma	Dense `gemma_2b`	`gemma_2b_lora`, rank 32
Action expert	Dense `gemma_300m`	`gemma_300m_lora`, rank 64
Base parameters	Trainable	Frozen by filter
Router and routed experts	Trainable	Trainable
Routing objective	Identical KinRT setting	Identical KinRT setting

For a first installation test, use kinrt_lora. For the paper's FULL row, use kinrt_full from the same config registry.

Install the pinned environment

cd /path/to/KinRT/policy/pi05
uv sync --frozen
uv run python -c "import jax; print(jax.devices())"
uv run python -c "from openpi.training import config; print(config.get_config('kinrt_lora').name)"

The lockfile pins JAX 0.5.0, Flax 0.10.2, Transformers 4.48.1, and a recorded LeRobot revision. Do not update dependencies during a reproduction run unless the changed environment is reported separately.

Expected gate

JAX lists a GPU and the final command prints kinrt_lora.

Connect external artifacts

Edit only the selected block in src/openpi/training/config.py. Replace its dataset identity, router-label path, base checkpoint path, asset location, and checkpoint output location.

Config field	Must point to	Failure symptom
`repo_id`	The intended LeRobot dataset	Missing dataset or wrong task count
`router_labels_path`	Labels generated from that exact dataset revision	Index error or semantically wrong supervision
`weight_loader`	Matching PI0.5 or PI0 base `params`	Shape or restore error
`assets_dir` / `asset_id`	Norm stats for this dataset and action schema	Missing stats or unstable actions
`checkpoint_base_dir`	A writable local filesystem	Checkpoint save failure

Path existence is not identity.

A file at the expected path may still belong to another dataset or model. Record checksums and metadata with every experiment.

Pass the dataset gate

Inspect metadata before running PCA/KMeans or normalization. KinRT aligns labels by the LeRobot global index field.

python - <<'PY'
import json
from pathlib import Path

root = Path("/data/lerobot/my_dataset")
info = json.loads((root / "meta" / "info.json").read_text())
required = {"observation.state", "action"}
features = set(info["features"])
print("episodes", info["total_episodes"])
print("frames", info["total_frames"])
print("missing", sorted(required - features))
print("data_path", info["data_path"])
PY

For DIYRobot, verify 14-D state/action vectors in degrees and three image streams. For RoboTwin, verify that the selected conversion produces the exact keys used by the config.

Run a bounded training smoke test

Complete the KinRT offline-label procedure first, then compute norm stats. Before a full run, override the selected config in a disposable copy to one step and one checkpoint. Do not publish smoke settings as benchmark settings.

uv run python scripts/compute_norm_stats.py --config-name kinrt_lora
uv run python scripts/train.py kinrt_lora --exp-name kinrt_smoke

Expected gate

Data loading succeeds, total loss and router loss are finite, all four label classes are observable, and a checkpoint can be written and restored.