Datasets:

DWLKB
/

aic-cheatcode-v3

LeRobot-compatible dataset of expert-teacher cable-insertion trajectories, collected inside the AI for Industry Challenge (AIC) Gazebo simulation with ground_truth:=true so every port/plug/TCP pose is logged exactly. The teacher is the reference CheatCode policy (aic_example_policies.ros.CheatCode).

What is in it

N episodes — one per trial. Each episode is a full approach + insertion attempt (truncated just after the closest approach, so the steady-state post-insertion hold is mostly absent).
Two trial types, interleaved by episode index:
- sfp — SFP module → SFP port on a NIC card
- sc — SC plug → SC optical port
Three wrist-mounted cameras at 1152×1024 RGB, 20 Hz, H.264 CRF 23 (mp4).
Full per-frame ground-truth labels for the target port's 6D pose and 9 cuboid keypoints, plus the plug, the TCP and the task board.

Successes and partial / failed trials are saved the same way; the distinction lives in meta/episodes.jsonl (success_tier3).

Layout

<dataset_root>/
├── README.md                                          # this file
├── meta/
│   ├── info.json                                      # dataset schema + fps
│   ├── episodes.jsonl                                 # one row per episode
│   ├── tasks.jsonl                                    # task type dictionary
│   └── validator_report.json                          # (optional) sanity audit
├── data/chunk-000/
│   └── episode_XXXXXX.parquet                         # 20 Hz time series
├── videos/chunk-000/
│   ├── observation.images.left/episode_XXXXXX.mp4
│   ├── observation.images.center/episode_XXXXXX.mp4
│   └── observation.images.right/episode_XXXXXX.mp4
└── assets_snapshot/
    ├── camera_info.json                               # K, D, size, cam←tcp static
    ├── keypoints_sfp.json                             # port frame 9-keypoint spec
    └── keypoints_sc.json

Parquet schema (per frame)

Indexing

column	type	meaning
`timestamp`	float	seconds since the first frame of this episode (wall clock)
`frame_index`	int	0-based within the episode
`episode_index`	int	0-based, unique within the dataset
`task_index`	int	0 = SFP trial, 1 = SC trial

Observations

column	shape	units	notes
`observation.images.{left, center, right}`	`(H, W, 3)` uint8 RGB	pixels	stored in mp4; read with imageio / cv2 / lerobot loader
`observation.state.joints`	`(7,)`	rad (joint 1-6) + m (gripper width, index 7)	current joint positions
`observation.state.gripper`	`(1,)` or None	m	Gazebo's `/gripper_state`; may be null when the stock eval container doesn't publish it
`observation.wrench`	`(6,)`	N, N·m	`[fx, fy, fz, tx, ty, tz]` at the F/T sensor
`observation.tcp_pose_actual`	`(7,)`	m + unit quat (xyzw)	current gripper TCP in base_link: `[x, y, z, qx, qy, qz, qw]`
`observation.tcp_pose_target`	`(7,)`	m + quat	controller reference TCP
`observation.tcp_velocity`	`(6,)`	m/s + rad/s	`[vx, vy, vz, ωx, ωy, ωz]`

Actions (teacher commands)

column	shape	notes
`action.pose_command`	`(7,)` or None	last `MotionUpdate.pose` published by CheatCode (xyz + xyzw quat in base_link)
`action.joint_command`	`(7,)` or None	Joint-mode command; always `None` with CheatCode (Cartesian-only)

Labels (ground truth, always populated)

All 6D poses are [x, y, z, qx, qy, qz, qw] in the robot's base_link frame.

column	shape	meaning
`labels.port_pose_base`	`(7,)`	target port's link pose
`labels.plug_pose_base`	`(7,)`	plug tip link pose
`labels.gripper_tcp_pose_base`	`(7,)`	`gripper/tcp`
`labels.task_board_pose_base`	`(7,)`	task board base link
`labels.port_keypoints_3d_base`	`(9, 3)`	9 keypoints defining the port cavity as a 3D cuboid, transformed into base_link
`labels.port_keypoints_2d`	`dict[cam→(9, 2)]`	per-camera pixel projection of the 9 keypoints (already distortion-rectified)
`labels.port_keypoints_visible`	`dict[cam→(9,)]` uint8	1 = keypoint is in front of the camera AND inside the image bounds
`labels.port_bbox_2d`	`dict[cam→(4,)]` or None	axis-aligned 2D bbox of the visible keypoints: `[x0, y0, x1, y1]`
`labels.all_ports`	`list[dict]`	Per-port labels for every port physically present on the active module. See below.

