This dataset provides a high-fidelity, ego-centric capture of professional order preparation tasks within a cold-chain logistics environment. It focuses on the rapid, repetitive, and high-precision picking and packing of multi-unit yogurt packs. This resource is specifically designed to train robotic agents in bimanual coordination, spatial reachability, and contact-point optimization for fragile rigid goods.

Key Technical Features

Temporal Protocol (T1-T4): Every micro-action is frame-accurately annotated using our proprietary four-point system:

T1 (Contact): Initial physical engagement.
T2 (Lift-off): Static-to-dynamic transition.
T3 (Placement): Target container engagement.
T4 (Release): Total tactile disengagement.

Use Cases for Research

Foundation Models & World Models: Training models to understand the Newtonian physics of rigid payloads and container boundaries.
Bimanual Policy Learning: Developing algorithms for coordinated two-hand tasks, such as stabilizing a box while inserting a pack.
End-to-End Picking Pipelines: Optimizing the "approach-to-grasp" phase in unstructured industrial environments where lighting and clutter vary.

About US

We are newcomers to the field, coming from the staffing industry. This gives us direct access to 100+ professional environments (industrial kitchens, bakeries, workshops) where we capture real-world manual tasks. Our approach is iterative and driven by field testing:

Capture Stack: We test different camera positions (chest, head, multi-view, 360°) and select the most relevant setup based on the specific task to ensure hands and tools stay in frame.
Multimodal: We integrate synchronized IMU sensors and Audio to capture the motion dynamics and contact sounds missing from standard datasets.
Annotation: We provide task segmentation and can adapt our labeling depth to specific model requirements. Since we own the access to the field, we are ultra-flexible. We can easily adapt our sensors, mounting, and annotation protocols to build custom collections that fit your specific needs. We’d be happy to chat about your current research and see how we can help ground your models with real-world professional data. Contact us orgn3ai@gmail.com

Commercial Licensing and Contact

The complete dataset and our custom collection services are available for commercial licensing and large-scale R&D. Whether you need existing data or a custom setup in a specific professional environment, do not hesitate to reach out for more information.
Contact: orgn3ai@gmail.com

License

This dataset is licensed under cc-by-nc-nd-4.0.

Dataset Statistics

This section provides detailed statistics extracted from dataset_metadata.json:

Overall Statistics

Dataset Name: YOGURT-ORDER-PREPARATION-sample
Batch ID: example
Total Clips: 60
Number of Sequences: 57
Number of Streams: 1
Stream Types: ego

Duration Statistics

Total Duration: 7.97 minutes (478.49 seconds)
Average Clip Duration: 7.97 seconds (7974.83 ms)
Min Clip Duration: 5.10 seconds (5100 ms)
Max Clip Duration: 15.12 seconds (15125 ms)

Clip Configuration

Padding: 1500 ms

Statistics by Stream Type

Ego

Number of clips: 60
Total duration: 7.97 minutes (478.49 seconds)
Average clip duration: 7.97 seconds (7974.83 ms)
Min clip duration: 5.10 seconds (5100 ms)
Max clip duration: 15.12 seconds (15125 ms)

Note: Complete metadata is available in dataset_metadata.json in the dataset root directory.

Dataset Structure

The dataset uses a unified structure where each example contains all synchronized video streams:

dataset/
├── data-*.arrow         # Dataset files (Arrow format)
├── dataset_info.json    # Dataset metadata
├── dataset_metadata.json  # Complete dataset statistics
├── state.json           # Dataset state
├── README.md            # This file
├── medias/              # Media files (mosaics, previews, etc.)
│   └── mosaic.mp4       # Mosaic preview video
└── videos/              # All video clips
    └── ego/      # Ego video clips

Dataset Format

The dataset contains 60 synchronized scenes in a single train split. Each example includes:

Synchronized video columns: One column per flux type (e.g., ego)
Scene metadata: scene_id, sync_id, duration_ms, padding_ms, fps
Rich metadata dictionary: Task, environment, audio info, and synchronization details

All videos in a single example are synchronized and correspond to the same moment in time.

Usage

Load and Access Dataset

import json
import random
from pathlib import Path
import cv2
from huggingface_hub import snapshot_download
from datasets import load_from_disk

repo = "orgn3ai/YOGURT-ORDER-PREPARATION-sample"

# 1) Download snapshot locally
local_path = snapshot_download(repo_id=repo, repo_type="dataset")
base_dir = Path(local_path)
print("Snapshot path:", base_dir)

# 2) Load dataset saved with save_to_disk()
ds = load_from_disk(str(base_dir))
train = ds["train"] if isinstance(ds, dict) and "train" in ds else ds
print("Train rows:", len(train))
print("Train columns:", train.column_names)

# 3) Read root metadata.json and extract "flux"
metadata_path = base_dir / "dataset_metadata.json"
if not metadata_path.exists():
    raise FileNotFoundError(
        f"dataset_metadata.json not found at repo root: {metadata_path}\n"
        "Check your repo tree; maybe it's named dataset_metadata.json instead."
    )

