TacRich-Manip LeRobot v3 — multi-task

Multimodal real-robot trajectories for gripper-based contact-rich manipulation, published in the standard LeRobot v3 layout. Task membership is represented by each frame's task_index, which is a foreign key into meta/tasks.parquet.

Dataset summary

Property	Value
Repository	Tachintech/TacRich-Manip
Collection method	multi-method
Robot	rm75b-pika-tachin
Episodes	823
Frames	1,315,682
Duration	9.14 hours at 40 Hz
Nominal rate	40 Hz
Task labels	15
LeRobot format	v3.0

This release contains more than one collection method. Consult the task labels and docs/DATASET_SCHEMA.md; UMI and teleoperation state/action semantics differ.

Task taxonomy and collection methods

Logical task	Collection method	Episodes	Frames	Hours	Published labels	Scope
cyclically_arrange_steel_plate	teleoperation	79	201,043	1.40	5	Cyclic steel-plate and cushion arrangement; five major stages and five published task labels.
cyclically_standup_bottle	teleoperation	181	133,682	0.93	1	Repeatedly grasp and stand a bottle upright (first collection).
cyclically_standup_bottle_version2	teleoperation	250	219,107	1.52	1	Repeated bottle stand-up collection under the version-2 setup.
dining_table_arrangement	teleoperation	30	227,998	1.58	1	Long-horizon dining-table arrangement demonstrations.
grasp_objects	teleoperation	47	69,311	0.48	4	Return croissant, banana piece, yellow cake roll, and avocado to a plate, published as four object-level task labels.
insert_peg_cylinder	teleoperation	79	109,073	0.76	1	Real-machine peg/cylinder insertion demonstrations.
test	teleoperation	59	269,076	1.87	1	Unified evaluation/prototyping class containing every small source directory whose name starts with test-; all were collected by teleoperation.
set_the_steel_plate	umi	98	86,392	0.60	1	UMI-collected steel-plate placement trajectories, kept separate because their episode-local TCP state/action semantics differ from robot teleoperation.