The labels.port_* columns above only cover the target port for the trial. labels.all_ports contains labels for every port visible in the scene so perception models can learn to detect all ports + select the target using the challenge's Task.port_name (which says "insert into sfp_port_0 or sfp_port_1" for SFP trials). SFP trials: 2 entries (sfp_port_0, sfp_port_1); SC trials: 1 entry (sc_port_base).

Each element is a dict:

key	shape	notes
`port_name`	str	`sfp_port_0`, `sfp_port_1`, or `sc_port_base`
`is_target`	bool	True for the entry matching `Task.port_name`
`pose_base`	`(7,)`	6D pose in `base_link`
`keypoints_3d_base`	`(9, 3)`	9 keypoints in `base_link`
`keypoints_2d`	`dict[cam→(9, 2)]`	per-camera pixel projection
`keypoints_visible`	`dict[cam→(9,)]` uint8	per-camera visibility
`bbox_2d`	`dict[cam→(4,)]` or None	per-camera axis-aligned bbox

Keypoint order is identical to the names list in assets_snapshot/keypoints_{sfp,sc}.json: [center, mouth_tl, mouth_tr, mouth_bl, mouth_br, base_tl, base_tr, base_bl, base_br]. The 4 mouth_* points lie on the port entrance plane; the 4 base_* points are the same rectangle translated into the port along the local +Z axis.

episodes.jsonl (per episode)

{
  "episode_index": 0,
  "task_index": 0,
  "length": 312,
  "trial_type": "sfp",
  "trial_id": "trial_1",
  "seed": 100000,
  "randomization": {
    "board_pose": {"x": ..., "y": ..., "yaw": ...},
    "rails": { "nic_rail_0": {"entity_present": true, "entity_pose": {...}}, ... },
    "grasp": { "gripper_offset": {...}, "roll": ..., "pitch": ..., "yaw": ... },
    "cable_type": "sfp_sc_cable"
  },
  "target": {
    "cable_name": "cable_0", "plug_type": "sfp", "plug_name": "sfp_tip",
    "port_type": "sfp", "port_name": "sfp_port_0",
    "target_module_name": "nic_card_mount_3", "time_limit": 180
  },
  "scoring": { /* full aic_engine scoring.yaml subsection */ },
  "success_tier3": 75.0
}

success_tier3 — scalar: 75 = full insertion, 38–50 = partial insertion, 0–25 = proximity only, negative = wrong port (rare).
randomization — full sampled scene description (reproduces the scene given the seed).

Coordinate frames

base_link is the UR5e base; all *_pose_base labels are expressed in it.
gripper/tcp is the tool frame at the fingertip midpoint.
Camera {left, center, right} optical frames are rigidly mounted on the wrist. Their extrinsic wrt gripper/tcp is constant and stored in assets_snapshot/camera_info.json as cam_T_tcp (4×4, camera-from-tcp). Per-frame camera-from-base is cam_T_tcp @ inv(tcp_pose_actual_matrix).
Port frame origin is inside the cavity, not at the entrance. The entrance plane is at local z = z_mouth (see assets_snapshot/keypoints_{sfp,sc}.json), and CheatCode uses z_offset relative to this convention.

Minimal loading recipe

import json, pathlib, pandas as pd, imageio, numpy as np

DS = pathlib.Path("<dataset_root>")

# --- episodes metadata ---
eps = [json.loads(l) for l in open(DS/"meta"/"episodes.jsonl")]
print(len(eps), "episodes")

# --- one episode: parquet + mp4 aligned by frame_index ---
ep = eps[0]
chunk = ep["episode_index"] // 1000
df = pd.read_parquet(DS/f"data/chunk-{chunk:03d}/episode_{ep['episode_index']:06d}.parquet")
video = imageio.get_reader(
    str(DS/f"videos/chunk-{chunk:03d}/observation.images.center/"
        f"episode_{ep['episode_index']:06d}.mp4"))