with metadata_path.open("r", encoding="utf-8") as f:
    root_meta = json.load(f)

flux = root_meta.get("flux")
if not isinstance(flux, list) or not flux:
    raise ValueError(f'Expected metadata.json["flux"] to be a non-empty list, got: {flux}')

print("Flux entries:", flux)

# 4) Pick a random dataset entry
idx = random.randrange(len(train))
ex = train[idx]

print("\nRandom example index:", idx)
print("Example keys:", list(ex.keys()))

def resolve_video_path(video_value) -> Path:
    """
    video_value can be:
    - string path (most common case)
    - dict like {"path": "...", "bytes": ...} (for backward compatibility)
    """
    if isinstance(video_value, dict) and "path" in video_value:
        rel = video_value["path"]
    elif isinstance(video_value, str):
        rel = video_value
    else:
        raise TypeError(f"Unsupported video value type: {type(video_value)}; value={video_value}")

    # Normalize to avoid leading "./"
    rel = str(rel).lstrip("/")

    # Your dataset may store relative paths like "videos/ego/xxx.mp4"
    # Resolve them inside the snapshot folder.
    return base_dir / rel

def inspect_video(path: Path):
    print(f"  Local path: {path}")
    print(f"  Exists: {path.exists()}")
    if not path.exists():
        return {"ok": False, "reason": "file_not_found"}

    cap = cv2.VideoCapture(str(path))
    if not cap.isOpened():
        return {"ok": False, "reason": "cannot_open"}

    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    fps = float(cap.get(cv2.CAP_PROP_FPS))
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    # Some codecs report fps=0; guard it
    duration = (frame_count / fps) if fps and fps > 0 else None

    # Try read first frame
    ret, frame0 = cap.read()
    cap.release()

    info = {
        "ok": True,
        "width": width,
        "height": height,
        "fps": fps,
        "frame_count": frame_count,
        "duration_sec": duration,
        "first_frame_ok": bool(ret),
        "first_frame_shape": tuple(frame0.shape) if ret and frame0 is not None else None,
        "first_frame_dtype": str(frame0.dtype) if ret and frame0 is not None else None,
    }
    return info

# 5) For each flux key, inspect the associated video
print("\n=== VIDEO CHECK ===")
for key in flux:
    print(f"\nFlux key: {key}")
    if key not in ex:
        print(f"  ERROR: key '{key}' not in example. Available keys: {list(ex.keys())}")
        continue

    try:
        video_path = resolve_video_path(ex[key])
    except Exception as e:
        print(f"  ERROR resolving path: {e}")
        continue

    info = inspect_video(video_path)
    if not info["ok"]:
        print(f"  ERROR: {info['reason']}")
        continue

    print("  Video properties:")
    print(f"    - Resolution: {info['width']}x{info['height']}")
    print(f"    - FPS: {info['fps']:.3f}")
    print(f"    - Frames: {info['frame_count']}")
    if info["duration_sec"] is not None:
        print(f"    - Duration: {info['duration_sec']:.3f}s")
    else:
        print("    - Duration: (fps unavailable)")
    print(f"    - First frame decoded: {info['first_frame_ok']}")
    if info["first_frame_ok"]:
        print(f"    - Frame0 shape: {info['first_frame_shape']}")
        print(f"    - Frame0 dtype: {info['first_frame_dtype']}")

print('\n=== LABELS ===')
print(f"nbLabels: {len(ex['labels'])}")
for label in ex['labels']:
    print(f"    - {label['time_ms']}ms (withoutPadding): {label['label']}")

print("\nDONE.")

Dataset Features

Each example contains:

scene_id: Unique scene identifier (e.g., "01_0000")
sync_id: Synchronization ID linking synchronized clips
duration_ms: Duration of the synchronized clip in milliseconds (includes padding)
padding_ms: Padding applied to clips (added at beginning and end, total padding = padding_ms × 2)
fps: Frames per second (extracted from video)
batch_id: Batch identifier
dataset_name: Dataset name from config
One column per flux: Each flux name from metadata['flux_names'] has its own column (e.g., ego) - String path to video file (relative to dataset root)
metadata: Dictionary containing:
- task: Task identifier
- environment: Environment description
- has_audio: Whether videos contain audio
- num_fluxes: Number of synchronized flux types
- flux_names: List of flux names present
- sequence_ids: List of original sequence IDs
- sync_offsets_ms: List of synchronization offsets

Additional Notes

Important: This dataset uses a unified structure where each example contains all synchronized video streams in separate columns. All examples are in the train split.

Synchronization: Videos in the same example (same index in the train split) are automatically synchronized. They share the same sync_id and correspond to the same moment in time.

Flux Keys: The available flux keys are listed in dataset_metadata.json under the "flux" key. Use these keys to programmatically access video columns in each example.

Video Paths: Video paths are stored as strings (relative to the dataset root directory). Paths can be resolved using the resolve_video_path function shown in the usage example above.

License

This dataset is licensed under cc-by-nc-nd-4.0.

Downloads last month: 195