create read-only mc eval app

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,14 @@
 ---
-title: Wm Evals
-emoji: 🐢
-colorFrom: green
-colorTo: blue
+title: Minecraft LM-Arena Baseline
+emoji: 🎮
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: 6.9.0
-app_file: app.py
-pinned: false
+python_version: 3.10
+app_file: arena/app.py
+fullWidth: true
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Minecraft LM-Arena baseline for paired Minecraft video
+evaluation.

arena/README.md

@@ -0,0 +1,100 @@
+# Minecraft LM-Arena Baseline
+
+This app is a small local Gradio baseline for reviewing paired Minecraft videos from `data_subset/`.
+It follows the current dataset shape first and does not add physics or causality tags yet.
+
+## Inferred dataset format
+
+- Each scenario folder in `data_subset/` contains 10 cases: `01` through `10`.
+- Each case is paired by exact case id inside one scenario folder.
+- The pairing used here is:
+  - left: `{case_id}.mp4`
+  - right: `{case_id}_wangame.mp4`
+  - actions: `{case_id}_action.npy`
+  - preview still: `{case_id}.jpg`
+- `ptlflow/run_all_eval.py` and `ptlflow/visualize_results.py` both treat `{id}.mp4` as the reference / GT video and `{id}_wangame.mp4` as the generated WanGame output. The app follows that same convention.
+
+## App behavior
+
+- Loads one paired sample at a time from `arena/manifest.json`.
+- Shows reference video on the left and WanGame output on the right.
+- Displays a formatted action summary derived from `*_action.npy`.
+- Collects three votes:
+  - action following
+  - visual quality
+  - temporal consistency
+- Each vote is `Left better`, `Right better`, or `Tie / unsure`.
+- Includes a `Tie all / unsure` shortcut.
+- Includes a manual `Flag artifact` flow:
+  - pause the player
+  - read the native video timestamp
+  - type seconds into the artifact field
+  - click `Flag artifact`
+- Saves annotations to `arena/results/annotations.jsonl`.
+
+## Files
+
+- `app.py`: Gradio UI
+- `build_manifest.py`: dataset scanner and manifest writer
+- `dataset.py`: manifest loading and path resolution
+- `actions.py`: action parsing and formatting
+- `result_logger.py`: JSONL logging
+
+## How to run
+
+Install the minimal dependencies in your Python environment:
+
+```bash
+python -m pip install gradio numpy
+```
+
+Build or rebuild the manifest:
+
+```bash
+python arena/build_manifest.py
+```
+
+Run the app:
+
+```bash
+python arena/app.py
+```
+
+Optional flags:
+
+```bash
+python arena/app.py --rebuild-manifest --port 7861
+```
+
+Read-only mode for public demos:
+
+```bash
+python arena/app.py --disable-writes
+```
+
+Or with an environment variable:
+
+```bash
+ARENA_DISABLE_WRITES=1 python arena/app.py
+```
+
+## Limitations and ambiguities
+
+- The current dataset naturally supports a fixed reference-vs-WanGame A/B pair, not a blinded model-vs-model arena.
+- `.jpg` files look like aligned preview stills, but none of the relevant `ptlflow` evaluation scripts consume them. The app surfaces them only as metadata.
+- `*_action.npy` contains `keyboard` `(T, 6)` and `mouse` `(T, 2)` arrays. The keyboard order is inferred from `ptlflow/action_flow_score.py` as `[W, S, A, D, left, right]`, and mouse order as `[pitch, yaw]`.
+- In this subset, the `left` and `right` keyboard channels exist in the format but appear unused.
+- Gradio’s stock video components do not provide a reliable cross-player live timestamp callback, so artifact flagging uses a documented manual timestamp fallback.
+- The two video players are independent and not synchronized.
+- If you deploy to Hugging Face Spaces, free storage is ephemeral. Local JSONL annotations are fine for local runs, but not a durable collection backend for a public deployment.
+
+## If physics / causality tags are added later
+
+- Extend the JSONL schema in `result_logger.py` with new tag fields.
+- Add new controls in `app.py`; the manifest format does not need to change for simple extra labels.
+- If the future setup compares multiple generated videos instead of reference vs generated, change the manifest schema first so samples can carry arbitrary candidate lists instead of the current fixed left/right pair.
+
+## Spaces note
+
+- `app.py` reads `GRADIO_SERVER_NAME` and `GRADIO_SERVER_PORT`, so it is safe to run on Hugging Face Spaces.
+- If you want the published app to be review-only for now, set `ARENA_DISABLE_WRITES=1`.

arena/__init__.py

@@ -0,0 +1 @@
+"""Baseline human-eval app for Minecraft video comparisons."""

