Oratis commited on
Commit
8ad3383
·
verified ·
1 Parent(s): f643aab

README: batch-2 (60fps + audio) — totals, audio columns, repeat field, time-model update, known caveats

Browse files
Files changed (1) hide show
  1. README.md +113 -135
README.md CHANGED
@@ -6,13 +6,14 @@ language:
6
  - en
7
  tags:
8
  - video
 
9
  - gameplay
10
  - human-demonstration
11
  - keyboard-mouse
12
  - action-annotation
13
  - non-trainable
14
  size_categories:
15
- - n<1K
16
  configs:
17
  - config_name: segments
18
  default: true
@@ -42,12 +43,17 @@ extra_gated_fields:
42
 
43
  # Diogenes CoD Sample v01
44
 
45
- **A sample dataset.** PC gameplay recording at 1920×1080 @ 30 fps, H.264, with
46
- **frame-aligned keyboard/mouse action annotations**.
47
 
48
- This is a *sample* — the recording output available at the time of publication, which is a
49
- small early slice of an ongoing capture effort, not a complete or representative corpus.
50
- It exists so collaborators can evaluate recording quality, annotation schema, and
 
 
 
 
 
51
  time-alignment fidelity. Expect the shape of the data to change in later versions.
52
 
53
  ## ⚠️ Not for model training
@@ -73,132 +79,97 @@ time-alignment between video frames and input events.
73
 
74
  ## Contents
75
 
76
- | | |
77
- |---|---|
78
- | Sessions | 19 |
79
- | Runs | 20 |
80
- | Segments | 857 (10 s each) |
81
- | Duration | 2.36 h (141 min) |
82
- | Frames | 254,587 @ 30 fps |
83
- | Input events | 402,692 |
84
- | Video | 15.73 GiB, H.264, ~16 Mb/s |
85
- | Resolution | 1920×1080 |
86
-
87
- Frames carrying at least one input signal: 187,015 / 254,587 (73.5%).
88
- Duplicate frames: 336 (0.132%). Every video verifies against its recorded SHA-256.
89
-
90
- Run termination reasons: `foreground_lost` 857 (per segment).
91
 
92
  ## Dataset structure
93
 
94
  Three parquet tables plus the media, joinable on `(session_id, run_id, segment_id)`:
95
 
96
  ```
97
- data/segments.parquet 857 rows one row per 10-second segment (index table)
98
- data/frames.parquet 254,587 rows one row per video frame, with action labels
99
- data/events.parquet 402,692 rows one row per raw input event
100
  videos/<session_id>/<run_id>/<segment_id>.mp4
101
- metadata/ catalog and profile documents, verbatim
 
 
 
102
  metadata/sessions/ per-session session.json
103
  ```
104
 
 
 
 
 
105
  ### `segments` fields
106
 
 
 
107
  | field | type | description |
108
  |---|---|---|
109
- | `session_id`, `run_id`, `segment_id` | string | join key |
110
- | `segment_index` | int32 | ordinal within the run |
111
- | `video_path` | string | repo-relative path to the mp4 |
112
- | `video_bytes`, `video_sha256` | int64, string | integrity |
113
- | `num_frames`, `num_events`, `duration_s` | int32, int32, float64 | volume |
114
- | `width`, `height`, `fps` | int32, int32, float64 | video geometry |
115
- | `game_id`, `catalog_id`, `catalog_version`, `catalog_mode` | string | provenance |
116
- | `mapping_id`, `mapping_version` | string | action-mapping identity |
117
- | `mean_bitrate_bps` | int64 | mean video bitrate |
118
- | `run_state`, `run_stop_reason` | string | run outcome |
119
- | `non_trainable`, `production_certified` | bool | compliance flags, verbatim |
120
- | `qpc_start`, `qpc_end` | int64 | segment bounds on the capture timebase |
121
- | `run_anchor_qpc`, `qpc_frequency` | int64 | the run's timebase origin and tick rate (10 MHz) |
122
- | `run_t_us` | int64 | segment start, µs since the run anchor |
123
- | `t_utc_est` | timestamp[µs, UTC] | segment start, estimated wall clock (see *Time model*) |
124
 
125
  ## Time model
126
 
127
- Three coordinates are carried on **both** the `frames` and `events` tables, so neither
128
- has to be reconstructed from the other:
 
 
 
129
 
