README.md

---
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:

```python
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

```python
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:

```python
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.