arena/actions.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+
+KEY_NAMES = ["W", "S", "A", "D", "left", "right"]
+
+
+@dataclass(frozen=True)
+class ActionSegment:
+    start_frame: int
+    end_frame: int
+    label: str
+
+
+@dataclass(frozen=True)
+class ActionSummary:
+    n_frames: int
+    fps: float | None
+    duration_s: float | None
+    used_keys: list[str]
+    mouse_pitch_values: list[float]
+    mouse_yaw_values: list[float]
+    control_mode: str
+    segments: list[ActionSegment]
+    markdown: str
+
+
+def load_action_file(action_path: str | Path) -> tuple[np.ndarray, np.ndarray]:
+    payload = np.load(Path(action_path), allow_pickle=True).item()
+    if not isinstance(payload, dict):
+        raise ValueError(f"Expected dict payload in {action_path}, found {type(payload)!r}")
+    if "keyboard" not in payload or "mouse" not in payload:
+        raise ValueError(f"Missing keyboard/mouse arrays in {action_path}")
+
+    keyboard = np.asarray(payload["keyboard"], dtype=np.float32)
+    mouse = np.asarray(payload["mouse"], dtype=np.float32)
+    if keyboard.ndim != 2 or keyboard.shape[1] != len(KEY_NAMES):
+        raise ValueError(f"Unexpected keyboard shape for {action_path}: {keyboard.shape}")
+    if mouse.ndim != 2 or mouse.shape[1] < 2:
+        raise ValueError(f"Unexpected mouse shape for {action_path}: {mouse.shape}")
+    if keyboard.shape[0] != mouse.shape[0]:
+        raise ValueError(
+            f"Keyboard/mouse length mismatch for {action_path}: "
+            f"{keyboard.shape[0]} vs {mouse.shape[0]}"
+        )
+
+    return keyboard, mouse[:, :2]
+
+
+def build_action_summary(
+    action_path: str | Path,
+    fps: float | None = None,
+    max_segments: int = 18,
+) -> ActionSummary:
+    keyboard, mouse = load_action_file(action_path)
+    n_frames = int(keyboard.shape[0])
+    duration_s = (n_frames / fps) if fps else None
+
+    used_keys = [KEY_NAMES[i] for i in range(len(KEY_NAMES)) if np.any(keyboard[:, i] > 0.5)]
+    mouse_pitch_values = _rounded_unique(mouse[:, 0])
+    mouse_yaw_values = _rounded_unique(mouse[:, 1])
+    control_mode = _infer_control_mode(keyboard, mouse)
+    segments = _collapse_segments(keyboard, mouse)
+    markdown = _format_markdown(
+        n_frames=n_frames,
+        fps=fps,
+        duration_s=duration_s,
+        used_keys=used_keys,
+        mouse_pitch_values=mouse_pitch_values,
+        mouse_yaw_values=mouse_yaw_values,
+        control_mode=control_mode,
+        segments=segments,
+        max_segments=max_segments,
+    )
+
+    return ActionSummary(
+        n_frames=n_frames,
+        fps=fps,
+        duration_s=duration_s,
+        used_keys=used_keys,
+        mouse_pitch_values=mouse_pitch_values,
+        mouse_yaw_values=mouse_yaw_values,
+        control_mode=control_mode,
+        segments=segments,
+        markdown=markdown,
+    )
+
+
+def summary_to_manifest_dict(summary: ActionSummary) -> dict[str, Any]:
+    return {
+        "n_frames": summary.n_frames,
+        "fps": summary.fps,
+        "duration_s": summary.duration_s,
+        "used_keys": summary.used_keys,
+        "mouse_pitch_values": summary.mouse_pitch_values,
+        "mouse_yaw_values": summary.mouse_yaw_values,
+        "control_mode": summary.control_mode,
+        "segments": [asdict(segment) for segment in summary.segments],
+        "markdown": summary.markdown,
+    }
+
+
+def _rounded_unique(values: np.ndarray) -> list[float]:
+    rounded = {round(float(value), 3) for value in values.tolist()}
+    return sorted(rounded)
+
+
+def _infer_control_mode(keyboard: np.ndarray, mouse: np.ndarray) -> str:
+    has_keyboard = bool(np.any(keyboard > 0.5))
+    has_mouse = bool(np.any(np.abs(mouse) > 1e-6))
+    if has_keyboard and has_mouse:
+        return "keyboard + camera"
+    if has_keyboard:
+        return "keyboard-only"
+    if has_mouse:
+        return "camera-only"
+    return "idle / unclear"
+
+
+def _collapse_segments(keyboard: np.ndarray, mouse: np.ndarray) -> list[ActionSegment]:
+    if keyboard.shape[0] == 0:
+        return []
+
+    labels = [_describe_step(keyboard[idx], mouse[idx]) for idx in range(keyboard.shape[0])]
+    segments: list[ActionSegment] = []
+    start = 0
+    current = labels[0]
+    for idx in range(1, len(labels)):
+        if labels[idx] != current:
+            segments.append(ActionSegment(start_frame=start, end_frame=idx - 1, label=current))
+            start = idx
+            current = labels[idx]
+    segments.append(ActionSegment(start_frame=start, end_frame=len(labels) - 1, label=current))
+    return segments
+
+
+def _describe_step(keyboard_row: np.ndarray, mouse_row: np.ndarray) -> str:
+    pressed_keys = [KEY_NAMES[idx] for idx, value in enumerate(keyboard_row) if value > 0.5]
+    pitch = float(mouse_row[0]) if len(mouse_row) >= 1 else 0.0
+    yaw = float(mouse_row[1]) if len(mouse_row) >= 2 else 0.0
+    has_mouse = abs(pitch) > 1e-6 or abs(yaw) > 1e-6
+
+    key_label = "+".join(pressed_keys) if pressed_keys else ""
+    mouse_label = ""
+    if has_mouse:
+        mouse_label = f"mouse(pitch={pitch:+.1f}, yaw={yaw:+.1f})"
+
+    if key_label and mouse_label:
+        return f"{key_label} + {mouse_label}"
+    if key_label:
+        return key_label
+    if mouse_label:
+        return mouse_label
+    return "idle"
+
+
+def _format_markdown(
+    n_frames: int,
+    fps: float | None,
+    duration_s: float | None,
+    used_keys: list[str],
+    mouse_pitch_values: list[float],
+    mouse_yaw_values: list[float],
+    control_mode: str,
+    segments: list[ActionSegment],
+    max_segments: int,
+) -> str:
+    timing_bits = [f"{n_frames} action steps"]
+    if fps:
+        timing_bits.append(f"{fps:.2f} FPS")
+    if duration_s is not None:
+        timing_bits.append(f"~{duration_s:.2f}s")
+
+    lines = [
+        f"**Action summary:** {' | '.join(timing_bits)}",
+        f"**Inferred control mode:** {control_mode}",
+        f"**Keys used:** {', '.join(used_keys) if used_keys else 'none'}",
+        (
+            "**Mouse values:** "
+            f"pitch={_format_values(mouse_pitch_values)} | "
+            f"yaw={_format_values(mouse_yaw_values)}"
+        ),
+        "",
+        "**Timeline**",
+    ]
+
+    for segment in segments[:max_segments]:
+        if fps:
+            start_s = segment.start_frame / fps
+            end_s = (segment.end_frame + 1) / fps
+            prefix = f"`{start_s:.2f}s-{end_s:.2f}s`"
+        else:
+            prefix = f"`frames {segment.start_frame}-{segment.end_frame}`"
+        lines.append(f"- {prefix}: {segment.label}")
+
+    remaining = len(segments) - max_segments
+    if remaining > 0:
+        lines.append(f"- ... {remaining} more segments omitted for readability")
+
+    return "\n".join(lines)
+
+
+def _format_values(values: list[float]) -> str:
+    if not values:
+        return "[]"
+    return "[" + ", ".join(f"{value:+.1f}" for value in values) + "]"

