README.md

---
pretty_name: Diogenes Gameplay Raw Sample v01
license: other
license_name: proprietary-internal-non-trainable
language:
  - en
tags:
  - video
  - audio
  - gameplay
  - human-demonstration
  - keyboard-mouse
  - action-annotation
  - non-trainable
size_categories:
  - 1K<n<10K
configs:
  - config_name: segments
    default: true
    data_files:
      - split: sample
        path: data/segments.parquet
  - config_name: frames
    data_files:
      - split: sample
        path: data/frames.parquet
  - config_name: events
    data_files:
      - split: sample
        path: data/events.parquet
extra_gated_heading: Request access to Diogenes Gameplay Raw Sample v01
extra_gated_description: >-
  Access is restricted. Enter the access code supplied to you by Diogenes Lab.
  Requests submitted without a valid code are rejected. This dataset must not be
  used to train, fine-tune, or evaluate any model.
extra_gated_button_content: Request access
extra_gated_fields:
  Access code: text
  Organization: text
  Intended use: text
  I confirm I will NOT use this data to train, fine-tune, or evaluate any model: checkbox
---

# Diogenes Gameplay Raw Sample v01

> Formerly `DiogenesLab/Diogenes_COD_sample_v01` — old links redirect here.

**A sample dataset.** PC gameplay recordings with **frame-aligned keyboard/mouse action
annotations**, in two batches:

| batch | recorded | video | audio |
|---|---|---|---|
| **batch 1** | 2026-07-25/26 | 1920×1080 @ **30 fps**, H.264 | none |
| **batch 2** | 2026-07-31 | 1920×1080 @ **60 fps**, H.264 | **process-loopback system audio**, 48 kHz stereo s16le (zstd-compressed PCM) |

This is a *sample* — the recording output available at the time of publication, a small
early slice of an ongoing capture effort, not a complete or representative corpus. It
exists so collaborators can evaluate recording quality, annotation schema, and
time-alignment fidelity. Expect the shape of the data to change in later versions.

## ⚠️ Not for model training

Every record carries `non_trainable: true` and `production_certified: false`, copied verbatim
from the source metadata. The originating catalog runs in `dev_non_trainable` mode and the
source game profile is named *"Call of Duty® Steam（release 测试，禁止训练）"* —
"release test, training prohibited".

**本数据集不可用于任何模型训练。** 所有记录的 `non_trainable` 标记均为 `true`，
`production_certified` 均为 `false`，与源元数据逐字一致。数据来源为 release 测试录制，
未取得可训练所需的 consent grant、catalog 认证与 QA 流程。

Constraints that apply:

- **No training, fine-tuning, or evaluation of models** on this data.
- The video depicts **Call of Duty®**, copyright Activision Publishing, Inc. Diogenes Lab claims
  no rights to the depicted game content. Redistribution outside approved collaborators is not permitted.
- These runs predate the consent-grant pipeline; there is no `consent_id` attached.

Permitted: inspecting recording quality, validating the annotation schema, and reviewing
time-alignment between video frames and input events.

## Contents

| | total | batch 1 (30 fps) | batch 2 (60 fps + audio) |
|---|---|---|---|
| Sessions | 35 | 19 | 16 |
| Runs | 36 | 20 | 16 |
| Segments (10 s each) | 1,787 | 857 | 930 |
| Duration | **4.92 h** | 2.36 h | 2.56 h |
| Frames | 807,309 | 254,587 | 552,722 |
| Input events | 858,161 | 402,692 | 455,469 |
| Video | 32.7 GiB | 15.7 GiB | 17.0 GiB |
| Audio segments | 865 | — | 865 (1.37 GiB compressed PCM) |

Frames carrying at least one input signal: 540,849 / 807,309 (67.0%).
Duplicate frames: 6,295 (0.78% — 0.13% in batch 1, 1.08% in batch 2; at 60 fps WGC re-serves
a frame whenever the game renders below 60). Every video and audio object verifies against
its recorded SHA-256. Run termination: `foreground_lost` × 36 (all runs).

## Dataset structure

Three parquet tables plus the media, joinable on `(session_id, run_id, segment_id)`:

```
data/segments.parquet      1,787 rows   one row per 10-second segment (index table)
data/frames.parquet      807,309 rows   one row per video frame, with action labels
data/events.parquet      858,161 rows   one row per raw input event
videos/<session_id>/<run_id>/<segment_id>.mp4
audio/<session_id>/<run_id>/<segment_id>.pcm.zst    (batch 2 only; verbatim capture bytes)
metadata/                catalog and profile documents for batch 1, verbatim (kept in place)
metadata/catalog-2026-07-30.0/   batch-2 pre-audio catalog documents, verbatim
metadata/catalog-2026-07-31.0/   batch-2 audio catalog documents, verbatim
metadata/sessions/       per-session session.json
```

Audio decodes to exactly `audio_frames × 4` bytes of interleaved stereo s16le PCM at 48 kHz
(`zstd -d < seg.pcm.zst`). Segment audio SHA-256, byte counts and health metadata live in the
`segments` table (`audio_*` columns, null for batch 1).

### `segments` fields

Batch-1 fields are unchanged from the original release. Added (nullable, batch 2 only):

| field | type | description |
|---|---|---|
| `audio_path` | string | repo-relative path to the `.pcm.zst` object |
| `audio_bytes` | int64 | compressed size (bytes) |
| `audio_sha256` | string | SHA-256 of the compressed object |
| `audio_frames` | int64 | PCM frames (samples per channel) |
| `audio_sample_rate`, `audio_channels` | int32 | 48000 / 2 |
| `audio_state` | string | `ready` for all shipped segments |

