Publish Xperience-10M task-suite derived artifacts

PROJECT_README.md

@@ -219,9 +219,16 @@ pipeline over Xperience-10M. The important separation is:
 - adapter-required Xperience-10M sensor inputs: depth, pose/SLAM, hand/body
   mocap, contacts, and IMU.
 
-The H20 smoke test validates the adapter-required side first, using real
-Xperience-10M sample data from ModelScope and real action labels. It does not
-download or fine-tune the 30B Qwen3-Omni weights yet.
+The H20 work now has two separate evidence levels:
+
+- an adapter-side smoke test over one Xperience-10M sample episode, useful for
+  checking sensor feature extraction and label plumbing,
+- a technical Qwen3-Omni LoRA smoke run that loaded the local
+  `Qwen/Qwen3-Omni-30B-A3B-Instruct` weights and trained LoRA parameters on
+  128 windows from the single locally available episode.
+
+Neither is a 32-episode result. The full pilot is still gated on raw
+Xperience-10M access and a held-out episode split.
 
 ```bash
 python scripts/omni/build_episode_manifest.py \
@@ -251,7 +258,7 @@ Verified H20 run:
 | Split | single-episode chronological |
 | Feature dim | 4,262 |
 | Adapter soft-token blocks | 11 |
-| Qwen3-Omni weights loaded | no |
+| Qwen3-Omni weights loaded | adapter smoke: no; LoRA smoke: yes |
 | Result | 0.0000 macro-F1, expected for this single-episode chronological smoke split |
 
 The zero score is not treated as a model claim. It is a useful signal that this
@@ -273,11 +280,12 @@ checkpoints, caches, and logs, a realistic first budget is:
 | Useful LoRA run | 64-128 | 74k-149k | Train sensor adapters plus selected Qwen3-Omni LoRA |
 | Storage-heavy run | 256+ | 297k+ | Only after download layout and checkpoint size are stable |
 
-For the next run, use **32 episodes** if ModelScope exposes enough files
-cleanly. If download structure is simple and disk remains above 800GB free,
-scale to **64 or 128 episodes**. Do not aim for 10k samples first; at the
-observed sample-equivalent size, that would become a data-management project
-before it is a modeling experiment.
+For the next run, use a **32-episode stratified pilot** through the A100 relay,
+then scale to **128 episodes** and later **512 episodes** only after the
+download, transfer, manifest, train, and held-out evaluation path is stable. 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:
 
@@ -297,6 +305,63 @@ python scripts/render_overview_figures.py
 python scripts/render_task_suite_infographic.py
 ```
 