for i, frame in enumerate(video):    # frame is (H, W, 3) uint8 RGB
    row = df.iloc[i]
    port_pose   = np.asarray(row["labels.port_pose_base"])       # (7,)
    kp2d_center = np.stack(row["labels.port_keypoints_2d"]["center"])  # (9, 2)
    visible     = np.asarray(row["labels.port_keypoints_visible"]["center"])  # (9,)
    # ... build sample
    if i >= 5:
        break

# --- camera intrinsics ---
cam = json.load(open(DS/"assets_snapshot/camera_info.json"))["center"]
K = np.asarray(cam["K"])                # (3, 3)
cam_T_tcp = np.asarray(cam["cam_T_tcp"])  # (4, 4) static

Quality filtering

For imitation learning on clean demonstrations:

clean = [e for e in eps if (e.get("success_tier3") or 0) >= 70]

For perception (the label is always correct even on partial trials):

usable = eps                              # keep everything

For occlusion-robust training you can drop frames where no camera sees the port:

vis = np.stack([np.asarray(row["labels.port_keypoints_visible"][c])
                for c in ("left", "center", "right")])    # (3, 9)
ok = (vis.sum(axis=1) >= 5).any()         # at least one cam has ≥5/9 visible

2D keypoints → 3D port pose (optional PnP)

import cv2
kp_local = np.asarray(
    json.load(open(DS/"assets_snapshot/keypoints_sfp.json"))["points_local"])  # (9, 3)
kp2d = np.stack(row["labels.port_keypoints_2d"]["center"])                     # (9, 2)
vis  = np.asarray(row["labels.port_keypoints_visible"]["center"]).astype(bool)
ok, rvec, tvec = cv2.solvePnP(
    kp_local[vis], kp2d[vis], K, distCoeffs=np.zeros(5),
    flags=cv2.SOLVEPNP_ITERATIVE)

Use cases

Port 6D pose regression — input: one or three camera images, target: labels.port_pose_base or labels.port_keypoints_2d. The 9-keypoint supervision is compatible with heatmap-style keypoint models and direct regression.
Imitation learning — use observation.* as input history and action.pose_command as the target; use observation.tcp_pose_actual if you prefer delta actions. Task-condition with task_index.
Hybrid policy — run a learned port-pose estimator on the images, then reuse CheatCode's controller logic with the estimate instead of the GT TF.

Randomization space (per trial)

Sampled independently from seed = start_seed + episode_index.

Board pose — xy jitter ±5 cm around (0.15, −0.2), yaw ±0.5 rad around π.
NIC card (SFP trial) — exactly one card, target rail uniform on {0..4}; translation in [−0.0215, 0.0234] m and yaw in [−10°, +10°]; target port sfp_port_{0|1}.
SC port (SC trial) — exactly one port, target rail 0 or 1, translation in [−0.06, 0.055] m.
Grasp offset — Gaussian noise around the nominal grasp: σ = 2 mm (xyz) and σ = 0.04 rad (rpy), matching the qualification-spec uncertainty exactly.

Known quirks

Gripper fingers appear slightly open around the plug. The challenge config sets attach_cable_to_gripper=True, which installs a logical fixed joint between the plug and gripper/tcp rather than relying on physical grasping, so the finger width doesn't change to match the plug dimensions. This is cosmetic — simulation physics and all labels remain correct.
Frame 0 of every episode is a post-reset settled state, not the instant the trial started. The collector defers recording until /joint_states shows sample-to-sample Δposition under ~0.02 rad for 3 consecutive ticks, which skips the one-frame teleport the engine produces when returning the arm to home between trials.
Episode lengths vary (typically 200–700 frames). Truncation cuts at argmin(plug→port) + 20 frames so a short stabilisation tail is kept without the full 5 s CheatCode hold or the engine-driven reset motion.
observation.state.gripper may be null for the entire episode if the eval container doesn't publish /gripper_state. The gripper width is included in observation.state.joints (last element) regardless.
Partial insertions are kept (success_tier3 < 70); filter at train time if your objective needs only clean demonstrations.

Reproducing a scene

Every episodes.jsonl row carries a seed and a full randomization dict. Re-running the sampler with that seed reproduces the exact scene configuration (subject to the ROS 2 / Gazebo message-scheduling non-determinism noted in the collection README).