The two collection methods are deliberately different namespaces. Every teleoperation/* action is an absolute robot command in the robot-base frame. The umi/set_the_steel_plate task uses episode-local TCP coordinates and a next-observation action target. A training pipeline must not silently treat the UMI zero-filled joint channels as measured robot joints or mix these coordinate frames without an explicit adapter.

The small test recordings are intentionally grouped under the single teleoperation/test class in meta/tasks.parquet. The following table and meta/task_sources.parquet preserve their source-level provenance without turning small evaluation recordings into separate training classes.

Test source	Scope	Episodes	Frames	Hours at 40 Hz
test-cyclically_arrange_steel_spoon	Cyclic steel-spoon arrangement	3	25,025	0.174
test-cyclically_standup_bottle	Cyclic bottle stand-up	10	71,320	0.495
test-dining-table-arrangement	Dining-table arrangement	9	69,922	0.486
test-grab_fruit	Fruit grasping	5	20,129	0.140
test-pour_water	Water pouring	3	10,330	0.072
test-set_the_tableware-version1	Tableware placement, setup v1	3	3,639	0.025
test-set_the_tableware-version2	Tableware placement, setup v2	4	7,682	0.053
test-stand_up_objects	Standing objects upright	11	47,767	0.332
test-wipe_the_blackboard	Blackboard wiping	10	8,432	0.059
test-write	Writing	1	4,830	0.034
Test total	Unified teleoperation/test class	59	269,076	1.869

The cyclic steel-plate task publishes only five major task labels: place the steel plate on the table, place the yellow cushion, lean the plate against the cushion, return the plate to the rack, and return the cushion/reset the robot. The object-grasp task similarly publishes only four object-level labels—croissant, banana piece, yellow cake roll, and avocado. Approach/grasp/transport/release substage boundaries remain source annotations and are documented provenance; they are deliberately not separate rows in meta/tasks.parquet.

Authoritative task labels stored in meta/tasks.parquet are listed below. This list is rendered directly from the Parquet metadata during publication. In particular, grasp_objects contains four object-level labels, the cyclic steel-plate task contains five major-stage labels, and all ten small test sources share one teleoperation/test label; no approach/grasp/release substage is published as a separate task.

• umi/set_the_steel_plate
• teleoperation/grasp_objects:return_yellow_cake_roll_to_plate
• teleoperation/grasp_objects:return_banana_piece_to_plate
• teleoperation/grasp_objects:return_croissant_to_plate
• teleoperation/grasp_objects:return_avocado_to_plate
• teleoperation/insert_peg_cylinder
• teleoperation/cyclically_standup_bottle
• teleoperation/cyclically_standup_bottle_version2
• teleoperation/cyclically_arrange_steel_plate:place_yellow_cushion
• teleoperation/cyclically_arrange_steel_plate:lean_steel_plate_against_cushion
• teleoperation/cyclically_arrange_steel_plate:place_steel_plate_on_table
• teleoperation/cyclically_arrange_steel_plate:return_steel_plate_to_rack
• teleoperation/cyclically_arrange_steel_plate:return_yellow_cushion_to_original_position
• teleoperation/test
• teleoperation/dining_table_arrangement

Complete feature inventory

Shapes below are the logical shapes recorded in meta/info.json. RGB video is stored as MP4 and decoded on demand; other frame fields are stored in Parquet.

Key	Logical dtype / storage	Shape	Ordered content, unit, and frame
observation.images.cam_front	video / MP4 AV1	[480,640,3]	Front RGB, HWC, uint8-equivalent, current frame
observation.images.cam_side	video / MP4 AV1	[480,640,3]	Side RGB, HWC, uint8-equivalent, current frame
observation.images.cam_fisheye	video / MP4 AV1	[480,640,3]	Gripper fisheye RGB, HWC, uint8-equivalent, current frame
observation.depth.cam_front	image / 16-bit PNG	[480,640,1]	Front depth, HW1, uint16 millimetres; stored losslessly
observation.tactile	float32	[2,32,58]	[left_finger, right_finger], then sensor row and column; calibrated response, not SI force
observation.joint_position	float32	[7]	[arm_j1,...,arm_j7], degrees; zero-filled for UMI only
observation.ee_pose	float32	[7]	[x,y,z,qx,qy,qz,qw]; metres and unit quaternion in XYZW order
observation.gripper_distance	float32 scalar	[1]	Current gripper opening, millimetres
observation.state	float32	[15]	Joint7 + flange/TCP position3 + quaternion4 + gripper1; exact order below
observation.state_gripper	float32	[10]	Gripper-tip/TCP position3 + rotation-6D6 + gripper1; exact order below
observation.timestamp	float64 scalar	[1]	Aligned source acquisition time, Unix seconds
observation.source_timestamp_tactile	float64 scalar	[1]	Original tactile sample time, Unix seconds
observation.source_timestamp_proprio	float64 scalar	[1]	Original robot-state sample time, Unix seconds
observation.source_timestamp_vision	float64 scalar	[1]	Original front-camera sample time, Unix seconds
action	float32	[8]	Absolute target position3 + quaternion4 + target gripper1; exact order below
action_gripper	float32	[10]	Gripper-tip/TCP target position3 + rotation-6D6 + target gripper1
timestamp	float32 scalar	[1]	LeRobot episode-relative time, frame_index / 40, seconds
frame_index	int64 scalar	[1]	Zero-based frame index inside the episode
episode_index	int64 scalar	[1]	Zero-based episode identifier in this dataset
index	int64 scalar	[1]	Zero-based global frame index across all episodes
task_index	int64 scalar	[1]	Foreign key into meta/tasks.parquet

The four primary vectors are ordered exactly as follows:

observation.state[15] =
  [arm_j1, arm_j2, arm_j3, arm_j4, arm_j5, arm_j6, arm_j7,
   flange_x_m, flange_y_m, flange_z_m,
   flange_qx, flange_qy, flange_qz, flange_qw,
   gripper_distance_mm]

action[8] =
  [target_flange_x_m, target_flange_y_m, target_flange_z_m,
   target_flange_qx, target_flange_qy, target_flange_qz, target_flange_qw,
   target_gripper_distance_mm]

observation.state_gripper[10] =
  [tip_x_m, tip_y_m, tip_z_m,
   R00, R10, R20, R01, R11, R21,
   gripper_distance_mm]

action_gripper[10] =
  [target_tip_x_m, target_tip_y_m, target_tip_z_m,
   target_R00, target_R10, target_R20,
   target_R01, target_R11, target_R21,
   target_gripper_distance_mm]

The rotation-6D representation is the first two columns of a 3×3 rotation matrix, flattened as [R[:,0], R[:,1]], not the first two rows.

For field-level storage, runtime decoding, timestamp fallback, and metadata definitions, see the complete schema.

Flange and gripper-tip coordinate frames

Teleoperation observation.state/action use flange poses in the robot-base frame. The corresponding *_gripper keys use the gripper-tip pose in the same robot-base frame. The published fixed transform is

T_base_gripper = T_base_flange @ T_flange_gripper

T_flange_gripper =
[[ 0.7660444431, -0.6427876097, 0, 0   ],
 [ 0.6427876097,  0.7660444431, 0, 0   ],
 [ 0,             0,            1, 0.2 ],
 [ 0,             0,            0, 1   ]]

Thus p_base_gripper = p_base_flange + R_base_flange @ [0,0,0.2] metres and R_base_gripper = R_base_flange @ Rz(+40°). For the reverse direction,

T_gripper_flange = inverse(T_flange_gripper) =
[[ 0.7660444431,  0.6427876097, 0,  0   ],
 [-0.6427876097,  0.7660444431, 0,  0   ],
 [ 0,             0,            1, -0.2 ],
 [ 0,             0,            0,  1   ]]

Translation is expressed in the flange frame; yaw is a right-handed local rotation about flange +Z. Gripper opening is copied without modification.

UMI is a separate channel: every TCP pose is expressed in the current episode's first-valid-TCP frame, T_local_i = inverse(T_0) @ T_raw_i, and its action is the next observed local TCP pose. Do not mix the two channels without respecting this frame convention.

Loading and visualization

Install a LeRobot version that supports dataset format v3 and the plotting dependencies:

python -m pip install "lerobot>=0.5" matplotlib numpy

Inspect all keys and their runtime shapes:

python examples/load_lerobot_dataset.py --repo-id Tachintech/TacRich-Manip --episode-index 0

Render front/side/fisheye RGB, lossless uint16 depth, and both tactile maps:

python examples/visualize_episode.py \
  --repo-id Tachintech/TacRich-Manip \
  --episode-index 0 \
  --frame-index 0 \
  --output episode0_frame0.png

LeRobot loaders normally expose RGB as CHW float tensors. Some torchvision versions expose 16-bit PNG depth as a signed int16 tensor containing the same bits; the provided visualizer safely reinterprets those bits as uint16 before plotting. Use the Parquet/Arrow value when exact float64 source timestamps are required, because a generic PyTorch scalar conversion can down-cast them.

File layout and metadata

README.md, LICENSE, CITATION.cff, AUTHORS.md
docs/DATASET_SCHEMA.md
examples/load_lerobot_dataset.py
examples/visualize_episode.py
meta/info.json
meta/stats.json
meta/tasks.parquet
meta/task_sources.parquet
meta/episodes/chunk-*/file-*.parquet
data/chunk-*/file-*.parquet
videos/<camera-key>/chunk-*/file-*.mp4