+### 32-Episode Readiness Gate
+
+```bash
+python scripts/omni/discover_xperience10m_sources.py \
+  --workspace /home/cy/Ropedia/ropedia-episode-task-suite \
+  --data-root /home/cy/Ropedia/modelscope_data \
+  --output results/omni_finetune/source_discovery.json \
+  --report-output results/omni_finetune/DATA_BLOCKER_REPORT.md
+```
+
+Current status in this repo:
+
+- local_valid_episodes: 1 (degraded-valid: annotation + fisheye_cam0.mp4)
+- local_complete_episodes: 0
+- ready_for_32_episode_pilot: false
+- A100 Hugging Face relay: active watcher, polling gated access every 15 minutes
+- planned 32-episode pilot: stratified across 32 top-level session UUIDs
+- HF full dataset blocker: `ropedia-ai/xperience-10m` returns 403 pending review
+- source_discovery: `results/omni_finetune/source_discovery.json`
+- blocker_report: `results/omni_finetune/DATA_BLOCKER_REPORT.md`
+- relay_status: `results/omni_finetune/A100_HF_RELAY_STATUS.md`
+
+Current H20-sourced evidence files in this repo:
+
+- `results/omni_finetune/episode_manifest.json`
+- `results/omni_finetune/dataset_manifest.json`
+- `results/omni_finetune/training_metadata.json`
+- `results/omni_finetune/metrics.json`
+- `results/omni_finetune/progress.jsonl`
+- `results/omni_finetune/RUN_REPORT.md`
+- `results/omni_finetune/DATA_BLOCKER_REPORT.md`
+- `results/omni_finetune/A100_HF_RELAY_STATUS.md`
+
+Use this gate before scheduling any 32-episode full fine-tune run.
+
+For the A100 Hugging Face relay, the 32-episode pilot should use stratified
+selection, not the first 32 paths in repository order. The current relay script
+scans 64 top-level session UUIDs, filters for complete leaf episodes, excludes
+`visualization.rrd`, applies a `0.25 GB` minimum episode size, and selects 32
+episodes from 32 different session UUIDs. This is still a pilot subset, but it
+is materially better for generalization checks than adjacent episodes from the
+same recording session.
+
+### Uploading the pilot Qwen3-Omni LoRA
+
+A prepared upload package is available at `results/omni_finetune/hf_upload`.
+
+```bash
+python3 scripts/omni/upload_qwen3_omni_lora_to_hf.py \
+  --repo-id cy0307/ropedia-qwen3-omni-lora-smoke \
+  --source-dir results/omni_finetune/hf_upload \
+  --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.
+
 ## Minimal 12-Task Architectures
 
 These are deliberately minimal baselines. They are useful because every

README.md

@@ -26,6 +26,13 @@ This dataset repo contains the derived evidence layer for the public Xperience-1
 
 It does **not** contain raw Xperience-10M videos or raw `annotation.hdf5`. Download raw data only from the official Ropedia / Hugging Face sources and follow their terms.
 
+Current scale-up status: the full `ropedia-ai/xperience-10m` Hugging Face
+dataset is still gated for this account. The A100 relay has been configured to
+poll access, download a 32-episode stratified pilot subset after approval,
+validate it, transfer it to H20, and run the readiness gate. Until that
+completes, the committed Qwen3-Omni artifacts remain smoke/debug evidence, not
+real 32-episode held-out metrics.
+
 ## Why This Repo Exists
 
 This is the reviewable half of the project. You can inspect the task outputs, compare the committed metrics, and understand the single-episode limitations without downloading the raw videos first.
@@ -73,6 +80,18 @@ The artifacts validate one public sample episode:
 
 For research claims, rerun the same scripts over many episodes and evaluate on held-out episodes.
 
+## Pending 32-Episode Pilot
+
+| Item | Value |
+| --- | --- |
+| Selection strategy | stratified round-robin across top-level session UUIDs |
+| Candidate scan | first 64 top-level session UUIDs |
+| Valid complete candidates | 680 |
+| Selected pilot episodes | 32 from 32 session UUIDs |
+| Estimated raw subset | about 72.0 GB |
+| Excluded file type | `visualization.rrd` |
+| Blocker | HF gated dataset approval pending |
+
 ![12-task infographic](assets/task_suite_infographic.png)
 
 ![Verified episode pipeline](assets/pipeline_diagram.png)

docs/data/summary_metrics.json

@@ -1,4 +1,19 @@
 {
+  "omni_relay": {
+    "status": "pending_huggingface_gated_access",
+    "dataset": "ropedia-ai/xperience-10m",
+    "relay_server": "ANGEL-A100-80Gx4",
+    "training_server": "ANGEL-H20-96GX8",
+    "selection_strategy": "stratified_round_robin_by_top_level_session",
+    "target_episodes": 32,
+    "selected_sessions": 32,
+    "candidate_scan_top_level_sessions": 64,
+    "valid_candidates": 680,
+    "estimated_bytes": 72031620552,
+    "exclude": ["visualization.rrd"],
+    "blocker": "Hugging Face returns 403 pending review for the full Xperience-10M gated dataset.",
+    "claim_boundary": "No real 32-episode fine-tune is claimed until the watcher downloads data, transfers it to H20, and the held-out evaluation runs."
+  },
   "models": {
     "motion_action": {
       "accuracy": 0.9828178694158075,
@@ -389,4 +404,4 @@
       "dim": 117
     }
   ]
-}
+}

docs/index.html

@@ -657,7 +657,7 @@
       <div class="wrap">
         <div class="section-head">
           <h2>Where the evidence lives.</h2>
-          <p>Metrics, predictions, confusion matrices, manifests, model weights, and derived window artifacts are committed so the repo is reviewable before rerunning anything.</p>
+          <p>Metrics, predictions, confusion matrices, manifests, lightweight model weights, and derived window artifacts are committed so the repo is reviewable before rerunning anything. Raw Xperience-10M data and Qwen weights are not redistributed.</p>
         </div>
         <div class="artifact-grid">
           <article class="artifact"><h3>Task-suite report</h3><p>One JSON file with every task metric and split detail.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/blob/main/results/episode_task_suite/summary_report.json">summary_report.json</a></article>
@@ -669,11 +669,28 @@
           <article class="artifact"><h3>Hugging Face Space</h3><p>The same dashboard packaged as a public static Space.</p><a href="https://huggingface.co/spaces/cy0307/ropedia-episode-task-suite">cy0307/ropedia-episode-task-suite</a></article>
           <article class="artifact"><h3>Derived HF artifacts</h3><p>Metrics, predictions, docs, and lightweight derived files without raw Xperience-10M video/data redistribution.</p><a href="https://huggingface.co/datasets/cy0307/ropedia-episode-task-suite-artifacts">dataset repo</a></article>
           <article class="artifact"><h3>HF baseline models</h3><p>Minimal NumPy softmax and ridge baseline weights with model card and architecture diagrams.</p><a href="https://huggingface.co/cy0307/ropedia-minimal-task-baselines">model repo</a></article>
+          <article class="artifact"><h3>A100 HF relay status</h3><p>HF full-dataset access is pending; an A100 watcher is ready to download a 32-session stratified pilot and transfer it to H20 once approved.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/blob/main/results/omni_finetune/A100_HF_RELAY_STATUS.md">A100_HF_RELAY_STATUS.md</a></article>
+          <article class="artifact"><h3>Qwen3-Omni readiness artifacts</h3><p>Manifests, metadata, metrics, and progress logs from the current smoke/evidence run. No real 32-episode metric is claimed yet.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/blob/main/results/omni_finetune/episode_manifest.json">episode_manifest.json</a></article>
+          <article class="artifact"><h3>32-episode data gate</h3><p>The readiness gate remains the source of truth before any full pilot training claim.</p><a href="https://github.com/ChaoYue0307/ropedia-episode-task-suite/blob/main/results/omni_finetune/DATA_BLOCKER_REPORT.md">DATA_BLOCKER_REPORT.md</a></article>
           <article class="artifact"><h3>HF collection</h3><p>Space, artifacts, and model baselines grouped into one public project collection.</p><a href="https://huggingface.co/collections/cy0307/ropedia-episode-task-suite">collection</a></article>
         </div>
       </div>
     </section>
 
+    <section id="omni-relay">
+      <div class="wrap">
+        <div class="section-head">
+          <h2>Qwen3-Omni pilot is approval-ready.</h2>
+          <p>The full Xperience-10M Hugging Face dataset is gated. While access is pending, the A100 relay has already selected a 32-episode pilot across 32 different session UUIDs and will continue automatically after approval.</p>
+        </div>
+        <div class="artifact-grid">
+          <article class="artifact"><h3>Selection</h3><p>Stratified round-robin over 64 top-level sessions; 680 complete candidates scanned; 32 sessions selected.</p></article>
+          <article class="artifact"><h3>Transfer</h3><p>A100 downloads from Hugging Face, excludes visualization.rrd, validates files, then rsyncs to H20.</p></article>
+          <article class="artifact"><h3>Boundary</h3><p>The current LoRA artifact is a smoke/pilot checkpoint. A real 32-episode result requires the watcher to finish and held-out evaluation to run.</p></article>
+        </div>
+      </div>
+    </section>
+
     <section id="run">
       <div class="wrap">
         <div class="section-head">

results/omni_finetune/A100_HF_RELAY_STATUS.md

@@ -0,0 +1,66 @@
+# A100 Hugging Face Relay Status
+
+Current blocker: Hugging Face access to `ropedia-ai/xperience-10m` is still
+pending approval from the dataset authors.
+
+Verified:
+
+- A100 SSH alias: `ANGEL-A100-80Gx4`
+- H20 SSH alias: `ANGEL-H20-96GX8`
+- A100 can reach `huggingface.co`
+- A100 staging path: `/mnt/kgc/chaoyue/xperience10m_hf_staging`
+- A100 HF cache path: `/mnt/kgc/chaoyue/hf_cache`
+- A100 HF token path: `/mnt/kgc/chaoyue/hf_home/token`
+- A100 has enough free space for the 32-episode stratified pilot subset
+- Direct A100 -> H20 SSH/rsync works with `~/.ssh/xperience10m_h20_transfer`
+
+Dry-run selection:
+
+- Dataset: `ropedia-ai/xperience-10m`
+- Target: 32 complete leaf episodes
+- Strategy: stratified round-robin across top-level session UUIDs
+- Candidate scan: first 64 top-level session UUIDs
+- Valid candidates: `680`
+- Selected sessions: `32`
+- Minimum episode size: `0.25 GB`
+- Estimated bytes: `72,031,620,552`
+- Excludes: `visualization.rrd`
+
+Background watcher:
+
+```bash
+ps -p $(cat /mnt/kgc/chaoyue/xperience10m_logs/hf_access_watch.pid) -o pid,etime,cmd
+tail -f /mnt/kgc/chaoyue/xperience10m_logs/hf_access_watch.out
+tail -f /mnt/kgc/chaoyue/xperience10m_logs/hf_access_watch.jsonl
+```
+
+Watcher behavior:
+
+1. Polls one gated HF file every 15 minutes.
+2. When access changes from 403 pending to approved, downloads 32 complete episodes from 32 different session UUIDs.
+3. Validates the staged files.
+4. Transfers staged data to `/home/cy/Ropedia/modelscope_data` on H20.
+5. Runs the H20 readiness gate.
+
+Manual restart on A100:
+
+```bash
+HF_HOME=/mnt/kgc/chaoyue/hf_home \
+HF_HUB_CACHE=/mnt/kgc/chaoyue/hf_cache \
+nohup python3 /mnt/kgc/chaoyue/xperience10m_tools/watch_hf_access_and_stage_xperience10m.py \
+  --poll-seconds 900 \
+  --target-episodes 32 \
+  --max-top-level 64 \
+  --workers 8 \
+  --reserve-gb 250 \
+  --selection-strategy stratified \
+  --min-episode-gb 0.25 \
+  --run-transfer \
+  > /mnt/kgc/chaoyue/xperience10m_logs/hf_access_watch.out 2>&1 &
+```
+
+Stop watcher:
+
+```bash
+kill $(cat /mnt/kgc/chaoyue/xperience10m_logs/hf_access_watch.pid)
+```

results/omni_finetune/HF_UPLOAD.md

@@ -0,0 +1,26 @@
+# Hugging Face Upload (Model Artifact)
+
+The current checkpoint available in this repo is the pilot run:
+
+- `results/omni_finetune/adapter_lora/` (`xperience10m_qwen3_omni_32ep_lora`)
+- Train windows: `128`
+- Processes: `8`
+- JSON output path: `results/omni_finetune/predictions_eval.jsonl`
+
+Upload target layout:
+- Source directory: `results/omni_finetune/hf_upload/`
+- Upload script: `scripts/omni/upload_qwen3_omni_lora_to_hf.py`
+
+Run (when network to huggingface.co is available):
+
+```bash
+HF_TOKEN=<your_token> python3 scripts/omni/upload_qwen3_omni_lora_to_hf.py \
+  --repo-id cy0307/ropedia-qwen3-omni-lora-smoke \
+  --source-dir results/omni_finetune/hf_upload \
+  --message "Upload Xperience-10M Qwen3-Omni pilot LoRA"
+```
+
+If you want the repo private, add `--private`.
+
+Note: this is a pilot artifact. The full 32-episode LoRA run is still blocked by
+data availability; this artifact should not be reported as a full-scale result.

scripts/omni/stage_xperience10m_from_hf.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+"""Stage a bounded Xperience-10M episode subset from Hugging Face.
+
+This downloads leaf episode folders such as:
+
+    <session_uuid>/ep1/{annotation.hdf5,fisheye_cam0.mp4,...}
+
+It intentionally excludes visualization.rrd and writes a manifest that can be
+used before transferring data to the H20 training server.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+
+from huggingface_hub import HfApi, hf_hub_download
+
+
+REQUIRED_FILES = [
+    "annotation.hdf5",
+    "fisheye_cam0.mp4",
+    "fisheye_cam1.mp4",
+    "fisheye_cam2.mp4",
+    "fisheye_cam3.mp4",
+    "stereo_left.mp4",
+    "stereo_right.mp4",
+]
+
+
+@dataclass
+class Episode:
+    episode_id: str
+    prefix: str
+    files: dict[str, int]
+
+    @property
+    def session_id(self) -> str:
+        return self.prefix.split("/", 1)[0]
+
+    @property
+    def leaf_episode(self) -> str:
+        parts = self.prefix.split("/", 1)
+        return parts[1] if len(parts) > 1 else "."
+
+    @property
+    def missing(self) -> list[str]:
+        return [name for name in REQUIRED_FILES if name not in self.files]
+
+    @property
+    def is_complete(self) -> bool:
+        return not self.missing
+
+    @property
+    def is_degraded_valid(self) -> bool:
+        return "annotation.hdf5" in self.files and "fisheye_cam0.mp4" in self.files
+
+    @property
+    def bytes(self) -> int:
+        return sum(self.files.values())
+
+    def as_dict(self) -> dict:
+        return {
+            "episode_id": self.episode_id,
+            "prefix": self.prefix,
+            "session_id": self.session_id,
+            "leaf_episode": self.leaf_episode,
+            "files": self.files,
+            "missing": self.missing,
+            "is_complete": self.is_complete,
+            "is_degraded_valid": self.is_degraded_valid,
+            "bytes": self.bytes,
+        }
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo-id", default="ropedia-ai/xperience-10m")
+    parser.add_argument("--local-dir", type=Path, required=True)
+    parser.add_argument("--target-episodes", type=int, default=32)
+    parser.add_argument("--max-top-level", type=int, default=64)
+    parser.add_argument("--workers", type=int, default=6)
+    parser.add_argument("--reserve-gb", type=float, default=100.0)
+    parser.add_argument("--prefer-complete", action="store_true", default=True)
+    parser.add_argument("--allow-degraded", action="store_true")
+    parser.add_argument("--min-episode-gb", type=float, default=0.25)
+    parser.add_argument(
+        "--selection-strategy",
+        choices=["stratified", "first"],
+        default="stratified",
+        help="stratified spreads episodes across top-level session UUIDs.",
+    )
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--manifest-name", default="stage_manifest.json")
+    return parser.parse_args()
+
+
+def file_size(item) -> int:
+    value = getattr(item, "size", None)
+    return int(value) if value is not None else 0
+
+
+def natural_episode_key(episode: Episode) -> tuple[str, int, str]:
+    match = re.fullmatch(r"ep(\d+)", episode.leaf_episode)
+    numeric = int(match.group(1)) if match else 10**9
+    return episode.session_id, numeric, episode.leaf_episode
+
+
+def collect_candidates(api: HfApi, repo_id: str, max_top_level: int) -> list[Episode]:
+    candidates: list[Episode] = []
+    top_count = 0
+    for top in api.list_repo_tree(repo_id, repo_type="dataset", recursive=False):
+        top_path = getattr(top, "path", "")
+        if not top_path:
+            continue
+        top_count += 1
+        grouped: dict[str, dict[str, int]] = {}
+        for item in api.list_repo_tree(repo_id, repo_type="dataset", path_in_repo=top_path, recursive=True):
+            path = getattr(item, "path", "")
+            name = Path(path).name
+            if name not in REQUIRED_FILES:
+                continue
+            prefix = Path(path).parent.as_posix()
+            grouped.setdefault(prefix, {})[name] = file_size(item)
+
+        for prefix, files in sorted(grouped.items()):
+            episode_id = prefix.replace("/", "__")
+            episode = Episode(episode_id=episode_id, prefix=prefix, files=files)
+            if episode.is_degraded_valid:
+                candidates.append(episode)
+
+        if top_count >= max_top_level:
+            break
+    return sorted(candidates, key=natural_episode_key)
+
+
+def round_robin_by_session(episodes: list[Episode], target: int) -> list[Episode]:
+    grouped: dict[str, list[Episode]] = {}
+    for episode in sorted(episodes, key=natural_episode_key):
+        grouped.setdefault(episode.session_id, []).append(episode)
+
+    selected: list[Episode] = []
+    session_ids = sorted(grouped)
+    depth = 0
+    while len(selected) < target:
+        added = False
+        for session_id in session_ids:
+            bucket = grouped[session_id]
+            if depth < len(bucket):
+                selected.append(bucket[depth])
+                added = True
+                if len(selected) >= target:
+                    break
+        if not added:
+            break
+        depth += 1
+    return selected
+
+
+def select_episodes(
+    candidates: list[Episode],
+    target: int,
+    prefer_complete: bool,
+    allow_degraded: bool,
+    min_episode_bytes: int,
+    selection_strategy: str,
+) -> list[Episode]:
+    eligible = [ep for ep in candidates if ep.bytes >= min_episode_bytes]
+    if prefer_complete and not allow_degraded:
+        complete = [ep for ep in eligible if ep.is_complete]
+        if len(complete) >= target:
+            pool = complete
+        else:
+            pool = [ep for ep in eligible if ep.is_degraded_valid]
+    else:
+        pool = [ep for ep in eligible if ep.is_degraded_valid]
+
+    if selection_strategy == "first":
+        return pool[:target]
+    return round_robin_by_session(pool, target)
+
+
+def local_file(local_dir: Path, filename: str) -> Path:
+    return local_dir / filename
+
+
+def download_one(repo_id: str, local_dir: Path, filename: str, token: str | None) -> dict:
+    path = hf_hub_download(
+        repo_id=repo_id,
+        repo_type="dataset",
+        filename=filename,
+        local_dir=str(local_dir),
+        token=token,
+    )
+    stat = Path(path).stat()
+    return {"path": filename, "local_path": path, "bytes": stat.st_size}
+
+
+def validate_selected(local_dir: Path, selected: list[Episode]) -> list[dict]:
+    records = []
+    for episode in selected:
+        files = {}
+        for name in REQUIRED_FILES:
+            path = local_file(local_dir, f"{episode.prefix}/{name}")
+            files[name] = {
+                "exists": path.exists(),
+                "bytes": path.stat().st_size if path.exists() else 0,
+            }
+        records.append(
+            {
+                **episode.as_dict(),
+                "local_files": files,
+                "local_complete": all(item["exists"] for item in files.values()),
+                "local_degraded_valid": files["annotation.hdf5"]["exists"]
+                and files["fisheye_cam0.mp4"]["exists"],
+            }
+        )
+    return records
+
+
+def write_manifest(path: Path, payload: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+
+def main() -> int:
+    args = parse_args()
+    token = os.environ.get("HF_TOKEN")
+    local_dir = args.local_dir.expanduser().resolve()
+    local_dir.mkdir(parents=True, exist_ok=True)
+
+    api = HfApi(token=token)
+    candidates = collect_candidates(api, args.repo_id, args.max_top_level)
+    min_episode_bytes = int(args.min_episode_gb * 1024**3)
+    selected = select_episodes(
+        candidates,
+        args.target_episodes,
+        args.prefer_complete,
+        args.allow_degraded,
+        min_episode_bytes,
+        args.selection_strategy,
+    )
+    required_bytes = sum(ep.bytes for ep in selected)
+    free_bytes = shutil.disk_usage(local_dir).free
+    reserve_bytes = int(args.reserve_gb * 1024**3)
+
+    payload = {
+        "repo_id": args.repo_id,
+        "local_dir": str(local_dir),
+        "target_episodes": args.target_episodes,
+        "max_top_level": args.max_top_level,
+        "selection_strategy": args.selection_strategy,
+        "min_episode_bytes": min_episode_bytes,
+        "allow_degraded": args.allow_degraded,
+        "num_candidates": len(candidates),
+        "num_selected": len(selected),
+        "num_selected_sessions": len({ep.session_id for ep in selected}),
+        "required_bytes": required_bytes,
+        "free_bytes_before": free_bytes,
+        "reserve_bytes": reserve_bytes,
+        "dry_run": args.dry_run,
+        "selected": [ep.as_dict() for ep in selected],
+    }
+    write_manifest(local_dir / args.manifest_name, payload)
+
+    if len(selected) < args.target_episodes:
+        raise SystemExit(f"only found {len(selected)} valid episodes, target is {args.target_episodes}")
+    if free_bytes - required_bytes < reserve_bytes:
+        raise SystemExit(
+            f"not enough free space: need {required_bytes} bytes plus reserve {reserve_bytes}, "
+            f"free {free_bytes}"
+        )
+    if args.dry_run:
+        print(json.dumps(payload, indent=2))
+        return 0
+
+    filenames = [f"{ep.prefix}/{name}" for ep in selected for name in REQUIRED_FILES if name in ep.files]
+    results = []
+    with ThreadPoolExecutor(max_workers=max(1, args.workers)) as pool:
+        futures = [pool.submit(download_one, args.repo_id, local_dir, filename, token) for filename in filenames]
+        for idx, future in enumerate(as_completed(futures), start=1):
+            item = future.result()
+            results.append(item)
+            print(f"[{idx}/{len(futures)}] {item['path']} {item['bytes']}")
+
+    final_payload = {
+        **payload,
+        "downloaded_files": sorted(results, key=lambda item: item["path"]),
+        "validated": validate_selected(local_dir, selected),
+        "free_bytes_after": shutil.disk_usage(local_dir).free,
+    }
+    write_manifest(local_dir / args.manifest_name, final_payload)
+    print(f"Wrote {local_dir / args.manifest_name}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/omni/transfer_xperience10m_a100_to_h20.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+A100_STAGE_DIR="${A100_STAGE_DIR:-/mnt/kgc/chaoyue/xperience10m_hf_staging/}"
+H20_HOST="${H20_HOST:-cy@47.100.122.133}"
+H20_DATA_ROOT="${H20_DATA_ROOT:-/home/cy/Ropedia/modelscope_data/}"
+SSH_KEY="${SSH_KEY:-$HOME/.ssh/xperience10m_h20_transfer}"
+
+rsync -avP --partial --append-verify \
+  --exclude "visualization.rrd" \
+  -e "ssh -i ${SSH_KEY} -o BatchMode=yes -o StrictHostKeyChecking=accept-new" \
+  "${A100_STAGE_DIR}" \
+  "${H20_HOST}:${H20_DATA_ROOT}"
+
+ssh -i "${SSH_KEY}" -o BatchMode=yes -o StrictHostKeyChecking=accept-new "${H20_HOST}" \
+  "cd /home/cy/Ropedia/ropedia-episode-task-suite && python3 scripts/omni/discover_xperience10m_sources.py --workspace /home/cy/Ropedia/ropedia-episode-task-suite --data-root /home/cy/Ropedia/modelscope_data --output results/omni_finetune/source_discovery.json --report-output results/omni_finetune/DATA_BLOCKER_REPORT.md"

scripts/omni/watch_hf_access_and_stage_xperience10m.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Poll Hugging Face gated access, then stage and optionally transfer Xperience-10M.
+
+This is intended for an A100 relay server that can reach Hugging Face while H20
+cannot. It does a cheap HEAD request against one gated file. When access is
+approved, it starts the selective 32-episode staging script and then can launch
+the A100->H20 transfer script.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+from huggingface_hub import hf_hub_url
+from huggingface_hub.file_download import get_hf_file_metadata
+
+
+DEFAULT_PROBE_FILE = "003dcaf0-edba-4787-ada0-187d2748f684/ep1/fisheye_cam0.mp4"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo-id", default="ropedia-ai/xperience-10m")
+    parser.add_argument("--probe-file", default=DEFAULT_PROBE_FILE)
+    parser.add_argument("--local-dir", type=Path, default=Path("/mnt/kgc/chaoyue/xperience10m_hf_staging"))
+    parser.add_argument("--stage-script", type=Path, default=Path("/mnt/kgc/chaoyue/xperience10m_tools/stage_xperience10m_from_hf.py"))
+    parser.add_argument("--transfer-script", type=Path, default=Path("/mnt/kgc/chaoyue/xperience10m_tools/transfer_xperience10m_a100_to_h20.sh"))
+    parser.add_argument("--log-dir", type=Path, default=Path("/mnt/kgc/chaoyue/xperience10m_logs"))
+    parser.add_argument("--target-episodes", type=int, default=32)
+    parser.add_argument("--max-top-level", type=int, default=64)
+    parser.add_argument("--workers", type=int, default=8)
+    parser.add_argument("--reserve-gb", type=float, default=250)
+    parser.add_argument("--min-episode-gb", type=float, default=0.25)
+    parser.add_argument("--selection-strategy", default="stratified", choices=["stratified", "first"])
+    parser.add_argument("--poll-seconds", type=int, default=900)
+    parser.add_argument("--max-attempts", type=int, default=0, help="0 means run until approved.")
+    parser.add_argument("--run-transfer", action="store_true")
+    return parser.parse_args()
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def read_token() -> str:
+    token = os.environ.get("HF_TOKEN", "").strip()
+    if token:
+        return token
+
+    hf_home = Path(os.environ.get("HF_HOME", "~/.cache/huggingface")).expanduser()
+    token_path = hf_home / "token"
+    if token_path.exists():
+        return token_path.read_text(encoding="utf-8").strip()
+    return ""
+
+
+def append_jsonl(path: Path, record: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(record, sort_keys=True) + "\n")
+
+
+def check_access(repo_id: str, probe_file: str, token: str) -> tuple[bool, dict]:
+    if not token:
+        return False, {"status": "missing_token"}
+
+    url = hf_hub_url(repo_id=repo_id, filename=probe_file, repo_type="dataset")
+    try:
+        metadata = get_hf_file_metadata(url, token=token, timeout=30)
+        return True, {
+            "status": "approved",
+            "etag": metadata.etag,
+            "size": metadata.size,
+        }
+    except Exception as exc:
+        response = getattr(exc, "response", None)
+        status_code = getattr(response, "status_code", None)
+        return False, {
+            "status": "not_approved" if status_code in (401, 403) else "check_error",
+            "http_status": status_code,
+            "error_type": type(exc).__name__,
+            "error": str(exc),
+        }
+
+
+def run_logged(cmd: list[str], log_file: Path, env: dict[str, str]) -> int:
+    log_file.parent.mkdir(parents=True, exist_ok=True)
+    with log_file.open("a", encoding="utf-8") as handle:
+        handle.write(f"\n[{utc_now()}] RUN {' '.join(cmd)}\n")
+        handle.flush()
+        proc = subprocess.run(cmd, stdout=handle, stderr=subprocess.STDOUT, env=env)
+        handle.write(f"[{utc_now()}] EXIT {proc.returncode}\n")
+        return int(proc.returncode)
+
+
+def main() -> int:
+    args = parse_args()
+    args.log_dir.mkdir(parents=True, exist_ok=True)
+    status_path = args.log_dir / "hf_access_watch.jsonl"
+    token = read_token()
+
+    env = os.environ.copy()
+    if token:
+        env["HF_TOKEN"] = token
+    env.setdefault("HF_HOME", "/mnt/kgc/chaoyue/hf_home")
+    env.setdefault("HF_HUB_CACHE", "/mnt/kgc/chaoyue/hf_cache")
+
+    attempt = 0
+    while True:
+        attempt += 1
+        approved, detail = check_access(args.repo_id, args.probe_file, token)
+        record = {"time": utc_now(), "attempt": attempt, "approved": approved, **detail}
+        append_jsonl(status_path, record)
+        print(json.dumps(record, sort_keys=True), flush=True)
+
+        if approved:
+            break
+        if args.max_attempts and attempt >= args.max_attempts:
+            return 2
+        time.sleep(max(60, args.poll_seconds))
+
+    stage_cmd = [
+        "python3",
+        str(args.stage_script),
+        "--local-dir",
+        str(args.local_dir),
+        "--target-episodes",
+        str(args.target_episodes),
+        "--max-top-level",
+        str(args.max_top_level),
+        "--workers",
+        str(args.workers),
+        "--reserve-gb",
+        str(args.reserve_gb),
+        "--min-episode-gb",
+        str(args.min_episode_gb),
+        "--selection-strategy",
+        args.selection_strategy,
+    ]
+    stage_rc = run_logged(stage_cmd, args.log_dir / "stage_32ep.log", env)
+    append_jsonl(status_path, {"time": utc_now(), "stage_exit": stage_rc})
+    if stage_rc != 0:
+        return stage_rc
+
+    if args.run_transfer:
+        transfer_rc = run_logged([str(args.transfer_script)], args.log_dir / "transfer_to_h20.log", env)
+        append_jsonl(status_path, {"time": utc_now(), "transfer_exit": transfer_rc})
+        return transfer_rc
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())