arena/app.py

@@ -0,0 +1,437 @@
+from __future__ import annotations
+
+import argparse
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+
+try:
+    from .dataset import DatasetManifest, Sample, ensure_manifest, load_manifest
+    from .result_logger import append_annotation
+except ImportError:
+    from dataset import DatasetManifest, Sample, ensure_manifest, load_manifest
+    from result_logger import append_annotation
+
+
+VOTE_CHOICES = ["Left better", "Tie / unsure", "Right better"]
+FLAG_HELP = (
+    "No artifact flags recorded yet. Pause a player, read the native timestamp, "
+    "type it below, and click `Flag artifact`."
+)
+
+
+def build_app(
+    manifest: DatasetManifest,
+    results_dir: Path,
+    writes_enabled: bool = True,
+) -> gr.Blocks:
+    if not manifest.samples:
+        raise ValueError("Manifest contains no samples.")
+
+    first_sample = manifest.samples[0]
+    first_title = _sample_title(first_sample, 0, len(manifest.samples))
+    first_metadata = _sample_metadata(first_sample)
+    first_status = _status_message(
+        f"Loaded `{first_sample.sample_id}`. Save an annotation, then move to the next sample."
+    )
+
+    with gr.Blocks(title="Minecraft LM-Arena Baseline") as demo:
+        current_index = gr.State(0)
+        artifact_flags = gr.State([])
+
+        gr.Markdown("# Minecraft LM-Arena Baseline")
+        gr.Markdown(
+            "Left is the reference `.mp4`; right is the paired WanGame `_wangame.mp4` output. "
+            "Players are independent. The artifact button uses a manual timestamp fallback because "
+            "plain Gradio does not reliably expose live `currentTime` from both video widgets."
+        )
+        if not writes_enabled:
+            gr.Markdown(
+                "**Read-only mode:** annotation writes are disabled. "
+                "Use this for public demo review until the final eval schema is settled."
+            )
+
+        sample_title = gr.Markdown(first_title)
+        sample_metadata = gr.Markdown(first_metadata)
+
+        with gr.Row():
+            left_video = gr.Video(
+                value=str(first_sample.reference_video),
+                label=first_sample.left_label,
+            )
+            right_video = gr.Video(
+                value=str(first_sample.generated_video),
+                label=first_sample.right_label,
+            )
+
+        action_markdown = gr.Markdown(first_sample.action_markdown)
+
+        with gr.Row():
+            action_following = gr.Radio(
+                choices=VOTE_CHOICES,
+                label="Action following",
+            )
+            visual_quality = gr.Radio(
+                choices=VOTE_CHOICES,
+                label="Visual quality",
+            )
+            temporal_consistency = gr.Radio(
+                choices=VOTE_CHOICES,
+                label="Temporal consistency",
+            )
+
+        tie_all = gr.Button("Tie all / unsure")
+        tie_all.click(
+            fn=lambda: ("Tie / unsure", "Tie / unsure", "Tie / unsure"),
+            outputs=[action_following, visual_quality, temporal_consistency],
+        )
+
+        gr.Markdown(
+            "Artifact flagging fallback: enter the paused player time in seconds, then record it."
+        )
+        with gr.Row():
+            artifact_time_input = gr.Textbox(
+                label="Artifact timestamp (seconds)",
+                placeholder="Example: 1.24",
+            )
+            flag_artifact = gr.Button("Flag artifact")
+            clear_artifacts = gr.Button("Clear artifact flags")
+
+        artifact_markdown = gr.Markdown(FLAG_HELP)
+        note = gr.Textbox(lines=3, label="Optional note")
+
+        with gr.Row():
+            save_button = gr.Button(
+                "Save annotation",
+                variant="primary",
+                interactive=writes_enabled,
+            )
+            prev_button = gr.Button("Previous sample")
+            next_button = gr.Button("Next sample")
+
+        status = gr.Markdown(first_status)
+
+        flag_artifact.click(
+            fn=record_artifact_flag,
+            inputs=[artifact_time_input, artifact_flags],
+            outputs=[artifact_flags, artifact_markdown, artifact_time_input, status],
+        )
+        clear_artifacts.click(
+            fn=lambda: ([], FLAG_HELP, "", _status_message("Cleared artifact flags.")),
+            outputs=[artifact_flags, artifact_markdown, artifact_time_input, status],
+        )
+        save_button.click(
+            fn=lambda index, flags, action_vote, visual_vote, temporal_vote, note_text: save_annotation(
+                manifest=manifest,
+                results_dir=results_dir,
+                sample_index=index,
+                flags=flags,
+                action_vote=action_vote,
+                visual_vote=visual_vote,
+                temporal_vote=temporal_vote,
+                note_text=note_text,
+                writes_enabled=writes_enabled,
+            ),
+            inputs=[
+                current_index,
+                artifact_flags,
+                action_following,
+                visual_quality,
+                temporal_consistency,
+                note,
+            ],
+            outputs=[status],
+        )
+        prev_button.click(
+            fn=lambda index: navigate_sample(manifest, index - 1),
+            inputs=[current_index],
+            outputs=_sample_outputs(
+                sample_title,
+                sample_metadata,
+                left_video,
+                right_video,
+                action_markdown,
+                action_following,
+                visual_quality,
+                temporal_consistency,
+                artifact_time_input,
+                artifact_markdown,
+                note,
+                status,
+                current_index,
+                artifact_flags,
+            ),
+        )
+        next_button.click(
+            fn=lambda index: navigate_sample(manifest, index + 1),
+            inputs=[current_index],
+            outputs=_sample_outputs(
+                sample_title,
+                sample_metadata,
+                left_video,
+                right_video,
+                action_markdown,
+                action_following,
+                visual_quality,
+                temporal_consistency,
+                artifact_time_input,
+                artifact_markdown,
+                note,
+                status,
+                current_index,
+                artifact_flags,
+            ),
+        )
+
+    return demo
+
+
+def navigate_sample(manifest: DatasetManifest, requested_index: int) -> tuple[Any, ...]:
+    sample_count = len(manifest.samples)
+    sample_index = max(0, min(requested_index, sample_count - 1))
+    sample = manifest.samples[sample_index]
+    status = _status_message(f"Loaded `{sample.sample_id}`.")
+    return (
+        _sample_title(sample, sample_index, sample_count),
+        _sample_metadata(sample),
+        str(sample.reference_video),
+        str(sample.generated_video),
+        sample.action_markdown,
+        None,
+        None,
+        None,
+        "",
+        FLAG_HELP,
+        "",
+        status,
+        sample_index,
+        [],
+    )
+
+
+def record_artifact_flag(
+    artifact_time_text: str,
+    existing_flags: list[dict[str, Any]] | None,
+) -> tuple[list[dict[str, Any]], str, str, str]:
+    existing_flags = list(existing_flags or [])
+    try:
+        timestamp_s = round(float(artifact_time_text.strip()), 3)
+    except (AttributeError, ValueError):
+        return (
+            existing_flags,
+            _artifact_markdown(existing_flags),
+            artifact_time_text,
+            _status_message("Enter a numeric timestamp before flagging an artifact."),
+        )
+
+    if timestamp_s < 0:
+        return (
+            existing_flags,
+            _artifact_markdown(existing_flags),
+            artifact_time_text,
+            _status_message("Artifact timestamps must be zero or positive."),
+        )
+
+    existing_flags.append(
+        {
+            "timestamp_s": timestamp_s,
+            "source": "manual_text_entry",
+            "recorded_at": _utc_now(),
+        }
+    )
+    return (
+        existing_flags,
+        _artifact_markdown(existing_flags),
+        "",
+        _status_message(f"Flagged artifact at {timestamp_s:.3f}s."),
+    )
+
+
+def save_annotation(
+    manifest: DatasetManifest,
+    results_dir: Path,
+    sample_index: int,
+    flags: list[dict[str, Any]] | None,
+    action_vote: str | None,
+    visual_vote: str | None,
+    temporal_vote: str | None,
+    note_text: str,
+    writes_enabled: bool,
+) -> str:
+    if not writes_enabled:
+        return _status_message(
+            "Annotation writes are disabled in this deployment. "
+            "Set `ARENA_DISABLE_WRITES=0` or omit `--disable-writes` to enable saving."
+        )
+
+    missing = [
+        label
+        for label, value in (
+            ("action following", action_vote),
+            ("visual quality", visual_vote),
+            ("temporal consistency", temporal_vote),
+        )
+        if not value
+    ]
+    if missing:
+        return _status_message(f"Select votes for: {', '.join(missing)}.")
+
+    sample = manifest.samples[sample_index]
+    flags = list(flags or [])
+    record = {
+        "annotated_at": _utc_now(),
+        "sample_id": sample.sample_id,
+        "scenario": sample.scenario,
+        "case_id": sample.case_id,
+        "pair_mode": sample.pair_mode,
+        "left_label": sample.left_label,
+        "right_label": sample.right_label,
+        "reference_video": sample.reference_video_relative,
+        "generated_video": sample.generated_video_relative,
+        "preview_image": sample.preview_image_relative,
+        "action_path": sample.action_path_relative,
+        "votes": {
+            "action_following": action_vote,
+            "visual_quality": visual_vote,
+            "temporal_consistency": temporal_vote,
+        },
+        "artifact_flags": flags,
+        "artifact_latest_s": flags[-1]["timestamp_s"] if flags else None,
+        "note": note_text.strip(),
+    }
+    output_path = append_annotation(results_dir=results_dir, record=record)
+    return _status_message(
+        f"Saved `{sample.sample_id}` to `{_display_path(output_path)}`. "
+        "Use Next sample to continue."
+    )
+
+
+def _sample_outputs(*components: Any) -> list[Any]:
+    return list(components)
+
+
+def _sample_title(sample: Sample, sample_index: int, sample_count: int) -> str:
+    return (
+        f"## Sample {sample_index + 1} / {sample_count}\n"
+        f"`{sample.sample_id}`"
+    )
+
+
+def _sample_metadata(sample: Sample) -> str:
+    reference_meta = sample.reference_video_meta or {}
+    generated_meta = sample.generated_video_meta or {}
+    width = generated_meta.get("width") or reference_meta.get("width")
+    height = generated_meta.get("height") or reference_meta.get("height")
+    fps = generated_meta.get("fps") or reference_meta.get("fps")
+    duration_s = generated_meta.get("duration_s") or reference_meta.get("duration_s")
+    control_mode = sample.action_summary.get("control_mode", "unknown")
+
+    parts = [
+        f"**Scenario:** `{sample.scenario}`",
+        f"**Case ID:** `{sample.case_id}`",
+        f"**Pairing:** left=`{sample.reference_video_relative}` | right=`{sample.generated_video_relative}`",
+        f"**Action file:** `{sample.action_path_relative}`",
+        f"**Preview still:** `{sample.preview_image_relative or 'missing'}`",
+        f"**Inferred control regime:** {control_mode}",
+    ]
+
+    if width and height:
+        parts.append(f"**Resolution:** {width}x{height}")
+    if fps:
+        parts.append(f"**FPS:** {fps:.2f}")
+    if duration_s:
+        parts.append(f"**Duration:** {duration_s:.2f}s")
+
+    return " | ".join(parts)
+
+
+def _artifact_markdown(flags: list[dict[str, Any]]) -> str:
+    if not flags:
+        return FLAG_HELP
+
+    lines = ["**Flagged artifact times**"]
+    for index, flag in enumerate(flags, start=1):
+        lines.append(f"- {index}. `{flag['timestamp_s']:.3f}s` via {flag['source']}")
+    return "\n".join(lines)
+
+
+def _status_message(message: str) -> str:
+    return f"**Status:** {message}"
+
+
+def _display_path(path: Path) -> str:
+    try:
+        return path.relative_to(Path.cwd()).as_posix()
+    except ValueError:
+        return str(path)
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def parse_args() -> argparse.Namespace:
+    repo_root = Path(__file__).resolve().parents[1]
+    parser = argparse.ArgumentParser(description="Run the Minecraft LM-Arena baseline app.")
+    parser.add_argument(
+        "--manifest",
+        type=Path,
+        default=repo_root / "arena" / "manifest.json",
+        help="Path to the normalized manifest JSON file.",
+    )
+    parser.add_argument(
+        "--results-dir",
+        type=Path,
+        default=repo_root / "arena" / "results",
+        help="Directory for JSONL annotation logs.",
+    )
+    parser.add_argument(
+        "--rebuild-manifest",
+        action="store_true",
+        help="Re-scan data_subset and rebuild the manifest before launch.",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default=os.getenv("GRADIO_SERVER_NAME", "0.0.0.0"),
+        help="Host interface for Gradio.",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=int(os.getenv("GRADIO_SERVER_PORT", "7860")),
+        help="Port for Gradio.",
+    )
+    parser.add_argument(
+        "--disable-writes",
+        action="store_true",
+        default=_env_flag("ARENA_DISABLE_WRITES", False),
+        help="Disable writing annotations to disk.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    manifest_path = ensure_manifest(manifest_path=args.manifest, rebuild=args.rebuild_manifest)
+    manifest = load_manifest(manifest_path)
+    demo = build_app(
+        manifest=manifest,
+        results_dir=args.results_dir,
+        writes_enabled=not args.disable_writes,
+    )
+    demo.launch(server_name=args.host, server_port=args.port)
+
+
+def _env_flag(name: str, default: bool) -> bool:
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+if __name__ == "__main__":
+    main()

arena/build_manifest.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+from datetime import datetime, timezone
+from fractions import Fraction
+from pathlib import Path
+from typing import Any
+
+try:
+    from .actions import build_action_summary, summary_to_manifest_dict
+except ImportError:
+    from actions import build_action_summary, summary_to_manifest_dict
+
+
+GENERATED_SUFFIX = "_wangame.mp4"
+ACTION_SUFFIX = "_action.npy"
+
+
+def build_manifest(dataset_root: Path, repo_root: Path | None = None) -> dict[str, Any]:
+    repo_root = repo_root or Path(__file__).resolve().parents[1]
+    dataset_root = dataset_root.resolve()
+
+    samples: list[dict[str, Any]] = []
+    warnings: list[str] = []
+    scenario_summaries: list[dict[str, Any]] = []
+
+    for scenario_dir in sorted(path for path in dataset_root.iterdir() if path.is_dir()):
+        indexed_cases = _index_scenario_cases(scenario_dir)
+        valid_case_ids: list[str] = []
+
+        for case_id in sorted(indexed_cases):
+            entry = indexed_cases[case_id]
+            missing = [
+                field
+                for field in ("reference_video", "generated_video", "action_path")
+                if field not in entry
+            ]
+            if missing:
+                warnings.append(
+                    f"Skipping {scenario_dir.name}/{case_id}: missing {', '.join(sorted(missing))}"
+                )
+                continue
+
+            reference_video = entry["reference_video"]
+            generated_video = entry["generated_video"]
+            action_path = entry["action_path"]
+            preview_image = entry.get("preview_image")
+
+            reference_meta = probe_video(reference_video)
+            generated_meta = probe_video(generated_video)
+            fps = (
+                generated_meta.get("fps")
+                or reference_meta.get("fps")
+                or generated_meta.get("avg_frame_rate")
+                or reference_meta.get("avg_frame_rate")
+            )
+            action_summary = build_action_summary(action_path, fps=fps)
+
+            sample = {
+                "sample_id": f"{scenario_dir.name}/{case_id}",
+                "scenario": scenario_dir.name,
+                "case_id": case_id,
+                "pair_mode": "reference_vs_wangame",
+                "left_label": "Reference (.mp4)",
+                "right_label": "Generated (WanGame)",
+                "reference_video": _path_for_manifest(reference_video, repo_root),
+                "generated_video": _path_for_manifest(generated_video, repo_root),
+                "preview_image": _path_for_manifest(preview_image, repo_root) if preview_image else None,
+                "action_path": _path_for_manifest(action_path, repo_root),
+                "reference_video_meta": reference_meta,
+                "generated_video_meta": generated_meta,
+                "action_summary": summary_to_manifest_dict(action_summary),
+                "action_markdown": action_summary.markdown,
+            }
+            samples.append(sample)
+            valid_case_ids.append(case_id)
+
+        scenario_summaries.append(
+            {
+                "scenario": scenario_dir.name,
+                "n_samples": len(valid_case_ids),
+                "case_ids": valid_case_ids,
+            }
+        )
+
+    return {
+        "manifest_version": 1,
+        "created_at": _utc_now(),
+        "repo_root": _path_for_manifest(repo_root.resolve(), repo_root),
+        "dataset_root": _path_for_manifest(dataset_root, repo_root),
+        "pair_mode": "reference_vs_wangame",
+        "sample_count": len(samples),
+        "scenario_summaries": scenario_summaries,
+        "samples": samples,
+        "warnings": warnings,
+    }
+
+
+def write_manifest(dataset_root: Path, manifest_path: Path, repo_root: Path | None = None) -> Path:
+    manifest = build_manifest(dataset_root=dataset_root, repo_root=repo_root)
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    with manifest_path.open("w", encoding="utf-8") as handle:
+        json.dump(manifest, handle, indent=2)
+        handle.write("\n")
+    return manifest_path
+
+
+def probe_video(video_path: Path) -> dict[str, Any]:
+    command = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=width,height,avg_frame_rate,nb_frames,duration",
+        "-of",
+        "json",
+        str(video_path),
+    ]
+    try:
+        result = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError:
+        return {}
+    except subprocess.CalledProcessError:
+        return {}
+
+    try:
+        payload = json.loads(result.stdout)
+        stream = payload["streams"][0]
+    except (json.JSONDecodeError, KeyError, IndexError):
+        return {}
+
+    fps_text = stream.get("avg_frame_rate")
+    fps = _parse_fraction(fps_text)
+    duration = _parse_float(stream.get("duration"))
+    nb_frames = _parse_int(stream.get("nb_frames"))
+
+    return {
+        "width": _parse_int(stream.get("width")),
+        "height": _parse_int(stream.get("height")),
+        "avg_frame_rate": fps,
+        "fps": fps,
+        "duration_s": duration,
+        "nb_frames": nb_frames,
+    }
+
+
+def _index_scenario_cases(scenario_dir: Path) -> dict[str, dict[str, Path]]:
+    indexed: dict[str, dict[str, Path]] = {}
+    for path in sorted(candidate for candidate in scenario_dir.iterdir() if candidate.is_file()):
+        case_id: str | None = None
+        field: str | None = None
+        if path.name.endswith(ACTION_SUFFIX):
+            case_id = path.name[: -len(ACTION_SUFFIX)]
+            field = "action_path"
+        elif path.name.endswith(GENERATED_SUFFIX):
+            case_id = path.name[: -len(GENERATED_SUFFIX)]
+            field = "generated_video"
+        elif path.suffix.lower() == ".mp4":
+            case_id = path.stem
+            field = "reference_video"
+        elif path.suffix.lower() == ".jpg":
+            case_id = path.stem
+            field = "preview_image"
+
+        if case_id and field:
+            indexed.setdefault(case_id, {})[field] = path.resolve()
+    return indexed
+
+
+def _path_for_manifest(path: Path, repo_root: Path) -> str:
+    resolved = path.resolve()
+    try:
+        return resolved.relative_to(repo_root.resolve()).as_posix()
+    except ValueError:
+        return str(resolved)
+
+
+def _parse_fraction(value: Any) -> float | None:
+    if not value:
+        return None
+    try:
+        return float(Fraction(str(value)))
+    except (ZeroDivisionError, ValueError):
+        return None
+
+
+def _parse_float(value: Any) -> float | None:
+    if value in (None, ""):
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _parse_int(value: Any) -> int | None:
+    if value in (None, ""):
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _default_repo_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def main() -> None:
+    repo_root = _default_repo_root()
+    parser = argparse.ArgumentParser(description="Build a normalized dataset manifest for arena.")
+    parser.add_argument(
+        "--dataset-root",
+        type=Path,
+        default=repo_root / "data_subset",
+        help="Path to the dataset root (default: repo_root/data_subset)",
+    )
+    parser.add_argument(
+        "--manifest",
+        type=Path,
+        default=repo_root / "arena" / "manifest.json",
+        help="Path to the manifest JSON file to write",
+    )
+    args = parser.parse_args()
+
+    manifest_path = write_manifest(
+        dataset_root=args.dataset_root,
+        manifest_path=args.manifest,
+        repo_root=repo_root,
+    )
+    print(f"Wrote manifest to {manifest_path}")
+
+
+if __name__ == "__main__":
+    main()

