README.md

metadata

pretty_name: Diogenes CoD Sample v01
license: other
license_name: proprietary-internal-non-trainable
language:
  - en
tags:
  - video
  - gameplay
  - human-demonstration
  - keyboard-mouse
  - action-annotation
  - non-trainable
size_categories:
  - n<1K
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 CoD 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 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_id attached.

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_est is 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.