Request access to Diogenes CoD Sample v01
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.
Log in or Sign Up to review the conditions and access this dataset content.
Diogenes CoD Sample v01
A sample dataset. PC gameplay recording at 1920×1080 @ 30 fps, H.264, with frame-aligned keyboard/mouse action annotations.
This is a sample — the recording output available at the time of publication, which is 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_idattached.
Permitted: inspecting recording quality, validating the annotation schema, and reviewing time-alignment between video frames and input events.
Contents
| Sessions | 19 |
| Runs | 20 |
| Segments | 857 (10 s each) |
| Duration | 2.36 h (141 min) |
| Frames | 254,587 @ 30 fps |
| Input events | 402,692 |
| Video | 15.73 GiB, H.264, ~16 Mb/s |
| Resolution | 1920×1080 |
Frames carrying at least one input signal: 187,015 / 254,587 (73.5%). Duplicate frames: 336 (0.132%). Every video verifies against its recorded SHA-256.
Run termination reasons: foreground_lost 857 (per segment).
Dataset structure
Three parquet tables plus the media, joinable on (session_id, run_id, segment_id):
data/segments.parquet 857 rows one row per 10-second segment (index table)
data/frames.parquet 254,587 rows one row per video frame, with action labels
data/events.parquet 402,692 rows one row per raw input event
videos/<session_id>/<run_id>/<segment_id>.mp4
metadata/ catalog and profile documents, verbatim
metadata/sessions/ per-session session.json
segments fields
| field | type | description |
|---|---|---|
session_id, run_id, segment_id |
string | join key |
segment_index |
int32 | ordinal within the run |
video_path |
string | repo-relative path to the mp4 |
video_bytes, video_sha256 |
int64, string | integrity |
num_frames, num_events, duration_s |
int32, int32, float64 | volume |
width, height, fps |
int32, int32, float64 | video geometry |
game_id, catalog_id, catalog_version, catalog_mode |
string | provenance |
mapping_id, mapping_version |
string | action-mapping identity |
mean_bitrate_bps |
int64 | mean video bitrate |
run_state, run_stop_reason |
string | run outcome |
non_trainable, production_certified |
bool | compliance flags, verbatim |
qpc_start, qpc_end |
int64 | segment bounds on the capture timebase |
run_anchor_qpc, qpc_frequency |
int64 | the run's timebase origin and tick rate (10 MHz) |
run_t_us |
int64 | segment start, µs since the run anchor |
t_utc_est |
timestamp[µs, UTC] | segment start, estimated wall clock (see Time model) |
Time model
Three coordinates are carried on both the frames and events tables, so neither
has to be reconstructed from the other:
| coordinate | scope | use it for |
|---|---|---|
qpc / output_qpc_start,output_qpc_end |
run | the authoritative timebase: a 10 MHz monotonic tick |
video_t_us |
segment | seeking inside the segment's mp4; the coordinate the video itself uses |
run_t_us |
run | comparing across segments, which video_t_us cannot do |
t_utc_est |
absolute | wall clock — an estimate, see the caveat below |
Attributing an event to a frame is a half-open interval on the capture timebase:
frame_events = events[(events.qpc >= frame.output_qpc_start) &
(events.qpc < frame.output_qpc_end)]
Frame windows tile the segment with no gaps, each spanning exactly one frame period.
The same attribution is also precomputed in frames.frame_events_json — but note that
the precomputed view is a state-change view: keyboard auto-repeat (the stream of
key_down events the OS emits while a key is held) is collapsed there, because keys
already carries the held state. The events table is the raw stream and keeps every
repeat, so it holds more rows than sum(num_frame_events).
t_utc_estis derived, not recorded. The capture output contains no wall clock anywhere; this column is reconstructed per session from the epoch-ms embedded in the session id, anchored at the run's timebase origin. Across the session-to-session intervals in this corpus the reconstruction holds to ±0.06 s, but it carries an unknown constant bias — the delay between session creation and the first captured frame. Treat it as an estimate for ordering and coarse dating, never as a recorded capture timestamp.
frames fields
One row per rendered frame, aligned to the video by video_t_us.
| field | type | description |
|---|---|---|
frame, session_frame |
int32 | index within segment / within session |
video_t_us |
int64 | presentation timestamp, µs from segment start |
run_t_us |
int64 | µs from the run anchor — use this to compare across segments |
t_utc_est |
timestamp[µs, UTC] | estimated wall clock (see Time model) |
output_qpc_start, output_qpc_end |
int64 | half-open event-aggregation window for this frame |
source_qpc, source_seq |
int64 | the observation this frame actually came from; a duplicate frame reuses the previous source |
keys |
list[int32] | Windows virtual-key codes held on this frame |
actions |
list[string] | semantic actions from the mapping (see below) |
pointer_dx, pointer_dy |
int32 | relative mouse delta for this frame |
pointer_bins |
list[int32] | quantized pointer delta under contract dm-1 |
duplicate |
bool | frame repeated because no new source frame was available |
queue_drop, source_superseded |
int32 | pipeline health counters |
num_frame_events, frame_events_json |
int32, string | events attributed to this frame |
Semantic actions, by frame count:
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
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).
events fields
Raw input stream at full device resolution — finer-grained than the per-frame view.
| field | type | description |
|---|---|---|
seq |
int64 | monotonic sequence within the run |
qpc |
int64 | high-resolution timebase tick (10 MHz) |
video_t_us |
int64 | µs from segment start — the same coordinate frames uses |
run_t_us |
int64 | µs from the run anchor |
t_utc_est |
timestamp[µs, UTC] | estimated wall clock (see Time model) |
type |
string | event kind (see mix below) |
device |
string | salted per-device hash, e.g. mouse:0b5c… — not reversible |
vk, scan_code, flags |
int32 | keyboard event detail |
dx, dy, absolute |
int32, int32, bool | pointer motion |
Event mix: mouse_move 357,321 · key_down 37,518 · key_up 4,420 · mouse_down 1,702 · mouse_up 1,702 · wheel 29.
Usage
from datasets import load_dataset
segments = load_dataset("DiogenesLab/Diogenes_COD_sample_v01", "segments", split="sample")
frames = load_dataset("DiogenesLab/Diogenes_COD_sample_v01", "frames", split="sample")
events = load_dataset("DiogenesLab/Diogenes_COD_sample_v01", "events", split="sample")
print(segments[0]["video_path"], segments[0]["duration_s"])
Video files are not embedded in the parquet — fetch them by path:
from huggingface_hub import hf_hub_download
path = hf_hub_download(
"DiogenesLab/Diogenes_COD_sample_v01",
segments[0]["video_path"],
repo_type="dataset",
)
Recording methodology
Recording covers the game window only — no desktop, no other windows, no audio. 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. Runs terminate when the game window loses foreground; a run that detects any dropped frame is failed and discarded wholesale rather than repaired — one such run was excluded from this release for that reason.
Privacy
No audio, no webcam, no desktop capture, and no keystrokes outside the game's declared input contract. Device identifiers are salted hashes. The recording reflects a single internal operator; no third-party personal data is present.
Provenance
| Catalog mode | dev_non_trainable (v2026-07-24.5) |
| Game profile | call-of-duty-steam-release-test v5 |
| Mapping | game.call-of-duty.steam.pc v2026-07-24.2 |
| Input contract | dm-1 (pointer_clamp 200, pointer_mu 8, pointer_max_bin 10) |
Citation
Internal sample; not for citation. Contact Diogenes Lab for access questions.
- Downloads last month
- 19