arena/dataset.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Sample:
+    sample_id: str
+    scenario: str
+    case_id: str
+    pair_mode: str
+    left_label: str
+    right_label: str
+    reference_video_relative: str
+    generated_video_relative: str
+    action_path_relative: str
+    preview_image_relative: str | None
+    reference_video: Path
+    generated_video: Path
+    action_path: Path
+    preview_image: Path | None
+    reference_video_meta: dict[str, Any]
+    generated_video_meta: dict[str, Any]
+    action_summary: dict[str, Any]
+    action_markdown: str
+
+
+@dataclass(frozen=True)
+class DatasetManifest:
+    manifest_path: Path
+    dataset_root: Path
+    pair_mode: str
+    sample_count: int
+    scenario_summaries: list[dict[str, Any]]
+    warnings: list[str]
+    samples: list[Sample]
+
+
+def ensure_manifest(manifest_path: Path | None = None, rebuild: bool = False) -> Path:
+    manifest_path = manifest_path or default_manifest_path()
+    if rebuild or not manifest_path.exists():
+        build_manifest_module = _import_build_manifest()
+        build_manifest_module.write_manifest(
+            dataset_root=default_dataset_root(),
+            manifest_path=manifest_path,
+            repo_root=repo_root(),
+        )
+    return manifest_path
+
+
+def load_manifest(manifest_path: Path | None = None) -> DatasetManifest:
+    manifest_path = manifest_path or default_manifest_path()
+    with manifest_path.open("r", encoding="utf-8") as handle:
+        payload = json.load(handle)
+
+    root = repo_root()
+    samples = [
+        Sample(
+            sample_id=item["sample_id"],
+            scenario=item["scenario"],
+            case_id=item["case_id"],
+            pair_mode=item.get("pair_mode", "reference_vs_wangame"),
+            left_label=item.get("left_label", "Left"),
+            right_label=item.get("right_label", "Right"),
+            reference_video_relative=item["reference_video"],
+            generated_video_relative=item["generated_video"],
+            action_path_relative=item["action_path"],
+            preview_image_relative=item.get("preview_image"),
+            reference_video=_resolve_repo_path(root, item["reference_video"]),
+            generated_video=_resolve_repo_path(root, item["generated_video"]),
+            action_path=_resolve_repo_path(root, item["action_path"]),
+            preview_image=_resolve_repo_path(root, item["preview_image"]) if item.get("preview_image") else None,
+            reference_video_meta=item.get("reference_video_meta", {}),
+            generated_video_meta=item.get("generated_video_meta", {}),
+            action_summary=item.get("action_summary", {}),
+            action_markdown=item.get("action_markdown", "Action summary unavailable."),
+        )
+        for item in payload.get("samples", [])
+    ]
+
+    dataset_root_value = payload.get("dataset_root")
+    dataset_root = _resolve_repo_path(root, dataset_root_value) if dataset_root_value else default_dataset_root()
+
+    return DatasetManifest(
+        manifest_path=manifest_path,
+        dataset_root=dataset_root,
+        pair_mode=payload.get("pair_mode", "reference_vs_wangame"),
+        sample_count=int(payload.get("sample_count", len(samples))),
+        scenario_summaries=list(payload.get("scenario_summaries", [])),
+        warnings=list(payload.get("warnings", [])),
+        samples=samples,
+    )
+
+
+def default_manifest_path() -> Path:
+    return repo_root() / "arena" / "manifest.json"
+
+
+def default_dataset_root() -> Path:
+    return repo_root() / "data_subset"
+
+
+def repo_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _resolve_repo_path(root: Path, value: str | None) -> Path:
+    if not value:
+        return root
+    path = Path(value)
+    if path.is_absolute():
+        return path
+    return root / path
+
+
+def _import_build_manifest():
+    try:
+        from . import build_manifest as build_manifest_module
+    except ImportError:
+        import build_manifest as build_manifest_module
+
+    return build_manifest_module