130
- | coordinate | scope | use it for |
131
- |---|---|---|
132
- | `qpc` / `output_qpc_start`,`output_qpc_end` | run | the authoritative timebase: a 10 MHz monotonic tick |
133
- | `video_t_us` | segment | seeking inside the segment's mp4; the coordinate the video itself uses |
134
- | `run_t_us` | run | comparing across segments, which `video_t_us` cannot do |
135
- | `t_utc_est` | absolute | wall clock — **an estimate**, see the caveat below |
136
 
137
- **Attributing an event to a frame** is a half-open interval on the capture timebase:
138
 
139
- ```python
140
- frame_events = events[(events.qpc >= frame.output_qpc_start) &
141
- (events.qpc < frame.output_qpc_end)]
142
- ```
143
 
144
- Frame windows tile the segment with no gaps, each spanning exactly one frame period.
145
- The same attribution is also precomputed in `frames.frame_events_json` — but note that
146
- the precomputed view is a **state-change** view: keyboard auto-repeat (the stream of
147
- `key_down` events the OS emits while a key is held) is collapsed there, because `keys`
148
- already carries the held state. The `events` table is the raw stream and keeps every
149
- repeat, so it holds more rows than `sum(num_frame_events)`.
150
-
151
- > **`t_utc_est` is derived, not recorded.** The capture output contains no wall clock
152
- > anywhere; this column is reconstructed per session from the epoch-ms embedded in the
153
- > session id, anchored at the run's timebase origin. Across the session-to-session
154
- > intervals in this corpus the reconstruction holds to ±0.06 s, but it carries an
155
- > unknown *constant* bias — the delay between session creation and the first captured
156
- > frame. Treat it as an estimate for ordering and coarse dating, never as a recorded
157
- > capture timestamp.
158
 
159
- ### `frames` fields
 
160
 
161
- One row per rendered frame, aligned to the video by `video_t_us`.
162
-
163
- | field | type | description |
164
- |---|---|---|
165
- | `frame`, `session_frame` | int32 | index within segment / within session |
166
- | `video_t_us` | int64 | presentation timestamp, µs from segment start |
167
- | `run_t_us` | int64 | µs from the run anchor — use this to compare across segments |
168
- | `t_utc_est` | timestamp[µs, UTC] | estimated wall clock (see *Time model*) |
169
- | `output_qpc_start`, `output_qpc_end` | int64 | half-open event-aggregation window for this frame |
170
- | `source_qpc`, `source_seq` | int64 | the observation this frame actually came from; a duplicate frame reuses the previous source |
171
- | `keys` | list[int32] | Windows virtual-key codes held on this frame |
172
- | `actions` | list[string] | semantic actions from the mapping (see below) |
173
- | `pointer_dx`, `pointer_dy` | int32 | relative mouse delta for this frame |
174
- | `pointer_bins` | list[int32] | quantized pointer delta under contract `dm-1` |
175
- | `duplicate` | bool | frame repeated because no new source frame was available |
176
- | `queue_drop`, `source_superseded` | int32 | pipeline health counters |
177
- | `num_frame_events`, `frame_events_json` | int32, string | events attributed to this frame |
178
-
179
- Semantic actions, by frame count:
180
-
181
- `camera.yaw` 101,590 · `move.forward` 94,535 · `camera.pitch` 89,280 · `combat.aim` 56,380 · `move.left` 21,285 · `move.right` 20,530 · `combat.primary_attack` 11,106 · `move.sprint` 10,367 · `combat.tactical_equipment` 5,146 · `move.backward` 1,655 · `interact.use` 1,427 · `combat.lethal_equipment` 1,220 · `move.jump_mantle` 755 · `combat.killstreak_slot_2` 682 · `move.crouch_slide` 586
182
-
183
- Most frequent virtual-key codes: 87 `W` (93,509) · 65 `A` (20,282) · 68 `D` (19,484) · 16 `Shift` (10,001) · 81 `Q` (5,075) · 83 `S` (1,580) · 70 `F` (1,250) · 69 `E` (1,178) · 52 `?` (663) · 32 `Space` (620).
184
 
185
  ### `events` fields
186
 
187
- Raw input stream at full device resolution — finer-grained than the per-frame view.
188
 
189
  | field | type | description |
190
  |---|---|---|
191
- | `seq` | int64 | monotonic sequence within the run |
192
- | `qpc` | int64 | high-resolution timebase tick (10 MHz) |
193
- | `video_t_us` | int64 | µs from segment start — the same coordinate `frames` uses |
194
- | `run_t_us` | int64 | µs from the run anchor |
195
- | `t_utc_est` | timestamp[µs, UTC] | estimated wall clock (see *Time model*) |
196
- | `type` | string | event kind (see mix below) |
197
- | `device` | string | salted per-device hash, e.g. `mouse:0b5c…` — not reversible |
198
- | `vk`, `scan_code`, `flags` | int32 | keyboard event detail |
199
- | `dx`, `dy`, `absolute` | int32, int32, bool | pointer motion |
200
-
201
- Event mix: `mouse_move` 357,321 · `key_down` 37,518 · `key_up` 4,420 · `mouse_down` 1,702 · `mouse_up` 1,702 · `wheel` 29.
202
 
