ropedia-xperience-10m-task-baselines

This project builds on the Xperience-10M dataset released by Ropedia to provide public, reproducible embodied-AI evaluation materials. It is organized into two evidence lines. Line 1 turns one public sample episode into inspectable tasks, targets, and baseline runs. Line 2 uses selected 128-episode public-safe artifacts for aligned metadata/raw baselines, Qwen3-Omni v6 LoRA, Cosmos3-Super Reasoner, and Cosmos3-Nano Future Window. Every score links back to its source artifact, and direct scores remain clearly separated from compact-proxy estimates.

Updated: 2026-06-23.

Scope: Line 1 uses one public sample episode. Line 2 uses selected 128-episode public-safe artifacts linked back to official gated episode paths. Raw Xperience-10M MP4/HDF5/RRD files, Qwen3 base weights, Cosmos3 base weights, and gated data are not redistributed here.

Cite This Repository

Use this copyable BibTeX block for the repository:

@misc{he2026ropedia_xperience10m_task_suite,
  author       = {Chaoyue He},
  title        = {Ropedia Xperience-10M Task Suite},
  year         = {2026},
  url          = {https://github.com/ChaoYue0307/ropedia-xperience-10m-task-suite},
  note         = {Public task and evaluation layer for Ropedia Xperience-10M: two evidence lines, 20 embodied-AI tasks, 180 scored method-task records, and selected-128 model diagnostics}
}

Contents

• Project Entry Points
• At A Glance
• Data Explorer Analysis
• Two Evidence Lines
• Fast Project Map
• Why This Project Exists
• Start Here
• Glossary
• Current Research Scope
• Evaluation Protocol
• Dataset Context
• Reproducibility
• Citation / BibTeX

Project Entry Points

Use the two evidence lines first, then choose the artifact that answers your question. The dashboard is the best visual overview; the GitHub repo is the source of truth for scripts and generated JSON; Hugging Face mirrors contain public-safe cards, metrics, figures, and model artifacts.

Quick rule: use Line 1 for “can I inspect and reproduce the task?” Use Line 2 for “how do aligned baselines and model diagnostics compare on the selected 128 episodes?”

The committed task contracts, result matrices, validation JSON, public-safe result packages, GitHub sources, and Hugging Face mirrors are the canonical technical evidence.

At A Glance

Public Structure: 20 Tasks / 4 Directions / 3 Pipelines / 1 Unified Target

The project has four connected layers. The 20 tasks are the scored benchmark contracts. The 4 directions are research groupings over those same tasks. The 3 foundation pipelines are training recipes that reuse the same modalities, windows, and task targets. The 1 unified embodied model target is the long-term integration goal after those pipelines mature.

Layer rule: if it has a metric, it is a task; if it explains what the evidence studies, it is a direction; if it describes model inputs and training targets, it is a pipeline; if it combines perception, 3D memory, language, action, and planning, it is the unified target rather than an extra score axis.

Data Explorer Analysis

The data explorer is now a three-scope analysis layer, not only a raw-file browser. It compares the public sample episode, selected 128-episode feature exports, and the Hugging Face-hosted gated full-dataset metadata without mixing their evidence boundaries.

Entry points: website analysis section, analysis report, and structured analysis record.

Two Evidence Lines

The public suite is organized around two evidence lines. Keep them separate when comparing metrics.

Result Ledger

Method Blocks

Cosmos3-Super Forward-Dynamics LoRA is published as a separate fine-tuned adapter artifact with weights/results; it is not counted as a 20-task matrix method row.

Qwen3-Omni Run Versions

These are Qwen3-Omni run versions inside Line 2: selected 128 episodes. They are not the project evidence lines. The 20-task matrix uses Qwen3-Omni v6 LoRA; v5 remains the pinned prior multiscale release; v1-v4 are lineage and ablation evidence.

Detailed lineage: QWEN3_OMNI_RUN_LINEAGE.md and qwen3_omni_run_lineage.json.

Result entry points: TWO_EVIDENCE_LINES.md, two_evidence_lines.json, TWO_EVIDENCE_LINE_RESULT_SUMMARY.md, two_evidence_line_result_summary.json, QWEN3_OMNI_RUN_LINEAGE.md, qwen3_omni_run_lineage.json, single_episode_task_model_radar.json, episode128_task_model_radar.json, task_method_20_result_matrix.json, and xperience10m_128_episode_feature_index.json.

Fast Project Map

Why This Project Exists

This project is organized as a compact research artifact around Xperience-10M: start from a real public episode, make every modality and label path inspectable, turn the data into concrete embodied-AI tasks, and keep the evaluation boundary clear while preparing the next multi-episode experiments. The emphasis is on research judgment as much as implementation: what the sample can show, where the selected-128 comparison begins, and what evidence should exist before presenting stronger model quality.

The work is designed to demonstrate four capabilities that matter for embodied-AI research infrastructure:

Start Here

The public release is split across GitHub, the website, and Hugging Face. Use the public evidence map first for the shortest route through those mirrors, or use the machine-readable companion evidence-map data. For the one-page project summary, use the project brief and project-summary data.

Glossary

Use the glossary when a term such as evidence line, 20-frame window, direct score, compact-proxy score, raw metric value, normalized radar value, minimal/minimum baseline, simple baseline, Qwen v1-v6, Cosmos3-Super, LoRA adapter, or HF artifact dataset is unclear. The same definitions are mirrored as glossary data for the website and Hugging Face repos.

Published Mirror Map

Public release checks are exposed as structured records for mirrors and dashboards: website integrity, rendered-site check, task-surface integrity, publication audit, mirror parity, public-surface QA, and roadmap data.

Research Project Overview

For the fastest interpretation of the current metrics, start with the research takeaways and takeaway data. They summarize what the public sample results actually show: class shift under chronological splits, neural gains on dynamics/order/alignment, harder retrieval/reconstruction probes, and why the next model-quality step needs held-out episodes.

Current contributions:

• manifested sliding-window features over the currently extracted modalities,
• motion-only and current all-feature baseline models,
• 20 end-to-end episode-level task contracts,
• one shared 20-frame window and chronological split contract across the public-sample task suite,
• lightweight neural MLP heads for the same task contracts,
• a generated four-direction research taxonomy matching the Ropedia job tracks,
• four additional direction-extension probes with minimal and neural baselines,
• human-readable research task cards and an interactive scrub/play walkthrough storyboard for every task,
• an interactive research roadmap connecting 20 tasks, four research tracks, current sample evidence, the Qwen3-Omni scale-up path, and foundation-model track selection,
• a next-milestone track for Qwen3-Omni fine-tuning, Cosmos 3 world modeling, and sensor-bridge evaluation,
• a future pretraining plan for an Xperience Embodied Foundation Model over the full corpus after smaller multi-episode stages prove value,
• metrics, predictions, model weights, manifests, charts, and a two-level tabbed static research website,
• a clear explanation of what is implemented now and what moves to the multi-episode stage.

Current Research Scope

This project is best read as a staged embodied-AI research study:

Detailed dataset notes, reproduction checks, and generated data reports are included for implementation inspection. The full file map is available in the artifact guide.

Source alignment is tracked in the source-alignment note and source-alignment data. Whenever this repo says "full dataset," it refers to the Hugging Face-hosted gated dataset version at ropedia-ai/xperience-10m, not a local raw-data mirror. The official gated ropedia-ai/xperience-10m card reports 31.9 TB on the live Hugging Face dataset card and an about-1PB full-scale storage statement; the committed API-listing snapshot records 12,103 episode folders as upstream metadata only, not a local raw-data inventory. In other words, those episode folders are upstream listing metadata only for this project. The public sample remains ropedia-ai/xperience-10m-sample under cc-by-nc-4.0, with the HOMIE Toolkit and Rerun 0.29.0 noted as source tooling. The official responsible-use note that the data is limited in diversity is preserved.

Project Status

If you only have one minute, use the project status note and project-status data. They give the current research state in one compact table:

90-Second Research Project Path

Recommended project sequence:

A compact project-path summary is available at project-packet data.

Supporting Files

The artifact guide maps the public evidence who want to inspect the project files after the first pass. It groups the main briefs, task outputs, baseline results, visual assets, data notes, and scale-up documents.

The artifact index is the compact machine-readable companion used by the website and Hugging Face artifact dataset.

The project resource map is the complete generated inventory for scripts, result artifacts, website data, visual assets, configs, notes, and prepared Hugging Face bundles. Its structured companion, docs/data/project_resource_map.json, is used by the website Resources tab to search, filter, and open scripts/results directly.

Evaluation Protocol

The evaluation protocol and evaluation-protocol data are generated from committed metric artifacts. They define:

• the 20-frame window unit, stride, feature dimension, and raw-data policy,
• the chronological 70/30 single-episode split and its generalization limit,
• the per-task input, target, primary metric, minimal score, and neural score,
• leakage controls for future labels, target-side signals, caption/object labels, and train-only normalization,
• current limitations, including cross-episode generalization, audio-visual learning, pixel-depth reconstruction, and real held-out multi-episode Qwen3-Omni quality.

Dataset Context

The official ropedia-ai/xperience-10m dataset is a gated large-scale egocentric multimodal dataset for embodied AI, robotics, spatial intelligence, and world modeling. The public ropedia-ai/xperience-10m-sample repo provides the sample episode used for the implemented task suite here.

This project keeps two evidence lines separate. Line 1 uses the public sample for raw-file inspection, task construction, and local reproducibility. Line 2 uses selected 128-episode public-safe artifacts for same-split method comparison, Qwen3-Omni v6 diagnostics, and Cosmos3 diagnostics. Raw Xperience-10M MP4/HDF5/RRD files are not redistributed in this repo or in the Hugging Face mirrors.

The current verified public-sample subset is:

• one public sample episode, 5,821 frames, and 1,161 aligned windows,
• raw sample files with six MP4 video streams and audio streams,
• annotation.hdf5 carrying depth, SLAM/camera pose, hand/body mocap, IMU, language/caption annotations, calibration, metadata, and timing records,
• an 8,546-dimensional baseline representation using video, audio, depth, pose/SLAM, mocap, IMU, calibration, and language-derived signals.

Detailed dataset notes are available in the dataset-card alignment note and dataset-alignment data for full upstream-card and access-term context. Line 1 is the task lab; Line 2 is the selected-128 comparison layer; compact-proxy cells stay explicitly marked where direct raw targets are missing.

Start with the visual dashboard:

chaoyue0307.github.io/ropedia-xperience-10m-task-suite

Hugging Face Space app:

cy0307-ropedia-xperience-10m-task-suite.hf.space

Evidence Views

Links

Citation

If you use this project, cite the Ropedia Xperience-10M Task Suite by Chaoyue He and also cite the upstream Ropedia Xperience-10M dataset according to its official dataset card. The repository includes CITATION.cff, codemeta.json, and docs/data/project_manifest.json for machine-readable metadata.

Copy this BibTeX entry for the repository:

@misc{he2026ropedia_xperience10m_task_suite,
  author       = {Chaoyue He},
  title        = {Ropedia Xperience-10M Task Suite},
  year         = {2026},
  url          = {https://github.com/ChaoYue0307/ropedia-xperience-10m-task-suite},
  note         = {Public task and evaluation layer for Ropedia Xperience-10M: two evidence lines, 20 embodied-AI tasks, 180 scored method-task records, and selected-128 model diagnostics}
}

License And Metadata

The code files are MIT-licensed. Raw Xperience-10M data is not redistributed here, and dataset use remains governed by the official Ropedia/Xperience-10M terms. See LICENSE and DATA_NOTICE.md.

The infographic uses a custom text-free research background and puts the shared processing contract plus all 20 unified task families in one figure. Public sample stream thumbnails remain available through the raw sample browser and derived modality assets instead of a separate repeated atlas panel. The task names, input/output summaries, and metrics are overlaid from results/episode_task_suite/summary_report.json with scripts/render_task_suite_infographic.py, so the published PNG is a presentation graphic with verified labels and metrics, not a hallucinated metric sheet.

The complete unified task list is documented in TASK_SUITE_20.md and docs/data/task_suite_20.json. Historical tier2_task_suite paths remain only as stable provenance links inside the same suite.

The unified radar is now a grouped small-multiple comparison board instead of a nine-method overlay. It keeps all 20 task axes and all 9 method rows visible, but separates the methods into single-episode, 128-episode metadata/text, 128-episode raw-feature, and foundation-model panels. Every method has 20 explicit result records in the public matrix. Tasks 15 and 19 are marked as compact-proxy completions where the 128 export lacks raw interaction strings or paired video-view embeddings; those six proxy cells stay explicitly marked instead of being blended into direct-target metrics. The SVG uses sqrt(normalized_score) only for visual radius so small but real differences are readable; raw metrics and exact linear normalized scores remain in JSON and the table. Cosmos3-Super forward-dynamics LoRA remains a separate artifact card because its camera-pose proxy MSE is not one of the 20 task metrics. The machine-readable copies are docs/data/unified_task_model_radar.json and docs/data/task_method_20_result_matrix.json; the explicit score/proxy ledger is docs/data/task_method_20_gap_audit.json and TASK_METHOD_20_GAP_AUDIT.md; the public matrix is TASK_METHOD_20_RESULT_MATRIX.md. The website Results section also renders the same 180 cells as a wide, source-linked table with raw values, normalized radar values, metric keys, and direct/proxy badges.

The same source data is also split into two focused radars:

The single-episode radar uses one enlarged panel for Minimal vs Neural MLP, both with 20/20 scored public-sample axes. The 128-episode radar uses three grouped panels for metadata/text baselines, raw-feature baselines, and foundation-model rows: metadata and raw-feature simple/NN baselines are now complete 20/20 multi-episode records, and Qwen3-Omni v6 LoRA, Cosmos3-Super Reasoner, and Cosmos3-Nano Future Window each carry 20 scored task records. The current matrix has 180/180 scored method-task records.

The website raw sample browser includes a concise stream-to-feature ledger backed by docs/data/modality_atlas.json and docs/assets/modalities/. Those assets are small derived thumbnails from the public sample, not raw Xperience-10M files.

The pipeline and architecture figures use the same pattern: text-free visual backgrounds carry the composition, while scripts/render_overview_figures.py overlays exact labels, dimensions, and metrics from the committed result files.

Scope

This is a learning, inspection, and pipeline-validation repo with two public evidence lines. Line 1 is built from one public sample episode. Line 2 uses a selected 96/16/16 split over 128 episode paths, public-safe processed features, and verified Qwen3-Omni/Cosmos3 diagnostic artifacts.

What Is Inside

scripts/
  train_min_action_model.py         # motion/IMU baseline
  train_all_modalities_model.py     # current all-feature lightweight baseline
  episode_task_suite.py             # public-sample task definitions
  neural_task_models.py             # optional PyTorch MLP heads for task contracts
  research_direction_taxonomy.py    # maps walkthrough-backed tasks to the four research tracks
  research_direction_extension_tasks.py # one extra data-backed probe per track
  tier2_task_suite.py              # historical-name provenance builder for unified task rows
  build_unified_task_suite.py       # builds TASK_SUITE_20.md and task_suite_20.json
  build_unified_task_model_radar.py # builds grouped 20-axis model comparison radars
  build_task_method_20_gap_audit.py # builds the explicit 180/180 scored-cell ledger
  task_walkthroughs.py              # human-readable task-card and walkthrough-storyboard metadata
  generate_visualizations.py        # refreshes SVG charts + summary JSON
  render_task_suite_infographic.py  # renders the task-suite presentation PNG
  export_modality_atlas_assets.py   # exports responsive modality-card assets
  render_overview_figures.py        # renders polished pipeline/architecture PNGs
  build_brand_assets.py             # derives logo sizes, favicon, social card
  build_artifact_index.py           # builds the compact artifact guide data
  build_quality_gates.py            # builds release checks
  validate_mirror_parity.py         # checks prepared GitHub/HF mirror file parity
  validate_scope_claims.py          # separates setup artifacts from completed model metrics
  validate_task_surface.py          # checks readable task cards and interactive storyboard wiring
  validate_website_integrity.py     # checks local site links, anchors, and images
  validate_publication_package.py   # checks public repo + HF bundle contents
  publish_hf_bundles.py             # uploads prepared HF Space/artifact/model bundles
  omni/
    download_sample_modelscope.py   # ModelScope sample download helper
    build_episode_manifest.py       # metadata-only multi-episode scanner
    plan_finetune_sample_budget.py  # storage/sample-count planner
    qwen3_omni_adapter_smoke.py     # real-data Qwen3-Omni adapter setup check
    score_existing_model_output_task_probes.py # scores task targets already present in verified model outputs
    collect_qwen3_v4_release_artifacts.py # pulls verified v4 results after remote eval

results/
  min_action_model/                 # motion-only action baseline artifacts
  min_subtask_model/                # motion-only subtask baseline artifacts
  min_all_modalities_action_model/  # current all-feature action artifacts
  min_all_modalities_subtask_model/ # current all-feature subtask artifacts
  episode_task_suite/               # task-suite metrics and predictions
    neural_mlp/                     # optional neural baseline artifacts per task
    research_directions/            # four-track taxonomy, CSV, and summary
    research_direction_extensions/  # four extra direction probes + predictions
    tier2_task_suite/               # provenance baseline tasks + predictions; historical path
    task_walkthroughs/              # case-study walkthroughs for walkthrough-backed tasks
  omni_exploration/                 # ModelScope readiness-check artifacts
  omni_finetune/model_output_task_probes_20260616/ # task-13/task-16 probes derived from verified model JSON

docs/
  index.html                        # GitHub Pages dashboard
  data/additional_development_directions.json # concrete non-backbone project directions
  data/summary_metrics.json         # website-readable metrics bundle
  data/task_suite_20.json           # unified 20-task suite bundle
  data/unified_task_model_radar.json # 20-task radar values, groups, and sources
  data/single_episode_task_model_radar.json # 1-episode grouped radar values
  data/episode128_task_model_radar.json # 128-episode grouped radar values
  data/task_method_20_result_matrix.json # 9-method x 20-task result matrix
  data/task_method_20_gap_audit.json # explicit 180/180 scored-cell ledger
  data/task_icon_manifest.json     # assigned icon asset map for all 20 tasks
  data/evidence_contract.json       # machine-readable project scope
  data/artifact_index.json          # compact project-artifact catalog
  data/live_publication_status.json # live GitHub/HF publication verification
  data/quality_gates.json           # machine-readable release checks
  data/task_suite_enhancement_128.json # no-new-episode 128-suite enhancement pack
  data/task_surface_integrity.json  # machine-readable task-card/storyboard integrity check
  data/project_manifest.json        # machine-readable public-surface metadata
  data/project_packet.json          # compact project path and scope summary
  data/research_roadmap.json        # multi-episode and omni-model roadmap
  data/research_directions.json     # four-track website data bundle
  data/research_direction_extensions.json # four extra probe data bundle
  assets/task-icons/*.svg           # one crisp assigned icon per task
  assets/task-icons/task-icon-atlas.png # generated overview atlas for the 20-task visual language
  data/tier2_task_suite.json       # provenance baseline bundle; historical path
  data/task_walkthroughs.json       # human-readable task-card and walkthrough-storyboard data
  data/modality_atlas.json          # responsive modality-card data
  assets/brand/*.png                # project logo, favicon, social card
  assets/task_suite_infographic.png # task-suite presentation graphic
  assets/modalities/                # public-sample derived modality thumbnails
  assets/pipeline_diagram.png       # verified episode pipeline graphic
  assets/qwen3_omni_lora_pipeline.png # Qwen3-Omni LoRA training-flow figure
  assets/task_architectures.png     # verified task-head architecture map
  assets/charts/unified_task_model_radar.svg # 9-method grouped small-multiple radar board
  assets/charts/single_episode_task_model_radar.svg # 1-episode enlarged radar panel
  assets/charts/episode128_task_model_radar.svg # 128-episode grouped radar panels
  assets/charts/*.svg               # regenerated visualizations

notes/
  min_action_model.md
  all_modalities_model.md
  episode_task_suite.md

Raw Xperience-10M data is not committed. Download it from the official Ropedia distribution and follow the dataset terms.

GitHub Package

The public dashboard is packaged as a static-site container on GitHub Container Registry. It contains the docs/ site plus the main project documents; it does not include raw Xperience-10M videos, raw annotations, gated data, or model weights.

docker pull ghcr.io/chaoyue0307/ropedia-xperience-10m-task-suite:latest
docker run --rm -p 8080:80 ghcr.io/chaoyue0307/ropedia-xperience-10m-task-suite:latest

Then open http://localhost:8080.

Data Expected

The scripts expect a workspace with the Ropedia HOMIE toolkit and the Xperience-10M sample episode:

<workspace>/
  HOMIE-toolkit/
  data/sample/xperience-10m-sample/
    annotation.hdf5
    fisheye_cam0.mp4
    fisheye_cam1.mp4
    fisheye_cam2.mp4
    fisheye_cam3.mp4
    stereo_left.mp4
    stereo_right.mp4

The public website also includes a Raw Sample Browser that lists every official sample file, plays compact browser-preview clips derived from the official MP4 streams, exposes the audio track embedded in fisheye_cam0.mp4, links the full raw Hugging Face source for each MP4/HDF5/RRD file, and describes the annotation.hdf5 group organization without copying large raw files into this repository. The same manifest also lists what the non-playable annotation.hdf5 and visualization.rrd files contain, how each relates to the synchronized MP4 streams and 20-frame windows, and which external tools can open them.

The public sample dataset identifier is:

ropedia-ai/xperience-10m-sample

Hugging Face URL:

https://huggingface.co/datasets/ropedia-ai/xperience-10m-sample

Quickstart

From a workspace folder:

git clone https://github.com/Ropedia/HOMIE-toolkit.git
python3.12 -m venv .venv
source .venv/bin/activate
pip install -r HOMIE-toolkit/requirements.txt huggingface_hub hf_xet

Download the sample:

hf download ropedia-ai/xperience-10m-sample \
  --repo-type dataset \
  --local-dir data/sample/xperience-10m-sample

If Hugging Face access is unavailable in your environment, use ModelScope:

python scripts/omni/download_sample_modelscope.py \
  --output-dir data/sample/xperience-10m-sample \
  --mode minimal

--mode minimal downloads annotation.hdf5, README.md, and fisheye_cam0.mp4. Use --mode all-training to add all six MP4 streams while still skipping visualization.rrd.

Clone and run this repo:

git clone https://github.com/ChaoYue0307/ropedia-xperience-10m-task-suite.git
cd ropedia-xperience-10m-task-suite
python scripts/episode_task_suite.py --workspace /path/to/workspace

Run the public-sample task definitions with lightweight neural heads:

pip install torch
python scripts/episode_task_suite.py \
  --workspace /path/to/workspace \
  --include-neural

Then rebuild the unified 20-task index after the historical provenance bundle is regenerated:

python scripts/tier2_task_suite.py --workspace /path/to/workspace
python scripts/build_unified_task_suite.py
python scripts/build_evaluation_protocol.py

Run the smaller baselines:

python scripts/train_min_action_model.py --workspace /path/to/workspace
python scripts/train_all_modalities_model.py --workspace /path/to/workspace

Xperience-10M Fine-Tuning Exploration

This repo includes a first Qwen3-Omni fine-tuning path over Xperience-10M. The repository separates public-sample evidence from multi-episode fine-tuning artifacts. The selected-episode held-out package is now verified as a diagnostic result, not a strong final action/subtask model. The useful distinction is:

• direct Qwen3-Omni inputs: RGB/fisheye video, embedded MP4 audio, and language prompts,
• adapter-required Xperience-10M sensor inputs: depth, pose/SLAM, hand/body mocap, contacts, and IMU.

The figure shows the intended end-to-end training flow: raw valid episodes enter episode-level split validation, parallel media/sensor export creates Qwen-style JSONL records, Qwen3-Omni receives video/audio/text directly, the sensor bridge adds depth/pose/mocap/IMU features, LoRA adapters are trained on prepared train/val episodes, and sealed held-out test evaluation produces predictions, metrics, run reports, and upload-ready adapter artifacts.

The scale-up path requires valid prepared episodes, held-out episode splits, training metadata, predictions, metrics, and a run report. A result is ready for public README, website, or Hugging Face updates only after the validator passes and scripts/omni/package_verified_omni_result.py creates a public-safe derived-artifact package. The current verified package is listed in docs/data/omni_finetune_verified_result.json. The current cross-version comparison is generated at docs/data/omni_model_comparison.json and results/omni_finetune/OMNI_MODEL_COMPARISON.md; it separates the single-episode task suite, 128-episode aligned simple/NN baselines, Qwen3-Omni v6 LoRA, Cosmos3-Super Reasoner, and Cosmos3-Nano Future Window packages. The same generated files also include model_groups: a model-first view that pairs 1-episode and 128-episode entries for the same family. Use that section when comparing task heads against task heads, Qwen3-Omni smoke/LoRA against Qwen3-Omni LoRA, or Cosmos3-Nano compatibility against future Cosmos weight releases. For Qwen3-Omni specifically, read QWEN3_OMNI_RUN_LINEAGE.md: v1-v4 are pipeline-hardening and ablation evidence, v5 is the pinned prior multiscale release, and v6 is the current public 20-task Qwen row.

The no-new-episode enhancement plan is recorded in docs/data/task_suite_enhancement_128.json and TASK_SUITE_ENHANCEMENT_128.md. It keeps the current Qwen3-Omni v6 and Cosmos3 packages as baselines, then defines dense-window scenarios, hierarchical action/subtask targets, task bottlenecks, and experiment cards for stronger selected-128 runs without overwriting earlier results.

Sample Count Decision

Do not treat "10M" as a reason to start with the entire dataset. The engineering unit that matters first is diverse held-out episodes, not adjacent windows from one session.

Use the budget helper before downloading:

python scripts/omni/plan_finetune_sample_budget.py \
  --storage-root /path/to/storage \
  --target-free-after-download-gb 800 \
  --all-training-per-episode-gb 2.4 \
  --full-preview-per-episode-gb 5.1

Multi-Episode Readiness Gate

python scripts/omni/discover_xperience10m_sources.py \
  --workspace /path/to/ropedia-xperience-10m-task-suite \
  --data-root /path/to/xperience10m_data \
  --output results/omni_finetune/source_discovery.json

Current status in this repo:

• public_sample_valid_episodes: 1 (degraded-valid: annotation + fisheye_cam0.mp4)
• gated_metadata_audit: 12,102 complete visible episodes across 802 complete sessions
• selected_episode_plan: 128 source-balanced episodes, 96/16/16 train/val/test
• selected_download_size: 277.71 GiB excluding visualization.rrd
• selected_source_feature_index: XPERIENCE10M_128_EPISODE_FEATURE_INDEX.md and docs/data/xperience10m_128_episode_feature_index.json
• processed_128_feature_artifacts: 34,269 Qwen3-Omni v6 multiscale windows, 106,095 dense multiscale compact rows, and 34,269 x 394 metadata/text matrix rows, all linked back to official gated ropedia-ai/xperience-10m episode paths
• verified_final_diagnostic_package: true
• selected_split: 96 train / 16 validation / 16 held-out test episodes
• exported_windows: 2,848 train / 512 validation / 448 test
• validation_samples_used: 512
• held_out_eval: 448 test windows from 14 exported test episodes
• final_train_loss / final_val_loss: 0.0277 / 0.0278
• current_quality_target: strict-label JSON validity 100.00%, meeting the 98% target; action/subtask quality remains weak
• qwen3_lora_adapter_repo: https://huggingface.co/cy0307/ropedia-qwen3-omni-lora-128ep
• cosmos3_super_lora_adapter_repo: https://huggingface.co/cy0307/ropedia-cosmos3-super-forward-dynamics-lora-128ep
• 128_aligned_baselines: unified 20-task axes for simple and neural baselines, including metadata/text rows and public-safe compact-proxy rows where raw-feature targets are required
• cosmos3_nano: verified Cosmos3-Nano future-window compatibility package, 378 held-out future-window predictions from 14 test episodes
• cosmos3_super_reasoner: verified Cosmos3-Super Reasoner base-weight JSON-task evaluation, 448 held-out predictions from 14 test episodes; JSON validity 51.12%, action macro-F1 0.0008, contact accuracy 32.14%, transition accuracy 36.83%
• cosmos3_super_forward_dynamics_lora: verified 8-GPU FSDP LoRA artifact over camera-pose proxy targets; 2,848 train rows, 512 val rows, 448 test rows, 26.2M adapter parameters, val MSE 4.0082, test MSE 3.6853; public package excludes safetensors
• gated dataset: available for selected multi-episode data preparation
• source_discovery: results/omni_finetune/source_discovery.json
• data_status: results/omni_finetune/DATA_ACCESS_STATUS.md
• access_status: results/omni_finetune/MULTI_EPISODE_ACCESS_STATUS.md

Use this gate before scheduling any full fine-tune run. The pilot should use balanced held-out selection, not the first paths in repository order. The current 128-episode selection filters for complete leaf episodes, excludes visualization.rrd, balances episode-size bands, and preserves one selected episode per top-level session UUID.

Progressive Train/Validation Pilot

The selected 128-episode plan can be used before every episode has arrived by training only on prepared train episodes and monitoring prepared val episodes. The final test episodes stay sealed until the end, so early development does not contaminate held-out evaluation.

python scripts/omni/build_selection_episode_manifest.py \
  --workspace /path/to/ropedia-xperience-10m-task-suite \
  --data-root /path/to/xperience10m_128 \
  --selection-json results/omni_finetune/xperience10m_128_episode_selection.json \
  --output results/omni_finetune/trainval_progressive/episode_manifest_trainval.json \
  --include-split train \
  --include-split val

scripts/omni/run_trainval_progressive_128.sh wraps the same guard, exports a train/val-only Qwen3-Omni JSONL dataset, and launches LoRA training without running final test evaluation. The exporter uses session-qualified episode IDs and path-based split matching so repeated folder names such as ep1 cannot collide across different sessions.

For larger prepared subsets, scripts/omni/run_trainval_parallel_export_8gpu.sh uses the same split guard, exports episodes in parallel CPU shards, skips and reports episodes that contain no labeled windows under the configured label rule, then launches Qwen3-Omni LoRA with NUM_PROCESSES=8.

Full 128-Episode Held-Out Pilot

Once all selected episodes are complete, use the fixed selected-episode split:

• 96 train episodes,
• 16 validation episodes,
• 16 held-out test episodes.

The clean full-run launcher validates the selected split, exports all splits in parallel, trains Qwen3-Omni LoRA on train episodes while optionally monitoring validation loss, then evaluates on the held-out test split:

RUN_ID=xperience10m_qwen3_omni_128ep_fullsplit_fast8gpu \
DATA_ROOT=/path/to/xperience10m_128 \
SELECTION_JSON=results/omni_finetune/xperience10m_128_episode_selection.json \
MODEL_DIR=/path/to/Qwen__Qwen3-Omni-30B-A3B-Instruct \
NUM_PROCESSES=8 \
TRAIN_VAL_SPLIT=val \
MAX_VAL_SAMPLES=512 \
scripts/omni/run_128_fullsplit_parallel_export_8gpu.sh

The latest verified diagnostic package uses the same selected split and 8-GPU training path, includes the full held-out evaluation with 4,032 predictions and 99.90% JSON validity, and keeps raw data plus full Qwen weights out of the public repos. The next pass should keep this package contract while improving action/subtask target quality and error analysis.

Monitor the run with:

python scripts/omni/monitor_omni_progress.py \
  --run-id xperience10m_qwen3_omni_128ep_fullsplit_fast8gpu

The monitor reads training progress.jsonl, new evaluator partial-prediction progress, and legacy generation logs, so long held-out evals can still expose sample-level progress even before final metrics are written.

Validate the run artifacts stage by stage:

python scripts/omni/validate_omni_finetune_run.py \
  --run-id xperience10m_qwen3_omni_128ep_fullsplit_fast8gpu \
  --require-stage manifest

python scripts/omni/validate_omni_finetune_run.py \
  --run-id xperience10m_qwen3_omni_128ep_fullsplit_fast8gpu \
  --require-stage eval \
  --min-json-validity 0.98

After the eval validator passes, create the public-safe result package:

python scripts/omni/package_verified_omni_result.py \
  --dataset-run-id xperience10m_qwen3_omni_128ep_fullsplit_fast8gpu \
  --train-run-id <train_run_id> \
  --eval-run-id <eval_run_id>

For long-running remote jobs, the packaging step can be watched automatically:

python scripts/omni/watch_verified_omni_package.py \
  --dataset-run-id xperience10m_qwen3_omni_128ep_fullsplit_fast8gpu \
  --train-run-id <train_run_id> \
  --eval-run-id <eval_run_id>

While waiting, the watcher can append eval_progress_observed events from partial prediction files or legacy generation logs. This keeps the package status file useful during long held-out evaluations.

The package copies only small derived artifacts such as metrics, predictions, confusion matrices, run reports, manifests, validation summaries, and training metadata. The exact required eval files and primary metrics come from the selected backbone contract in configs/omni_backbones, so Qwen3-Omni, Cosmos-style world models, and VLA/policy tracks can share the same verified publication gate once their model-specific evaluators exist. The package excludes raw Xperience-10M files, base-model weights, adapter or checkpoint weights, full checkpoints, and large archives.

For hardware setups that can run multiple eval workers, the Qwen evaluator also supports deterministic sample shards:

CUDA_DEVICE_GROUPS="0,1 2,3 4,5 6,7" \
SHARDS=4 \
RUN_ID=<merged_eval_run_id> \
scripts/omni/run_qwen3_omni_lora_eval_sharded.sh

Only the merged eval directory should be validated and reported publicly, because the merger checks coverage and recomputes the metrics from all held-out predictions.

After dataset export, a model-neutral window index can be created for future backbones:

python scripts/omni/export_model_neutral_window_index.py \
  --dataset-jsonl results/omni_finetune/xperience10m_qwen3_omni_128ep_fullsplit_fast8gpu_dataset/dataset.jsonl

This produces window_index.jsonl and window_index_manifest.json so Cosmos- style world models and VLA/policy tracks can reuse the same split-checked windows without depending on Qwen chat-message records.

Uploading Qwen3-Omni LoRA artifacts

The public-safe verified package intentionally excludes raw data, base Qwen weights, LoRA weights, and full checkpoints. Adapter upload is a separate step: use it only when the intended adapter directory is present and the model card clearly distinguishes older smoke weights from the final selected-episode diagnostic run.

Keep weight-bearing repositories model-specific: the final 128-episode Qwen3-Omni adapter belongs in cy0307/ropedia-qwen3-omni-lora-128ep, older Qwen smoke material remains historical. Cosmos3-Nano remains an artifacts-only compatibility result; Cosmos3-Super Forward-Dynamics now has a separate weight-bearing model repo at cy0307/ropedia-cosmos3-super-forward-dynamics-lora-128ep. Metrics, predictions, audits, and reports stay in the artifact dataset.

python3 scripts/omni/upload_qwen3_omni_lora_to_hf.py \
  --repo-id cy0307/ropedia-qwen3-omni-lora-128ep \
  --source-dir /path/to/adapter_upload_package \
  --message "Upload Xperience-10M Qwen3-Omni LoRA pilot"

This script requires a valid Hugging Face token via HF_TOKEN or --token. Network availability to huggingface.co is required.

Foundation Backbone Plan

The next modeling plan tracks several foundation-model tracks instead of assuming one backbone solves every Xperience-10M objective.

See FOUNDATION_MODEL_PLAN.md and docs/data/foundation_model_plan.json for the full selection matrix, source links, and model-specific evaluation additions. See XPERIENCE_EMBODIED_FOUNDATION_MODEL_PRETRAINING.md for the long-term full-corpus pretraining plan.

The three headline foundation directions are also separated as pipeline tracks so each track is easy to read without mixing current results and future work:

For the single public sample, each direction is now shown as an explicit training-pair recipe:

High-resolution slide diagrams for the three tracks are published in docs/assets/foundation-pipelines. Spatial intelligence and human-video world modeling use the clean slide PNGs supplied for publication and are exported as 2560-pixel public images. The 2026-06-19 refresh verified that the latest uploaded Spatial and Human-video PNGs are byte-identical to the committed clean source cache. The VLA card now uses the clean VLA slide PNG supplied afterward and is exported through the same 2560-pixel public path. These images are communication assets, not completed model-quality evidence; the exact task, training, and evaluation contracts remain in the Markdown and JSON files.

Spatial intelligence models

Human-video world models

Vision-language-action models

See THREE_FOUNDATION_PIPELINES.md and docs/data/three_foundation_pipelines.json.

Backbone-specific contracts now live in configs/omni_backbones. The extension contract is documented in OMNI_MODEL_EXTENSION_CONTRACT.md, and the registry can be checked with:

python scripts/omni/backbone_registry.py --validate --json

Verify that every configured backbone can pass the public-safe packaging contract on synthetic derived artifacts:

python scripts/omni/smoke_test_backbone_packaging.py

After a real held-out package is created, audit it before updating README, website, or Hugging Face pages:

python scripts/omni/audit_verified_omni_package.py \
  --package-dir results/omni_finetune/verified_public/<eval_run_id>

Create a new planned backbone track from an existing contract template with:

python scripts/omni/scaffold_omni_backbone.py \
  --template-backbone policy_vla_branch \
  --id new_policy_branch \
  --display-name "New Policy Branch" \
  --model-family "Model family name" \
  --dataset-contract xperience10m_observation_action_v1 \
  --training-objective observation_to_action_policy \
  --checkpoint-gate policy_checkpoint_action_space_and_normalizer \
  --dry-run

Each backbone config declares the checkpoint gate, required train/eval files, allowed public artifacts, and forbidden private or heavyweight artifacts. This keeps Qwen3-Omni, Cosmos-style world models, and policy/VLA tracks on the same split, validation, and publication discipline even though their training targets are different.

Additional Development Directions

Beyond backbone selection and fine-tuning, Xperience-10M supports several concrete research-development tracks:

See ADDITIONAL_DEVELOPMENT_DIRECTIONS.md and docs/data/additional_development_directions.json.

Four Research Directions

The walkthrough-backed task contracts are organized against the four Ropedia research directions in a source-linked companion set:

• Direction taxonomy data
• Task-to-direction map
• Direction summary note
• Public direction data

The taxonomy uses two current baselines for every task:

Current direction-level coverage:

The important interpretation is that all four directions can be started from the Xperience-10M sample modalities, but only direction C is strongly represented by the current task evidence. Directions A, B, and D need additional targets and multi-episode training before they become full research deliverables.

Four Direction Probes

Alongside the unified 20-task suite, the repo includes one data-backed probe for each research direction. These probes are computed from the same shared_windows.npz, windows.csv, and feature_manifest.json artifacts, so the reported numbers are computed from sample-derived features and saved metric artifacts.

• research_direction_extension_results.json
• research_direction_extension_summary.md
• docs/data/research_direction_extensions.json
• research_direction_extension_tasks.svg

Run:

python scripts/research_direction_extension_tasks.py

These four probes make the direction mapping concrete while staying within the same single-episode evidence line. They should be read as task-backed probes, not as claims that the larger foundation-model directions are solved.

Unified 20-Task Suite

The sample task surface is presented as 20 tasks in one suite. All task rows share the same 20-frame window unit, 5-frame stride, chronological split, and minimal/neural comparison style, with task-specific leakage rules when a target would otherwise leak through caption, object, contact, or future features.

The historical tier2_task_suite file and directory names remain only for stable artifact links. They should be read as provenance bundles inside the unified 20-task suite, not as a separate benchmark tier.

• 20-task guide
• Task contract data
• All-method radar data
• Single-episode radar data
• 128-episode radar data
• 180-record result table
• Score/proxy audit data
• Score/proxy audit note
• TIER2_TASK_BASELINES.md
• tier2_task_suite_results.json
• docs/data/tier2_task_suite.json
• unified_task_model_radar.svg
• single_episode_task_model_radar.svg
• episode128_task_model_radar.svg
• tier2_task_suite.svg

The all-task table, including every input/output contract and minimal/neural metric, is in TASK_SUITE_20.md. Historical provenance links remain listed above for exact source tracing, but the public task surface should be read as one integrated 20-task suite.

Run:

/path/to/python-with-h5py scripts/tier2_task_suite.py

Regeneration needs either HOMIE-toolkit or an environment with h5py because the interaction/object targets come from the raw public-sample annotation.hdf5. The raw HDF5 and MP4 files remain excluded from the public repo and Hugging Face mirrors.

Task Walkthroughs For Juniors

Every task now has a beginner-facing explanation with:

• a concrete coffee-episode case study,
• exact input contract,
• middle process modules,
• output contract,
• minimal and neural metric,
• one important limitation.

Primary files:

• TASK_WALKTHROUGHS.md
• task_walkthroughs.json
• docs/data/task_walkthroughs.json
• docs/data/task_surface_integrity.json

Compact map:

Core Architecture Families in the 20-Task Suite

These are deliberately minimal baselines. They are useful because every input/output contract is explicit, not because they are strong embodied-AI models.

Shared setup:

raw episode -> 20-frame windows, stride 5 -> 8,546-dimensional multimodal representation
chronological split: first 70% train, last 30% test
scalers are fit on train windows only

There are four reusable head families:

The optional neural run keeps the same window representation, leakage filters, chronological splits, and metrics, but replaces the task heads with small PyTorch MLP classifiers or regressors. Its outputs live under results/episode_task_suite/neural_mlp/, and the rollup is stored in the neural_tasks section of results/episode_task_suite/summary_report.json.

The walkthrough-backed task heads are:

Key Results

Audio Contribution Study

The audio ablation keeps the same windows and task labels, then compares input variants under the same chronological split. The script scripts/audio_ablation_and_raw_upgrade.py reuses the real task-suite windows and evaluates six variants for every task: current inputs, no audio, audio-only, alternate audio-only, audio representation replacement, and all inputs plus the alternate audio representation.

The measured single-episode result is task-specific:

Full files:

• results/audio_ablation/AUDIO_ABLATION_SUMMARY.md
• results/audio_ablation/audio_ablation_metrics.csv
• results/audio_ablation/audio_delta_summary.csv
• docs/data/audio_ablation_summary.json
• docs/assets/charts/audio_ablation_delta.svg

Neural MLP Results

The neural baseline was run locally with --include-neural for the original core task contracts using 80 epochs, hidden size 128, batch size 128, and CPU execution. It is not a foundation model result; it is a controlled nonlinear-head comparison over the same 8,546-dimensional multimodal representation.

The strongest single-episode self-supervised signal is cross-modal retrieval: motion/IMU/camera/audio features retrieve matching depth/video windows substantially better than random.

Single-Episode Diagnostics and Explorer

While waiting for broader Xperience-10M access, the repo now includes an artifact-driven diagnostics pass over the public sample episode:

• results/single_episode_diagnostics/object_labels/window_object_labels.csv exports 1,161 real window-level object-label sets from annotation.hdf5.
• results/single_episode_diagnostics/modality_ablation/ablation_metrics.csv recomputes all 96 task/modality cells, including object relevance.
• results/single_episode_diagnostics/timeline_overlay/timeline_overlay.csv aligns 2,079 existing prediction rows back to the episode timeline.
• results/single_episode_diagnostics/alignment_stress/alignment_shift_metrics.csv evaluates cross-modal retrieval under explicit time shifts.
• docs/single_episode_explorer.html is a static interactive page for inspecting window labels, objects, predictions, modality statistics, and diagnostic scores.

These are single-episode research diagnostics. They are useful for studying task definitions, feature behavior, and model errors before scaling to more episodes; they are not reported as multi-episode benchmark results.

Reproducibility Check

I re-ran the full pipeline from the local raw public sample into a temporary local workspace and compared regenerated metrics with the committed artifacts. The baseline metrics, task metrics, feature manifest, and available modality manifest matched exactly after float normalization.

See notes/reproducibility_audit.md for the commands and verification evidence.

Why Some Scores Are Low

The task suite intentionally uses a chronological split:

first 70% of the episode -> train
last 30% of the episode  -> test

The test segment contains some action/subtask labels never seen during training. Timeline and next-action classifiers therefore expose the core limitation of single-episode learning instead of hiding it behind random splits.

Modalities Used

The current public-sample pipeline uses:

• hand/body mocap joints and contact labels,
• camera translation and rotation,
• IMU acceleration and gyroscope traces,
• depth confidence features,
• six video streams,
• audio from the sample MP4 stream,
• caption/object/interaction text features,
• SLAM point-cloud summary features,
• calibration parameters.

The full technical source manifest is stored in results/episode_task_suite/feature_manifest.json.

Data Notice

Xperience-10M data belongs to its original authors and is subject to the official Ropedia dataset license and access terms. This repo contains code and derived experiment artifacts only; it does not redistribute the raw videos or raw annotation dataset.