arena/dataset_notes.md

@@ -0,0 +1,72 @@
+# Dataset Notes
+
+## Short assumptions
+
+- Each folder under `data_subset/` is a scenario family, likely grouped by control regime or prompt generation regime rather than by evaluator split.
+- Each scenario folder currently contains 10 complete cases: `01` through `10`.
+- A complete case consists of:
+  - `{id}.mp4`
+  - `{id}_wangame.mp4`
+  - `{id}_action.npy`
+  - `{id}.jpg`
+
+## What the files likely mean
+
+- `{id}.mp4`
+  - Most likely the reference / ground-truth video for that case.
+  - This is not guessed only from the filename: `ptlflow/run_all_eval.py` and `ptlflow/visualize_results.py` explicitly pair `{id}.mp4` with `{id}_wangame.mp4` as reference vs generated.
+- `{id}_wangame.mp4`
+  - Most likely the WanGame-generated output for the same case.
+- `{id}_action.npy`
+  - A pickled dict with two arrays:
+    - `keyboard`: shape `(77, 6)`
+    - `mouse`: shape `(77, 2)`
+  - From `ptlflow/action_flow_score.py`, the keyboard order is `[W, S, A, D, left, right]`.
+  - From the same script, the mouse order is `[pitch, yaw]`.
+  - The subset appears aligned at 77 frames per case, with videos observed at 25 FPS and about 3.08s duration.
+- `{id}.jpg`
+  - Likely a preview still or initial frame.
+  - It visually matches the opening scene for at least one checked sample.
+  - Relevant `ptlflow` scripts do not appear to use it for evaluation, so its exact role remains somewhat ambiguous.
+
+## What each scenario folder likely represents
+
+- `camera`
+  - Inferred camera-only regime: no keyboard activity, nonzero mouse yaw throughout sampled files.
+- `camera4hold_alpha1`
+  - Inferred camera-only regime with held pitch/yaw steps.
+- `1_wasd_only`
+  - Inferred keyboard-only regime with no mouse input.
+- `wasdonly_alpha1`
+  - Another keyboard-only regime with no mouse input.
+- `fully_random`
+  - Mixed keyboard + mouse regime.
+- `wasd4holdrandview_simple_1key1mouse1`
+  - Mixed keyboard + mouse regime; folder name suggests sparse held inputs, which matches the action arrays broadly.
+
+These scenario names were not documented elsewhere in the repo, so the descriptions above are inferred from folder names plus action statistics.
+
+## Pairing logic
+
+- Pair samples only within the same scenario folder.
+- Pair by exact case id:
+  - `scenario/01.mp4`
+  - `scenario/01_wangame.mp4`
+  - `scenario/01_action.npy`
+- Do not pair across scenario folders even when the case ids match.
+
+## Baseline UI choice
+
+- The baseline app should be side-by-side A/B, not single-video scoring.
+- Reason:
+  - the dataset has a natural two-video pair per case
+  - `ptlflow` already treats that pair as the main eval unit
+  - the user requested an LM-Arena-style baseline first
+
+## Important ambiguity
+
+- This is an A/B comparison, but it is asymmetric:
+  - left is a reference video
+  - right is a generated WanGame output
+- That means the UI is "arena-shaped" but not a blinded model-vs-model arena.
+- A stricter single-video scoring flow would also be coherent, but the current repo structure supports paired comparison more directly, so the baseline chooses A/B.