All other fields as before: join key, `video_path`/`video_bytes`/`video_sha256`,
`num_frames`/`num_events`/`duration_s`, geometry (`width`/`height`/`fps` — **30.0 or 60.0**),
provenance (`game_id`, `catalog_id`, `catalog_version`, `catalog_mode`, `mapping_id`,
`mapping_version`), `mean_bitrate_bps`, run outcome, compliance flags, and the time model
(`qpc_start`/`qpc_end`/`run_anchor_qpc`/`qpc_frequency`/`run_t_us`/`t_utc_est`).

## Time model

Unchanged for batch 1. **Batch 2 improvement**: the capture client now records the run's
wall-clock anchor (`anchorAtUtc`) next to its QPC anchor, so batch-2 `t_utc_est` is anchored
on a **recorded** timestamp rather than reconstructed from the session-id epoch. The constant
bias caveat from batch 1 does not apply to batch 2; sub-millisecond alignment within a run is
still governed by the QPC timebase, which is authoritative in both batches.

Frame windows tile each segment with no gaps (`output_qpc_start`/`output_qpc_end`, half-open).
Event-to-frame attribution and the precomputed `frame_events_json` state-change view work
exactly as in the original release; keyboard auto-repeat is collapsed there because `keys`
carries held state.

### `frames` fields

Unchanged schema. At 60 fps, full segments hold 600 frames instead of 300.

Semantic actions, by frame count (whole corpus; batches differ in fps, so frame counts are
not comparable across batches without normalising):

`move.forward` 320,963 · `camera.yaw` 302,276 · `camera.pitch` 255,844 · `combat.aim` 165,921 ·
`move.right` 75,080 · `move.left` 69,920 · `combat.primary_attack` 31,334 · `move.sprint` 29,720

Most frequent virtual-key codes: 87 `W` (318,572) · 68 `D` (72,667) · 65 `A` (67,738) ·
16 `Shift` (28,893) · 81 `Q` (15,778) · 69 `E` (11,709) · 83 `S` (7,006) · 32 `Space` (4,397).

### `events` fields

Unchanged schema, plus one added nullable field:

| field | type | description |
|---|---|---|
| `repeat` | bool | batch 2 only: the client explicitly marks OS keyboard auto-repeat `key_down` events (`true` on 36,871 events). Null in batch 1 — collapse auto-repeat there by tracking held state, as before. |

Event mix (whole corpus): `mouse_move` 760,361 · `key_down` 80,085 · `key_up` 10,102 ·
`mouse_down` 3,777 · `mouse_up` 3,776 · `wheel` 60.

## Usage

```python
from datasets import load_dataset

segments = load_dataset("DiogenesLab/Diogenes_Gameplay_raw_sample_v01", "segments", split="sample")
frames   = load_dataset("DiogenesLab/Diogenes_Gameplay_raw_sample_v01", "frames",   split="sample")
events   = load_dataset("DiogenesLab/Diogenes_Gameplay_raw_sample_v01", "events",   split="sample")

audio_segs = segments.filter(lambda r: r["audio_state"] == "ready")
print(len(audio_segs), audio_segs[0]["audio_path"])
```

Media files are not embedded in the parquet — fetch them by path:

```python
from huggingface_hub import hf_hub_download

path = hf_hub_download("DiogenesLab/Diogenes_Gameplay_raw_sample_v01",
                       segments[0]["video_path"], repo_type="dataset")
```

## Recording methodology

Recording covers the game window only — no desktop, no other windows. Input is captured at
full device resolution in relative-pointer mode, restricted to the key and button set declared
in the game profile's input contract. Video frames and input events share a single
high-resolution timebase, which is what makes per-frame action attribution exact rather than
interpolated. Segments are 10 s and independently hashed.

Batch 2 additionally captures **process-loopback system audio** (the game process's own
output, not the microphone): 48 kHz stereo s16le, zstd-compressed per segment, hashed into the
same per-segment integrity manifest. Audio health counters (queue overflows, discontinuities,
silence fill, timestamp errors) were zero across all shipped segments.

Runs terminate when the game window loses foreground. A run that fails its recording
invariants is discarded wholesale rather than repaired.

## Known caveats (read before consuming)

- **Batch-1 frames plane is missing all Ctrl input.** The capture-time configuration declared
  Ctrl a control key while the mapping bound it to `move.prone`; the projector dropped every
  Ctrl event from the *frames* plane. The raw `events` table is complete — reconstruct held
  state from `events` if you need `move.prone` in batch 1. Batch 2 recorded under the corrected
  contract and does not have this issue.
- **Excluded sessions** (present in the source mirror, not shipped — recording invariant
  violations, listed for transparency): one batch-1 session (frame drop detected), and three
  batch-2 sessions: `dev-1785469615445-0002` (GPU-copy exceeded the 60 fps budget),
  `dev-1785470527520-0004` (input arming failed, zero segments),
  `dev-1785470017742-0003` (run declares 50 segments, mirror holds 49 — tail segment absent).
- **fps differs between batches** (30 vs 60): frame-count statistics are not comparable across
  batches without normalising; join through time (`run_t_us` / `t_utc_est`), not frame indices.
- Encoder normalisation by the NVIDIA driver (GOP, low-latency flags) is recorded per segment
  in the source metadata; `mean_bitrate_bps` in `segments` reflects the effective encoder.
- MP4s are not faststart (moov at tail); remote streaming readers need the tail first.

## Privacy

Input device identifiers are salted per-device hashes (e.g. `mouse:0b5c…`) and are not
reversible. No account names, chat, or user interface outside the game window is captured.
Batch-2 audio is process-loopback only — it contains game audio, not microphone input.