203
  ## Usage
204
 
@@ -209,48 +180,55 @@ segments = load_dataset("DiogenesLab/Diogenes_COD_sample_v01", "segments", split
209
  frames = load_dataset("DiogenesLab/Diogenes_COD_sample_v01", "frames", split="sample")
210
  events = load_dataset("DiogenesLab/Diogenes_COD_sample_v01", "events", split="sample")
211
 
212
- print(segments[0]["video_path"], segments[0]["duration_s"])
 
213
  ```
214
 
215
- Video files are not embedded in the parquet — fetch them by path:
216
 
217
  ```python
218
  from huggingface_hub import hf_hub_download
219
 
220
- path = hf_hub_download(
221
- "DiogenesLab/Diogenes_COD_sample_v01",
222
- segments[0]["video_path"],
223
- repo_type="dataset",
224
- )
225
  ```
226
 
227
  ## Recording methodology
228
 
229
- Recording covers the game window only — no desktop, no other windows, no audio. Input is
230
- captured at full device resolution in relative-pointer mode, restricted to the key and button
231
- set declared in the game profile's input contract.
232
-
233
- Video frames and input events share a single high-resolution timebase, which is what makes
234
- per-frame action attribution exact rather than interpolated. Segments are 10 s and independently
235
- hashed. Runs terminate when the game window loses foreground; a run that detects any dropped
236
- frame is failed and discarded wholesale rather than repaired — one such run was excluded from
237
- this release for that reason.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
238
 
239
  ## Privacy
240
 
241
- No audio, no webcam, no desktop capture, and no keystrokes outside the game's declared input
242
- contract. Device identifiers are salted hashes. The recording reflects a single internal
243
- operator; no third-party personal data is present.
244
-
245
- ## Provenance
246
-
247
- | | |
248
- |---|---|
249
- | Catalog mode | `dev_non_trainable` (v2026-07-24.5) |
250
- | Game profile | `call-of-duty-steam-release-test` v5 |
251
- | Mapping | `game.call-of-duty.steam.pc` v2026-07-24.2 |
252
- | Input contract | `dm-1` (pointer_clamp 200, pointer_mu 8, pointer_max_bin 10) |
253
-
254
- ## Citation
255
-
256
- Internal sample; not for citation. Contact Diogenes Lab for access questions.
 
6
  - en
7
  tags:
8
  - video
9
+ - audio
10
  - gameplay
11
  - human-demonstration
12
  - keyboard-mouse
13
  - action-annotation
14
  - non-trainable
15
  size_categories:
16
+ - 1K<n<10K
17
  configs:
18
  - config_name: segments
19
  default: true
 
43
 
44
  # Diogenes CoD Sample v01
45
 
46
+ **A sample dataset.** PC gameplay recordings with **frame-aligned keyboard/mouse action
47
+ annotations**, in two batches:
48
 
49
+ | batch | recorded | video | audio |
50
+ |---|---|---|---|
51
+ | **batch 1** | 2026-07-25/26 | 1920×1080 @ **30 fps**, H.264 | none |
52
+ | **batch 2** | 2026-07-31 | 1920×1080 @ **60 fps**, H.264 | **process-loopback system audio**, 48 kHz stereo s16le (zstd-compressed PCM) |
53
+
54
+ This is a *sample* — the recording output available at the time of publication, a small
55
+ early slice of an ongoing capture effort, not a complete or representative corpus. It
56
+ exists so collaborators can evaluate recording quality, annotation schema, and
57
  time-alignment fidelity. Expect the shape of the data to change in later versions.
58
 
59
  ## ⚠️ Not for model training
 
79
 
80
  ## Contents
81
 
82
+ | | total | batch 1 (30 fps) | batch 2 (60 fps + audio) |
83
+ |---|---|---|---|
84
+ | Sessions | 35 | 19 | 16 |
85
+ | Runs | 36 | 20 | 16 |
86
+ | Segments (10 s each) | 1,787 | 857 | 930 |
87
+ | Duration | **4.92 h** | 2.36 h | 2.56 h |
88
+ | Frames | 807,309 | 254,587 | 552,722 |
89
+ | Input events | 858,161 | 402,692 | 455,469 |
90
+ | Video | 32.7 GiB | 15.7 GiB | 17.0 GiB |
91
+ | Audio segments | 865 | — | 865 (1.37 GiB compressed PCM) |
92
+
93
+ Frames carrying at least one input signal: 540,849 / 807,309 (67.0%).
94
+ Duplicate frames: 6,295 (0.78% — 0.13% in batch 1, 1.08% in batch 2; at 60 fps WGC re-serves
95
+ a frame whenever the game renders below 60). Every video and audio object verifies against
96
+ its recorded SHA-256. Run termination: `foreground_lost` × 36 (all runs).
97
 
98
  ## Dataset structure
99
 
100
  Three parquet tables plus the media, joinable on `(session_id, run_id, segment_id)`:
101
 
102
  ```
103
+ data/segments.parquet 1,787 rows one row per 10-second segment (index table)
104
+ data/frames.parquet 807,309 rows one row per video frame, with action labels
105
+ data/events.parquet 858,161 rows one row per raw input event
106
  videos/<session_id>/<run_id>/<segment_id>.mp4
107
+ audio/<session_id>/<run_id>/<segment_id>.pcm.zst (batch 2 only; verbatim capture bytes)
108
+ metadata/ catalog and profile documents for batch 1, verbatim (kept in place)
109
+ metadata/catalog-2026-07-30.0/ batch-2 pre-audio catalog documents, verbatim
110
+ metadata/catalog-2026-07-31.0/ batch-2 audio catalog documents, verbatim
111
  metadata/sessions/ per-session session.json
112
  ```
113
 
114
+ Audio decodes to exactly `audio_frames × 4` bytes of interleaved stereo s16le PCM at 48 kHz
115
+ (`zstd -d < seg.pcm.zst`). Segment audio SHA-256, byte counts and health metadata live in the
116
+ `segments` table (`audio_*` columns, null for batch 1).
117
+
118
  ### `segments` fields
119
 
120
+ Batch-1 fields are unchanged from the original release. Added (nullable, batch 2 only):
121
+
122
  | field | type | description |
123
  |---|---|---|
124
+ | `audio_path` | string | repo-relative path to the `.pcm.zst` object |
125
+ | `audio_bytes` | int64 | compressed size (bytes) |
126
+ | `audio_sha256` | string | SHA-256 of the compressed object |
127
+ | `audio_frames` | int64 | PCM frames (samples per channel) |
128
+ | `audio_sample_rate`, `audio_channels` | int32 | 48000 / 2 |
129
+ | `audio_state` | string | `ready` for all shipped segments |
130
+
131
+ All other fields as before: join key, `video_path`/`video_bytes`/`video_sha256`,
132
+ `num_frames`/`num_events`/`duration_s`, geometry (`width`/`height`/`fps` — **30.0 or 60.0**),
133
+ provenance (`game_id`, `catalog_id`, `catalog_version`, `catalog_mode`, `mapping_id`,
134
+ `mapping_version`), `mean_bitrate_bps`, run outcome, compliance flags, and the time model
135
+ (`qpc_start`/`qpc_end`/`run_anchor_qpc`/`qpc_frequency`/`run_t_us`/`t_utc_est`).
 
 
 
136
 
137
  ## Time model
138
 
139
+ Unchanged for batch 1. **Batch 2 improvement**: the capture client now records the run's
140
+ wall-clock anchor (`anchorAtUtc`) next to its QPC anchor, so batch-2 `t_utc_est` is anchored
141
+ on a **recorded** timestamp rather than reconstructed from the session-id epoch. The constant
142
+ bias caveat from batch 1 does not apply to batch 2; sub-millisecond alignment within a run is
143
+ still governed by the QPC timebase, which is authoritative in both batches.
144
 
145
+ Frame windows tile each segment with no gaps (`output_qpc_start`/`output_qpc_end`, half-open).
146
+ Event-to-frame attribution and the precomputed `frame_events_json` state-change view work
147
+ exactly as in the original release; keyboard auto-repeat is collapsed there because `keys`
148
+ carries held state.
 
 
149
 
150
+ ### `frames` fields
151
 
152
+ Unchanged schema. At 60 fps, full segments hold 600 frames instead of 300.
 
 
 
153
 
154
+ Semantic actions, by frame count (whole corpus; batches differ in fps, so frame counts are
155
+ not comparable across batches without normalising):
 
 
 
 
 
 
 
 
 
 
 
 
156
 
157
+ `move.forward` 320,963 · `camera.yaw` 302,276 · `camera.pitch` 255,844 · `combat.aim` 165,921 ·
158
+ `move.right` 75,080 · `move.left` 69,920 · `combat.primary_attack` 31,334 · `move.sprint` 29,720
159
 
160
+ Most frequent virtual-key codes: 87 `W` (318,572) · 68 `D` (72,667) · 65 `A` (67,738) ·
161
+ 16 `Shift` (28,893) · 81 `Q` (15,778) · 69 `E` (11,709) · 83 `S` (7,006) · 32 `Space` (4,397).
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
162
 
163
  ### `events` fields
164
 
165
+ Unchanged schema, plus one added nullable field:
166
 
167
  | field | type | description |
168
  |---|---|---|
169
+ | `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. |
170
+
171
+ Event mix (whole corpus): `mouse_move` 760,361 · `key_down` 80,085 · `key_up` 10,102 ·
172
+ `mouse_down` 3,777 · `mouse_up` 3,776 · `wheel` 60.
 
 
 
 
 
 
 
173
 
174
  ## Usage
175
 
 
180
  frames = load_dataset("DiogenesLab/Diogenes_COD_sample_v01", "frames", split="sample")
181
  events = load_dataset("DiogenesLab/Diogenes_COD_sample_v01", "events", split="sample")
182
 
183
+ audio_segs = segments.filter(lambda r: r["audio_state"] == "ready")
184
+ print(len(audio_segs), audio_segs[0]["audio_path"])
185
  ```
186
 
187
+ Media files are not embedded in the parquet — fetch them by path:
188
 
189
  ```python
190
  from huggingface_hub import hf_hub_download
191
 
192
+ path = hf_hub_download("DiogenesLab/Diogenes_COD_sample_v01",
193
+ segments[0]["video_path"], repo_type="dataset")
 
 
 
194
  ```
195
 
196
  ## Recording methodology
197
 
198
+ Recording covers the game window only — no desktop, no other windows. Input is captured at
199
+ full device resolution in relative-pointer mode, restricted to the key and button set declared
200
+ in the game profile's input contract. Video frames and input events share a single
201
+ high-resolution timebase, which is what makes per-frame action attribution exact rather than
202
+ interpolated. Segments are 10 s and independently hashed.
203
+
204
+ Batch 2 additionally captures **process-loopback system audio** (the game process's own
205
+ output, not the microphone): 48 kHz stereo s16le, zstd-compressed per segment, hashed into the
206
+ same per-segment integrity manifest. Audio health counters (queue overflows, discontinuities,
207
+ silence fill, timestamp errors) were zero across all shipped segments.
208
+
209
+ Runs terminate when the game window loses foreground. A run that fails its recording
210
+ invariants is discarded wholesale rather than repaired.
211
+
212
+ ## Known caveats (read before consuming)
213
+
214
+ - **Batch-1 frames plane is missing all Ctrl input.** The capture-time configuration declared
215
+ Ctrl a control key while the mapping bound it to `move.prone`; the projector dropped every
216
+ Ctrl event from the *frames* plane. The raw `events` table is complete — reconstruct held
217
+ state from `events` if you need `move.prone` in batch 1. Batch 2 recorded under the corrected
218
+ contract and does not have this issue.
219
+ - **Excluded sessions** (present in the source mirror, not shipped — recording invariant
220
+ violations, listed for transparency): one batch-1 session (frame drop detected), and three
221
+ batch-2 sessions: `dev-1785469615445-0002` (GPU-copy exceeded the 60 fps budget),
222
+ `dev-1785470527520-0004` (input arming failed, zero segments),
223
+ `dev-1785470017742-0003` (run declares 50 segments, mirror holds 49 — tail segment absent).
224
+ - **fps differs between batches** (30 vs 60): frame-count statistics are not comparable across
225
+ batches without normalising; join through time (`run_t_us` / `t_utc_est`), not frame indices.
226
+ - Encoder normalisation by the NVIDIA driver (GOP, low-latency flags) is recorded per segment
227
+ in the source metadata; `mean_bitrate_bps` in `segments` reflects the effective encoder.
228
+ - MP4s are not faststart (moov at tail); remote streaming readers need the tail first.
229
 
230
  ## Privacy
231
 
232
+ Input device identifiers are salted per-device hashes (e.g. `mouse:0b5c…`) and are not
233
+ reversible. No account names, chat, or user interface outside the game window is captured.
234
+ Batch-2 audio is process-loopback only — it contains game audio, not microphone input.