arena/result_logger.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def annotations_path(results_dir: Path) -> Path:
+    return results_dir / "annotations.jsonl"
+
+
+def append_annotation(results_dir: Path, record: dict[str, Any]) -> Path:
+    results_dir.mkdir(parents=True, exist_ok=True)
+    output_path = annotations_path(results_dir)
+    with output_path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(record, ensure_ascii=True))
+        handle.write("\n")
+    return output_path

arena/results/.gitkeep

@@ -0,0 +1 @@
+

arena/results/annotations.jsonl

@@ -0,0 +1 @@
+{"annotated_at": "2026-03-10T04:48:33.348392+00:00", "sample_id": "1_wasd_only/01", "scenario": "1_wasd_only", "case_id": "01", "pair_mode": "reference_vs_wangame", "left_label": "Reference (.mp4)", "right_label": "Generated (WanGame)", "reference_video": "data_subset/1_wasd_only/01.mp4", "generated_video": "data_subset/1_wasd_only/01_wangame.mp4", "preview_image": "data_subset/1_wasd_only/01.jpg", "action_path": "data_subset/1_wasd_only/01_action.npy", "votes": {"action_following": "Left better", "visual_quality": "Tie / unsure", "temporal_consistency": "Left better"}, "artifact_flags": [], "artifact_latest_s": null, "note": ""}

