Datasets:

harpreetsahota
/

flexa-pour1-v3

import fiftyone as fo
from fiftyone.utils.huggingface import load_from_hub

# Load the dataset
# Note: other available arguments include 'max_samples', etc
dataset = load_from_hub("Voxel51/flexa-pour1-v3")

# Launch the App
session = fo.launch_app(dataset)

Dataset Card for flexa-pour1 (FiftyOne, v3.0 conversion)

The complete flexa-pour1 dataset (a single pouring-task episode) — a Unitree H1 humanoid + Shadow Hand replay of a pouring task, retargeted from an iPhone egocentric video capture. The original release, FlexaTechnologies/flexa-pour1, is published in LeRobotDataset v2.1 format; this repo is the same single episode, converted to LeRobotDataset v3.0 (using LeRobot's official convert_dataset_v21_to_v30 converter) and loaded into FiftyOne for exploration. Unlike the other FiftyOne LeRobot subsets in this series, this is not a subset of a larger dataset — the source only contains 1 episode in total, so this repo is the whole thing.

Dataset Details

Dataset Sources

Repository: FlexaTechnologies/flexa-pour1
Pipeline code: flexa-tech/flexa-pipeline

Uses

Direct Use

Inspecting a single retargeted humanoid+dexterous-hand manipulation episode in the FiftyOne App — a worked example of the "video-to-humanoid-replay" pipeline (iPhone capture → hand pose estimation → IK retargeting → MuJoCo simulation replay → LeRobot export), useful for validating LeRobot v3 import/tooling against an unusual, minimal-scale, dual-video (simulated + egocentric) dataset.

Out-of-Scope Use

This is a single demonstration of a single task ("pouring") from a single capture — it has no statistical value as a training or evaluation set on its own, and should not be used to draw any conclusion about H1+Shadow Hand pouring performance in general. It is best treated as a pipeline/format example, not a training corpus.

Dataset Structure

This is a multimodal FiftyOne dataset (dataset.media_type == "multimodal") with 1 sample (the dataset's only episode). The sample's media (2 video streams) is not copied into a per-sample file; instead it is resolved through a media_reference that points into the exported LeRobotDataset v3.0 source (data/, videos/, meta/ in this repo) at import time — this is how FiftyOne represents LeRobot episodes natively.

Fields

Field	FiftyOne type	Description
`id`	`ObjectIdField`	FiftyOne sample id
`media_reference`	`MediaReferenceField`	Pointer into the LeRobot source's `data/`, `videos/*`, and `meta/` files for this episode (chunk/file indexes, frame range, per-video timestamp ranges) — resolved on demand, not duplicated per sample
`tags`	`ListField(StringField)`	FiftyOne sample tags (empty by default)
`metadata`	`Metadata` (`size_bytes`, `mime_type`)	Standard FiftyOne sample metadata
`created_at` / `last_modified_at`	`DateTimeField`	FiftyOne bookkeeping timestamps
`episode_index`	`IntField`	`0` (the only episode)
`task`	`StringField`	`"Pour from bottle into cup"` (verbatim from source `meta/tasks.jsonl`)
`tasks`	`ListField(StringField)`	`["Pour from bottle into cup"]`
`length`	`IntField`	`294` frames (verbatim from source)
`duration`	`FloatField`	`9.8` seconds (`length / fps`)
`robot_type`	`StringField`	`h1_shadow_hand` (verbatim from source `meta/info.json`)
`fps`	`FloatField`	`30.0` (verbatim from source)

The per-frame numeric features and the 2 per-frame video streams are not flattened into sample fields — they remain in the LeRobot data/*.parquet and videos/*/*.mp4 files referenced by media_reference, and are surfaced by the FiftyOne App's State & Action and Streams viewer tabs rather than as queryable sample-level fields. Per source meta/info.json, these per-frame features are:

feature	shape	description
`observation.state`	`(48,)`	10 arm joint positions (5 per arm: shoulder pitch/roll/yaw, elbow, wrist yaw) + 38 Shadow Hand finger joint positions (19 per hand: WRJ1-2, and FFJ/MFJ/RFJ/LFJ with 3 joints each, THJ with 5 joints) — see full per-dimension names below
`action`	`(48,)`	commanded target for the same 48 DOF, same layout as `observation.state`
`observation.images.ego`	`(480, 640, 3)` video, H.264 (High profile, `yuv420p`)	egocentric view (from the original iPhone capture perspective)
`observation.images.sim`	`(480, 640, 3)` video, H.264 (High profile, `yuv420p`)	MuJoCo simulation replay view

The v2.1→v3.0 conversion additionally expanded the packed observation.state/action arrays into 48 individually-named scalar columns each (e.g. observation.state.left_shoulder_pitch, action.rh_THJ1) in the underlying data parquet, alongside the packed arrays — both representations are present in the source files, though FiftyOne surfaces neither as separate sample-level fields (see table above; both are accessible via media_reference/the Streams tab).

Joint order (both observation.state and action): arm — left_shoulder_pitch, left_shoulder_roll, left_shoulder_yaw, left_elbow, left_wrist_yaw, right_shoulder_pitch, right_shoulder_roll, right_shoulder_yaw, right_elbow, right_wrist_yaw; then Shadow Hand finger curl DOFs (WRJ1, WRJ2, FFJ3, FFJ2, FFJ1, MFJ3, MFJ2, MFJ1, RFJ3, RFJ2, RFJ1, LFJ3, LFJ2, LFJ1, THJ5, THJ4, THJ3, THJ2, THJ1) for the left hand (lh_*), then the same 19 for the right hand (rh_*).

Label types and why

There are no traditional detection/classification/segmentation labels. task is a plain StringField (not fo.Classification) because it is a single free-form natural-language instruction, and there is exactly one episode/one task in this dataset — nothing to classify against.

`dataset.info` contents

{
    "lerobot": {
        "format": "LeRobotDataset",
        "format_major": 3,
        "episode_count": 1,
        "imported_episode_count": 1,
        "skipped_episodes": [],
    }
}

Parsing decisions

Converted from LeRobotDataset v2.1, not a native v3.0 source. The upstream FlexaTechnologies/flexa-pour1 repo declares codebase_version: "v2.1" with the legacy per-episode layout (data/chunk-000/episode_000000.parquet, videos/chunk-000/{video_key}/episode_000000.mp4, meta/tasks.jsonl). FiftyOne's fo.types.LeRobotDataset importer requires v3.0, so this repo was produced by running LeRobot's official lerobot.scripts.convert_dataset_v21_to_v30 converter against a local copy of the source.
The source's v2.1 layout was itself non-conformant with LeRobot's own legacy schema, and had to be repaired before the official converter would accept it:
- meta/info.json was missing the total_chunks, total_videos, and total_tasks keys that the converter unconditionally reads/deletes. These were added (total_chunks: 1, total_videos: 2, total_tasks: 1 — all trivially computable for a 1-episode, 2-camera, 1-task dataset, and dropped again by the conversion itself).
- The source ships per-episode metadata as meta/episodes/0000.parquet (episode_index, tasks, length) rather than the standard v2.1 meta/episodes.jsonl. A conformant meta/episodes.jsonl was synthesized directly from this parquet's single row.
- The source has no meta/episodes_stats.jsonl at all (only a dataset-level meta/stats.json with observation.state/action mean/std/min/max, no count and no per-episode breakdown). Since there is exactly one episode, per-episode stats are identical to the dataset-level stats by construction; meta/episodes_stats.jsonl was synthesized from meta/stats.json with count: [294] added per feature.
- No stats were available (in the source or synthesized) for the video, timestamp, or index features — only observation.state and action carry stats in this dataset, consistent with common LeRobot practice of not computing image/video statistics.
- None of these fixes altered any actual episode data, video frames, or task content — they only supplied metadata bookkeeping (totals, per-episode stats keying) that the source's minimal/custom export script had omitted, so the official converter could run.
- The source's v2.1 data parquet also carried 96 extra per-joint scalar columns (observation.state.left_shoulder_pitch, action.rh_THJ1, etc.) alongside the packed observation.state/action array columns — these extra columns are not declared in meta/info.json's features, and while FiftyOne's own importer tolerates them, they made the exported v3.0 data unreadable by the official lerobot v3 reader (datasets.Dataset.from_parquet(..., features=...) rejects parquet files with undeclared columns). They were dropped from the local data parquet, keeping only the columns declared in meta/info.json (timestamp, frame_index, episode_index, index, task_index, observation.state, action) — no values in the retained columns were changed.
- meta/info.json's features dict was also missing declarations for the 5 standard per-frame columns (timestamp, frame_index, episode_index, index, task_index) that every other LeRobot v3 dataset in this series declares explicitly — the source's minimal v2.1 info.json only declared observation.state, action, and the two video features. These 5 standard declarations were added (matching the dtypes/shapes used elsewhere in LeRobot v3: timestamp float32, the other four int64, all shape [1]), since the official lerobot v3 reader builds its expected Arrow schema strictly from features and otherwise rejects the exported parquet as having unrecognized columns.
- Separately, the timestamp, observation.state, and action columns produced by the official v2.1→v3 converter were stored as float64 even though info.json declares dtype: "float32" for all three (the original v2.1 source data was itself float64-typed; the converter does not enforce/cast to the declared feature dtype). These three columns were cast to float32 (and the state/action lists to their documented fixed length of 48) to match the declared schema — this is a representable, lossless-for-practical-purposes precision reduction (float64 → float32), not a change in value semantics.
Video re-encoded from MPEG-4 Part 2 (mp4v) to H.264 for browser playback. The source's v2.1→v3.0 conversion carried over the original mp4v (MPEG-4 Part 2, Simple Profile) encoding, which Chrome/Electron's <video> and WebCodecs decoders do not support — videos failed to preview in the FiftyOne App ("Video decoder failed"), though the data itself was not corrupt (ffmpeg/PyAV decoded it fine). Both streams were transcoded in place with ffmpeg -c:v libx264 -profile:v high -pix_fmt yuv420p -bf 0 -g 2 -crf 18 -movflags +faststart, matching LeRobot's own encoder conventions (no B-frames, keyframe every 2 frames, so decode order equals presentation order and every frame is cheaply seekable; moov atom before mdat so the App can parse the header without reading the whole file). Frame count and duration are unchanged (verified: 294 frames / 9.8s on both streams) and the encode is visually lossless at crf 18. An earlier transcode with libx264's default B-frame/long-GOP settings played but flickered in the FiftyOne App; this recipe fixed it. meta/info.json's video.codec was updated from mp4v to h264 to match. Originals are kept locally in _mp4v_backup/ (not part of the published export).
Single episode, no held-out or unlabeled split. splits: {"train": "0:294"} (a frame-index range, matching the dataset's one 294-frame episode).

Dataset Creation

Curation Rationale

This dataset demonstrates a specific data-generation pipeline: converting a casually captured, egocentric smartphone video of a human performing a task into a simulated humanoid-robot replay usable for imitation learning, without teleoperation or motion capture hardware. It exists to validate/showcase that pipeline on one pouring demonstration, not to provide a training corpus at any scale.

Source Data

Data Collection and Processing

Per the source README, the full pipeline is: iPhone 15 Pro rear camera (Record3D .r3d capture, including LiDAR depth) → HaMeR 2D hand detection + MANO hand-pose estimation (run on Modal) → Record3D LiDAR depth fusion to lift 2D hand keypoints into 3D wrist trajectories → a custom Jacobian inverse-kinematics solver (with elbow-out nullspace bias) mapping wrist trajectories to Unitree H1 arm joint targets → DexMV finger retargeting mapping the estimated hand pose to Shadow Hand finger joint targets → replay of the resulting joint trajectory in MuJoCo to render the observation.images.sim view → export to LeRobot format, retaining the original iPhone egocentric video as observation.images.ego.

Who are the source data producers?

Flexa Technologies, via the flexa-tech/flexa-pipeline pipeline; the underlying human demonstration was captured on an iPhone by a Flexa Technologies operator/contributor (not otherwise identified in the source materials).

Annotations

Annotation process

The single task label ("Pour from bottle into cup") is a fixed, manually-assigned description of the captured demonstration; no further annotation (segmentation, keypoints, etc.) is present in the source or added here.

Personal and Sensitive Information

The observation.images.ego stream is real (not simulated) egocentric video captured by a human operator holding/wearing the capture device; depending on the capture environment it could incidentally include identifiable surroundings, though no faces or other people are expected given the egocentric, hands-focused framing of a tabletop pouring task.

Citation

APA:

Flexa Technologies. (2026). flexa-pour1 [Data set]. Hugging Face. https://huggingface.co/datasets/FlexaTechnologies/flexa-pour1

More Information

This is the complete FlexaTechnologies/flexa-pour1 dataset (1 episode), converted from the source's LeRobotDataset v2.1 format to v3.0 so it can be loaded via fo.types.LeRobotDataset. See flexa-tech/flexa-pipeline for the full capture-to-replay pipeline code.