meta/info.json is the canonical feature/path declaration, meta/stats.json contains global statistics, meta/tasks.parquet maps task text to IDs, and meta/task_sources.parquet preserves physical source-directory provenance (including the ten inputs grouped into teleoperation/test). meta/episodes/** maps every episode to frame and video ranges.

Depth-statistics note: In this release, LeRobot's generic image-statistics path recorded depth as three-channel normalized [0,1] image statistics. Those meta/stats.json depth values are not metric millimetre statistics and must not normalize uint16 depth. The stored PNG values and the provided visualizer remain exact.

Quality, provenance, and limitations

• Conversion checks required fields, shapes, finite pose values, unit quaternions, task/episode counts, and every metadata-referenced shard.
• Teleoperation actions come only from the migrated absolute arm_target_* columns. Raw action_delta_* is provenance and is never consumed by this converter. An action is a command at time t; servo latency means it is not expected to equal the next measured state exactly.
• RGB video is lossy AV1; depth and low-dimensional fields are lossless apart from the documented float32 casts.
• Sensor streams are asynchronous; use the source timestamps to measure age or alignment instead of assuming simultaneous exposure.
• Tactile values are calibrated sensor responses, not force in newtons unless a separate force calibration is applied.
• Real-robot trajectories may contain occlusion, lighting changes, contact transients, operator variation, and task failures. Review episodes before safety-critical use.

Intended use and safety

Intended uses include robot imitation learning, multimodal/tactile representation learning, contact-rich manipulation, synchronization research, and reproducible format conversion. The dataset does not constitute a safety controller or deployment guarantee. Validate workspace limits, action scaling, coordinate frames, and emergency-stop behavior on the target robot before any real-world execution.

License, attribution, and citation

This LeRobot dataset is distributed under the Apache License 2.0. It is jointly developed by Tachin Technology, Qingzhu Robotics, and the TacRich-Manip Dataset Team; Tachin Technology is a co-development partner and hardware provider. Contributor and institutional attribution is in AUTHORS.md. Cite the dataset and record the exact Hugging Face commit revision used for experiments; machine-readable citation metadata is in CITATION.cff.

@dataset{tacrich_manip_multi-task_2026,
  author  = {{Tachin Technology} and {Qingzhu Robotics} and {TacRich-Manip Dataset Team}},
  title   = {{TacRich-Manip LeRobot v3: multiple tasks}},
  year    = {2026},
  version = {0.2.0},
  url     = {https://huggingface.co/datasets/Tachintech/TacRich-Manip},
  note    = {Dataset version 0.2.0, accessed via Hugging Face. Please report the immutable commit revision used for experiments.}
}

Format references

• LeRobot Dataset v3 specification
• Hugging Face dataset card guidance
• LeRobot ALOHA insertion dataset