data_subset/1_wasd_only/01.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:855b25f93f4f165acf93cee4b37f341501fc59e9810c807ebd5837b5f12fe186
+size 78786

data_subset/1_wasd_only/01_action.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a580fa0e2f5f783e7113886f0447e580819e249bc993083aeff074a3233afcd7
+size 2902

data_subset/1_wasd_only/01_wangame.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e60938e6a77a1811216efee750e281eddc8eb38b8d2d0f133084e83465b6e967
+size 62610

data_subset/1_wasd_only/02.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0f3fbfb28afe97a9b6d9664f5d30c2f13bad54939135137db0652652de78fd0
+size 86880

data_subset/1_wasd_only/02_action.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20181eb53edb42e80a8271d99226e8b4ffd55e5d5501df73730085166977423d
+size 2902

data_subset/1_wasd_only/02_wangame.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7b3b957a3073916783a4b2c0bf320ce18b92c337814c16963432a2ae36b587f
+size 403384

data_subset/1_wasd_only/03.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e9d527912f7ce59c4f57ae5a9b771105746c87772377452a65346360e1244ae
+size 98605

data_subset/1_wasd_only/03_action.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:030abdc4ec31ce9cffebae9c46b08e7e89779715e1c4f81abe16cbffbee1746b
+size 2902

data_subset/1_wasd_only/03_wangame.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d28932a5f60b96f9f855b2a4593125a0d88a492a9c023ebf9e3ff412165333c
+size 393043

data_subset/1_wasd_only/04.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7c0b55bed20a73c61b7d50b09681f6f189ff8a8942129e143b2326d91be5810
+size 73484

data_subset/1_wasd_only/04_action.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e32503ed36fa7199a83548db507c3c4dfba396fc9acdf71792d86a71eb1ffa9b
+size 2902

data_subset/1_wasd_only/04_wangame.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5049a9a152b2497bf877b754ab8d607ec0f25f4b92297b40703c5438257db9f1
+size 79860

data_subset/1_wasd_only/05.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96e7064faaa87f8d845517eba3695d3e60b84cfc1eb4cdd57acb27cc494b26e2
+size 629639

data_subset/1_wasd_only/05_action.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20181eb53edb42e80a8271d99226e8b4ffd55e5d5501df73730085166977423d
+size 2902

data_subset/1_wasd_only/05_wangame.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6819b458185b7d8ae8181852c7205ff7d6e681b56ff222e7b668ef829b80dfba
+size 502535

data_subset/1_wasd_only/06.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70c28dd861202aef52d1e6e3bead6cb7d8eed08c49cc983c8f84e03e6791e1cc
+size 744972

data_subset/1_wasd_only/06_action.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:030abdc4ec31ce9cffebae9c46b08e7e89779715e1c4f81abe16cbffbee1746b
+size 2902

data_subset/1_wasd_only/06_wangame.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42b9afe180eeec4674c49113061619fe80b2708e2c40364e5c763528af72309b
+size 720365

data_subset/1_wasd_only/07.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad07edd622a19fdd30e342328e560412ba3f8f7f63a2e140941e227a84cf3565
+size 704835

data_subset/1_wasd_only/07_action.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a580fa0e2f5f783e7113886f0447e580819e249bc993083aeff074a3233afcd7
+size 2902

data_subset/1_wasd_only/07_wangame.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ed71ccc53d9c18de093c7852db3d8d007efadaf12b724f585045ed4e53f6b41
+size 690364

data_subset/1_wasd_only/08.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c827892a1b4fa233e5d702524ad6fc75c48d494100f74effef6c16a685a215fc
+size 777476

data_subset/1_wasd_only/08_action.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:030abdc4ec31ce9cffebae9c46b08e7e89779715e1c4f81abe16cbffbee1746b
+size 2902

data_subset/1_wasd_only/08_wangame.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a36f305aa87e043f93daeb9da57ec160c30ff1bd9381676d168e000d48cbd443
+size 696419

data_subset/1_wasd_only/09.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab71cea35b8f75063ed4b2bf91600663eb94ee7f0954f4685e49c715a6f28ff6
+size 1048922

data_subset/1_wasd_only/09_action.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a580fa0e2f5f783e7113886f0447e580819e249bc993083aeff074a3233afcd7
+size 2902