Showcase media (gifs + 720p mp4s) and Video(decode=False) snippets

README.md

@@ -18,486 +18,209 @@ tags:
 - audio
 - esports
 size_categories:
-- 10M<n<100M
+- 10K<n<100K
+configs:
+- config_name: manifest
+  data_files:
+  - split: metadata
+    path: manifest.parquet
+- config_name: rounds
+  data_files:
+  - split: metadata
+    path: round_index.parquet
+- config_name: matches
+  data_files:
+  - split: metadata
+    path: match_index.parquet
+- config_name: subsets
+  data_files:
+  - split: train_10h
+    path: subsets/train_10h.parquet
+  - split: train_50h
+    path: subsets/train_50h.parquet
+  - split: train_100h
+    path: subsets/train_100h.parquet
+  - split: train_500h
+    path: subsets/train_500h.parquet
+  - split: train_1000h
+    path: subsets/train_1000h.parquet
+  - split: train_all
+    path: subsets/train_all.parquet
+  - split: dust2_100h
+    path: subsets/dust2_100h.parquet
+  - split: full_demo_eval
+    path: subsets/full_demo_eval.parquet
 ---
 
 # CounterStrike-1K
 
-CounterStrike-1K is a large-scale, synchronized multi-POV Counter-Strike 2 dataset for world modeling and action-conditioned video prediction. The primary QA-filtered round-level release lock contains **1,490.82 rendered player-POV hours** from professional CS2 match-map demos, with exactly 10 synchronized player perspectives per released round. A strict full-demo chronology lock is also provided as a subset for evaluations that require complete demo-map timelines. Each sample contains rendered POV video with synchronized stereo game audio, per-frame controls, per-frame player/game state, sparse gameplay events, and public metadata.
+<p align="center">
+  <img src="media/multi_pov_with_actions.gif" alt="10 synchronized POVs with per-frame action HUD overlays" width="100%"/>
+</p>
 
-Raw HLTV demo files are **not** redistributed. The public release contains derived, anonymized artifacts only: video/audio, action/state records, sparse event records, public metadata, release indices, and supplemental derived game traces.
+**1,490 rendered POV-hours · 7,347 synchronized rounds · 73,470 POV clips · 7 maps · 720p + audio**
 
-## Quickstart
+<table align="center">
+  <tr>
+    <td align="center" width="50%"><img src="media/seven_maps.gif" alt="Seven active-duty maps" width="100%"/><br/><sub>Seven active-duty maps</sub></td>
+    <td align="center" width="50%"><img src="media/introduction_video_wall_1000_hours.gif" alt="100+ POV video wall — 1,000 hours" width="100%"/><br/><sub>Scale: 1,000-hour POV wall</sub></td>
+  </tr>
+</table>
 
-Install the basic loading tools:
+CounterStrike-1K is the first grounded, professional-grade Counter-Strike 2 dataset with **10 synchronized first-person perspectives per round**, captured from professional match demos. It is designed for video world modeling, action-conditioned video prediction, multi-view consistency research, and audio-conditioned learning.
 
-```bash
-pip install huggingface_hub webdataset pyarrow pandas numpy
-git clone https://github.com/AnirudhhRamesh/CounterStrike-1K
-cd CounterStrike-1K
-pip install -e .
-```
-
-Download the small sample release:
+## Quickstart
 
-```python
-from pathlib import Path
-from huggingface_hub import snapshot_download
+Start a fresh `uv` project and add the loader:
 
-root = Path(snapshot_download(
-    repo_id="ArnieRamesh/CounterStrike-1K-sample",
-    repo_type="dataset",
-))
-print(root)
+```bash
+mkdir cs1k-demo && cd cs1k-demo
+uv init
+uv add datasets "counterstrike1k @ git+https://github.com/AnirudhhRamesh/counterstrike1k"
 ```
 
-Load the sample inventory:
-
-```python
-import pyarrow.parquet as pq
+<details>
+<summary>Using pip instead</summary>
 
-manifest = pq.read_table(root / "manifest.parquet").to_pandas()
-print(manifest[["sample_key", "map_slug", "split", "round_id", "pov_idx", "duration_s", "frames"]].head())
+```bash
+mkdir cs1k-demo && cd cs1k-demo
+python -m venv .venv && source .venv/bin/activate
+pip install datasets "counterstrike1k @ git+https://github.com/AnirudhhRamesh/counterstrike1k"
 ```
+</details>
 
-Use the high-level v12 loader for the normal researcher interface:
+Stream one sample from the public shards — no download required:
 
 ```python
-from counterstrike1k import CounterStrike1K
-
-ds = CounterStrike1K(
-    root=root,
-    subset="sample",        # full release examples: train_100h, dust2_100h, train_all
-    resolution="360p",
-)
-
-sample = next(iter(ds))
-print(sample["metadata"]["sample_key"])
-print(sample["actions"].dtype, sample["state"].dtype)
-print(sample["player_alive"].shape, sample["player_alive"].mean())
-```
+from datasets import Video, load_dataset
+from counterstrike1k import decode_sample
 
-Stream WebDataset shards and decode the v12 control/state binaries:
+shards = load_dataset(
+    "ArnieRamesh/CounterStrike-1K-360-wds", split="train", streaming=True,
+).cast_column("mp4", Video(decode=False))
+sample = decode_sample(next(iter(shards)))
 
-```python
-from pathlib import Path
-import numpy as np
-import webdataset as wds
-
-ACTION_DTYPE = np.dtype([
-    ("tick", "<u4"),
-    ("delta_pitch", "<f4"),
-    ("delta_yaw", "<f4"),
-    ("buttons", "<u2"),
-])
-
-STATE_DTYPE = np.dtype([
-    ("tick", "<u4"), ("pitch", "<f4"), ("yaw", "<f4"),
-    ("pos_x", "<f4"), ("pos_y", "<f4"), ("pos_z", "<f4"),
-    ("active_weapon", "u1"), ("active_weapon_id", "u1"),
-    ("ammo_clip", "u1"), ("ammo_reserve", "u1"),
-    ("health", "u1"), ("armor_value", "u1"), ("balance", "<u2"),
-    ("t_score", "u1"), ("ct_score", "u1"),
-    ("has_helmet", "u1"), ("has_defuser", "u1"), ("has_bomb", "u1"),
-])
-
-shards = sorted(str(path) for path in Path(root).glob("shards-360p/**/*.tar"))
-dataset = (
-    wds.WebDataset(shards)
-    .decode(wds.torch_video)
-    .to_tuple("mp4", "actions.bin", "state.bin", "events.json", "json")
-)
-
-video, actions_bin, state_bin, events, metadata = next(iter(dataset))
-actions = np.frombuffer(actions_bin, dtype=ACTION_DTYPE)
-state = np.frombuffer(state_bin, dtype=STATE_DTYPE)
-player_alive = (
-    (state["tick"].astype(np.int64) >= metadata["alive_start_tick"])
-    & (state["tick"].astype(np.int64) < metadata["alive_end_tick"])
-)
-print(metadata["sample_key"], video.shape, actions.shape, state.shape, player_alive.mean())
+print(sample["actions"].shape)   # (frames,) tick, delta_pitch, delta_yaw, buttons bitmask
+print(sample["state"].shape)     # (frames,) pos, view, weapon, ammo, hp, money, score, …
+print(len(sample["video"]))      # mp4 bytes with synchronized audio
 ```
 
-Load a synchronized round:
+Browse the manifest:
 
 ```python
-round_index = pq.read_table(root / "round_index.parquet").to_pandas()
-manifest = pq.read_table(root / "manifest.parquet").to_pandas()
-complete = round_index[round_index["complete_10_pov"]].iloc[0]
-round_samples = (
-    manifest[manifest["round_id"] == complete["round_id"]]
-    .sort_values("pov_idx")
-)
-print(complete["round_id"], round_samples["sample_key"].tolist())
-```
-
-Browse release statistics locally:
+import pandas as pd
+from huggingface_hub import hf_hub_download
 
-```bash
-uv run --script cs2_generate/serve_release_stats_viewer.py \
-  --s3-prefix s3://counterstrike-1k \
-  --prefer-s3
+manifest = pd.read_parquet(hf_hub_download(
+    "ArnieRamesh/CounterStrike-1K", "manifest.parquet", repo_type="dataset",
+))
+mirage_train = manifest[(manifest["map_slug"] == "mirage") & (manifest["split"] == "train")]
 ```
 
-Open `http://127.0.0.1:8765`. The viewer reads only small JSON metadata files
-from `stats/`, `subsets/`, and `schema/`; it does not download shards or videos.
-
-## How To Use
-
-The normal training interface is a dictionary with decoded video plus the paired control/state arrays:
+Tiny offline preview (one match, ~2 GB):
 
 ```python
-sample = {
-    "video": video,
-    "actions": actions,
-    "state": state,
-    "events": events["events"],
-    "metadata": metadata,
-    "player_alive": player_alive,
-}
+from counterstrike1k import load_sample
+for sample in load_sample():
+    print(sample["metadata"]["sample_key"])
+    break
 ```
 
-Filter common research subsets from the manifest:
+Verify that decoded actions actually align with the video — `overlay_frame` draws a HUD with WASD/FIRE/JUMP, mouse delta, HP/armor/money, and score onto any frame:
 
 ```python
-train = manifest[manifest["split"] == "train"]
-
-rifle_mirage = train[
-    (train["map_slug"] == "mirage")
-    & train["has_rifle"]
-    & (train["alive_duration_s"] >= 10.0)
-]
-
-pistol_rounds = round_index[
-    round_index["is_pistol_round"]
-    & round_index["complete_10_pov"]
-    & ~round_index["media_truncated_any_pov"].fillna(False)
-]
-
-awp_clutches = train[
-    train["has_awp"]
-    & (train["pov_kills"] >= 2)
-    & (train["pov_deaths"] == 0)
-]
-
-bomb_rounds = round_index[
-    round_index["bomb_planted"]
-    | round_index["bomb_defused"]
-    | round_index["bomb_exploded"]
-]
-```
-
-Official public subsets are stored under `subsets/` as Parquet views over the shared shards:
-
-| Subset | Meaning |
-|---|---|
-| `train_10h` | Nested train subset, approximately 10 rendered POV-hours. |
-| `train_50h` | Nested train subset, approximately 50 rendered POV-hours. |
-| `train_100h` | Nested train subset, approximately 100 rendered POV-hours. |
-| `train_500h` | Nested train subset, approximately 500 rendered POV-hours. |
-| `train_1000h` | Nested train subset, approximately 1000 rendered POV-hours. |
-| `train_all` | All train-split samples. |
-| `dust2_100h` | Train-only Dust2 subset for DIAMOND-style fixed-budget comparisons. |
-| `full_demo_eval` | Strict full-demo chronology subset for complete demo-map evaluations. |
-
-Subsets do not duplicate media. A subset file lists `sample_key` values; the loader joins those keys to `manifest.parquet` and `sample_index_360p.parquet` / `sample_index_720p.parquet` to stream the required WebDataset shards.
-
-For full training, use the WebDataset shard repositories listed below rather than downloading individual media files.
-
-## What Is Being Released?
-
-The release is split into several Hugging Face dataset repositories:
-
-| Repository | Contents |
-|---|---|
-| `ArnieRamesh/CounterStrike-1K` | Metadata/control repo: dataset card, schema, Croissant metadata, release indices, stats, subsets, and examples. |
-| `ArnieRamesh/CounterStrike-1K-720-wds` | Full 720p WebDataset shards. |
-| `ArnieRamesh/CounterStrike-1K-360-wds` | Full 360p WebDataset shards. |
-| `ArnieRamesh/CounterStrike-1K-sample` | Small unsharded reviewer/developer subset with the same schema and loader API. |
-
-The full releases are provided as uncompressed WebDataset tar shards. The metadata/control repo provides the indices needed for filtering, synchronized round grouping, and random access into shards.
-
-The sample repository is provided for reviewer inspection and quick loader
-validation. It contains one complete 10-POV match-map directly as ordinary
-files rather than WebDataset shards, plus the same `manifest.parquet`,
-`round_index.parquet`, `match_index.parquet`, `subsets/sample.parquet`, schema,
-and loader API used by the full release. This keeps the inspection artifact
-small enough for large-dataset review while making the exact sample construction
-auditable.
-
-## At A Glance
-
-| Property | Value |
-|---|---:|
-| Rendered POV-hours | 1,490.82 |
-| Unique match-map demos | 342 |
-| Rounds | 7,347 |
-| Samples / clips | 73,470 |
-| Video frames | ~171.7M |
-| Unique anonymized player slots | 3,420 match-local slots |
-| Maps | 7 active-duty maps |
-| Player perspectives | Exactly 10 per released round |
-| Frame rate | 32 FPS |
-| Demo tick rate | 64 Hz |
-| Tick/frame alignment | 2 ticks per video frame |
-| Resolutions | 1280x720, 640x360 |
-| 720p shard target | 5 GiB |
-| 360p shard target | 2 GiB |
-| 720p shards | 396 |
-| 360p shards | 864 |
-| `sample_index.parquet` rows | 734,700 |
-| Resolution-specific sample-index rows | 367,350 per resolution |
-| `row_index.parquet` rows | 146,940 |
-| Total compressed size | ~2.73 TB for 720p + 360p WebDataset shards |
-
-Anonymized player slots are counted within match-map demos. The release does not include Steam IDs, online account identifiers, or player names.
-
-## Dataset Statistics
-
-Final media and shard statistics are generated after packing and validation and are stored under `stats/`. The primary training lock is the QA-filtered round-level complete-10-POV lock: 1,490.82 rendered POV-hours, 342 match-map demos, 7,347 rounds, and 73,470 clips. The strict full-demo lock is a chronology-preserving subset with 896.85 rendered POV-hours, 212 match-map demos, 4,467 rounds, and 44,670 clips.
-
-The final split lock manifests are `release/manifest_locks/counterstrike-1k_complete_10pov_v12_final_split_lock.json` and `release/manifest_locks/counterstrike-1k_full_demo_10pov_v12_final_split_lock.json`. Manual QA exclusions are applied from the DynamoDB-backed exclusion ledger; POV-level exclusions are rounded up to the whole round for final 10-POV release locks, and any excluded retained round drops the entire match-map from the strict full-demo chronology lock.
-
-### Per-Map Breakdown
-
-Per-map counts are reported in `stats/maps.json` after the final human-QA lock is applied.
+from counterstrike1k import overlay_frame, overlay_video
 
-### Per-Split Breakdown
-
-| Split | Frames | POV-hours | Match-map demos | Rounds | Samples |
-|---|---:|---:|---:|---:|---:|
-| train | 154,567,749 | 1,341.735 | 301 | 6,573 | 65,730 |
-| val | 8,587,312 | 74.542 | 21 | 383 | 3,830 |
-| test | 8,587,787 | 74.547 | 20 | 391 | 3,910 |
-
-The release also includes summary distributions for sample duration, alive duration, round duration, action frequencies, event counts, round completeness, and shard sizes.
-
-## Gameplay Coverage
-
-CounterStrike-1K covers the seven active-duty CS2 maps used for this release:
-
-- Ancient
-- Anubis
-- Dust2
-- Inferno
-- Mirage
-- Nuke
-- Overpass
-
-The source pool consists of professional CS2 match-map demos. Curation is balanced by rendered player-POV frame count, not raw match count. Final per-map and per-split counts are reported explicitly in `stats/summary.json`.
-
-## Video, Audio, And Encoding Format
-
-| Field | 720p release | 360p release |
-|---|---|---|
-| Container | MP4 | MP4 |
-| Video codec | H.264 | H.264 |
-| Resolution | 1280x720 | 640x360 |
-| Frame rate | 32 FPS | 32 FPS |
-| GOP | Closed GOP, size 32 | Closed GOP, size 32 |
-| B-frames | 0 | 0 |
-| Libx264 re-encode CRF | 20 if re-encoded | 20 |
-| Pixel format | yuv420p | yuv420p |
-| Faststart | enabled | enabled |
-| Audio codec | AAC-LC | AAC-LC |
-| Audio channels | stereo / 2 channels | stereo / 2 channels |
-| Audio sample rate | 44.1 kHz | 44.1 kHz |
-| Audio target bitrate | ~128 kbps | ~128 kbps |
-
-The `yuv420p` pixel format is used for broad decoder compatibility across FFmpeg, browsers, PyAV, torchcodec, OpenCV, and hardware video decoders. Faststart places MP4 metadata at the front of the file, which improves browser playback and HTTP range-read behavior.
-
-The release stores game audio as a standard stereo mix. It does not expose multichannel audio, HRTF parameters, or positional audio metadata. Any directional cues are those produced by CS2 in the rendered stereo output.
-
-The exact render and packing environment is recorded in `stats/release_environment.json`, including encoder settings, schema versions, and packer provenance.
-
-## Dataset Structure
-
-Each WebDataset sample uses a shared `sample_key` prefix:
-
-```text
-{sample_key}.mp4
-{sample_key}.actions.bin
-{sample_key}.state.bin
-{sample_key}.events.json
-{sample_key}.json
+overlay_frame(sample, 60)                          # PIL.Image, ready for display()
+overlay_video(sample, "debug.mp4", max_frames=192) # full debug clip
 ```
 
-Example sample key:
-
-```text
-match_{sha12}__r{round:03d}__p{pov:02d}
-```
-
-The files are:
-
-| Member | Description |
-|---|---|
-| `{sample_key}.mp4` | Rendered POV video with synchronized stereo game audio. |
-| `{sample_key}.actions.bin` | Fixed-width per-frame control records: tick, mouse deltas, and button bitmask. |
-| `{sample_key}.state.bin` | Fixed-width per-frame player/game-state records: view, position, active weapon, ammo, health/armor, side score, equipment flags, bomb flag, and money balance. |
-| `{sample_key}.events.json` | Sparse per-sample gameplay events. |
-| `{sample_key}.json` | Minimal public per-sample metadata sidecar. |
-
-`actions.bin` and `state.bin` are compact fixed-width binary formats rather than JSON or per-sample Parquet. They are dependency-light, directly loadable with `numpy.frombuffer`, and efficient for tens of thousands of small per-sample streams inside tar shards. The authoritative layouts are defined in `schema/actions_bin.json` and `schema/state_bin.json`.
-
-## Public Index Files
-
-| File | Purpose |
-|---|---|
-| `manifest.parquet` | Dataset sample inventory and research/filter columns. |
-| `sample_index.parquet` | Combined physical lookup table for WebDataset members: shard paths, offsets, lengths, hashes, and member names. |
-| `sample_index_360p.parquet`, `sample_index_720p.parquet` | Resolution-specific member lookup tables used by the default loader path. |
-| `row_index.parquet` | Sample-level physical lookup table with all member byte ranges for one `sample_key` and resolution on each row. |
-| `round_index.parquet` | Synchronized multi-POV round groups. |
-| `match_index.parquet` | Match-map-level grouping and aggregate counts. |
-| `subsets/*.parquet` | Researcher-facing subset views over the shared sample keys. |
-
-Researchers should usually start with `manifest.parquet` or `round_index.parquet`. Loaders and viewers should use `row_index.parquet` for one-row-per-sample lookup or the resolution-specific `sample_index_*.parquet` files for member-level random access into shards.
-
-## Data Fields
-
-Full field definitions are provided under `schema/`. At a high level, the release includes:
+The end-to-end Jupyter walkthrough is `cs2_release/quickstart.ipynb` in the [source repo](https://github.com/AnirudhhRamesh/CounterStrike-1K).
 
-- sample identity: `sample_key`, `match_id`, `round_id`, `round_idx`, `pov_idx`
-- public context: `map_slug`, split, team side
-- timing: ticks, frames, duration, FPS, tick rate, frame/tick stride
-- media QA: optional `media_truncated` / `media_truncated_any_pov` flags for rare samples whose corrected round/death-tail window extends past the rendered MP4
-- actions: movement/use/fire buttons and mouse deltas
-- player state: view angles, position, weapon, ammo, health, armor, side score, money, helmet/defuser/bomb state
-- masks: derive `player_alive` with `alive_start_tick <= state["tick"] < alive_end_tick`; `player_dead` is the complement
-- events: round boundaries, kills, bomb pickup/drop/plant/defuse/explosion
-- shard lookup: shard path, member offsets, byte lengths, hashes
+## Repos
 
-Steam IDs and online account identifiers are not present in public files.
+| Repo | Contents | Size |
+|---|---|---:|
+| `ArnieRamesh/CounterStrike-1K` | Manifest, round/match indices, schema, subsets, Croissant. | ~700 MB |
+| `ArnieRamesh/CounterStrike-1K-sample` | One match-map (16 rounds, 160 POV clips). | ~2 GB |
+| `ArnieRamesh/CounterStrike-1K-360-wds` | 360p WebDataset shards (recommended for training). | ~1.3 TB |
+| `ArnieRamesh/CounterStrike-1K-720-wds` | 720p WebDataset shards. | ~1.5 TB |
 
-## Supplemental Derived Game Traces
+## What's in a sample
 
-CounterStrike-1K does not redistribute raw demo files. To support lower-level state access without exposing raw demo bytes or online identifiers, the release includes derived anonymized game traces:
+Each WebDataset sample is one player POV across one round.
 
-| Prefix | Description |
-|---|---|
-| `match_states/` | Tick-level anonymized POV/game-state tables. |
-| `match_events/` | Tick/event-level anonymized gameplay event tables. |
-| `review_grids/` | CT/T debug-overlay review videos for complete rounds, plus optional match-level concatenations for full-match skim QA. |
-
-These traces support custom metrics, state-conditioned modeling, consistency checks, alternative dataset views, and other non-pixel research workflows.
-
-## Splits
-
-The public release uses `train`, `val`, and `test` splits. The split unit is a match-map demo, not an individual clip. The same match-map demo does not appear in multiple splits.
-
-Final split counts are reported in `stats/summary.json` and mirrored in the per-split table above.
-
-Weapon exposure counts are reported in `stats/weapons.json`. These are derived
-from `manifest.parquet` using `primary_weapon_id` and `weapon_ids_present`;
-they describe active weapons observed in released POV samples, not full player
-inventories.
-
-## Curation And Rendering Pipeline
-
-The release pipeline consists of:
-
-1. Discover and filter professional CS2 match-map demos.
-2. Validate demo integrity and parser compatibility.
-3. Render synchronized player POV clips.
-4. Derive per-frame actions/player state.
-5. Derive sparse events and anonymized game traces.
-6. Generate optional complete-round review grids for human QA.
-7. Pack round-atomic WebDataset shards.
-8. Build public Parquet indices.
-9. Run privacy, integrity, decode, and schema checks.
-
-The final release records exact environment details in `stats/release_environment.json`.
-
-The public release invariant is exactly 10 player POVs per released round.
-Source renders with incomplete succeeded POV sets are requeued or excluded
-before packing. If a source demo exposes more than 10 POV streams, the
-preprocessing pass identifies the 10 active player POVs from parser state and
-action traces, then filters coach/spectator/non-player POV streams before
-sample keys, shards, and public indices are built. Aggregate filtering counts
-are reported in `stats/quality.json`.
-
-## Quality And Validation
+| Member | Format | Description |
+|---|---|---|
+| `mp4` | H.264 + AAC | 720p or 360p video at 32 FPS with synchronized stereo game audio |
+| `actions.bin` | packed binary, 14 B/frame | `tick`, `delta_pitch`, `delta_yaw`, 12-button bitmask |
+| `state.bin` | packed binary, 37 B/frame | view, world position, active weapon, ammo, HP, armor, money, score, helmet/defuser/bomb |
+| `events.json` | JSON | Sparse events: round boundaries, kills (with attacker/victim/assister `pov_idx`), bomb plant/defuse/explode, blinds |
+| `json` | JSON | Public sample metadata: ids, alignment, alive window, weapon flags, kill counts |
 
-The release validation suite checks:
+Buttons (bit order): `FORWARD, BACK, LEFT, RIGHT, JUMP, DUCK, WALK, FIRE, RIGHTCLICK, RELOAD, INSPECT, USE`.
 
-- every MP4 has a decodable video stream
-- every MP4 has AAC-LC stereo audio
-- audio sample rate is 44.1 kHz
-- video frame count matches action and state record counts
-- action/state binary lengths are divisible by the locked record sizes
-- event and metadata JSON validate against schema
-- shard manifests match tar contents
-- byte offsets and lengths resolve to the expected members
-- round groups are internally consistent
-- split boundaries are match-map atomic
-- Steam IDs and online identifiers are absent from public JSON, Parquet, manifests, logs, and shards
+Group POVs of one synchronized round via the shared `round_id` = `match_{12hex}__r{round:03d}`. Sample keys are `match_{12hex}__r{round:03d}__p{pov:02d}` with `pov_idx ∈ {0..9}`.
 
-Validation summaries are stored under `stats/`.
+Full field-level schema is in `schema/`.
 
-## Privacy And Source Boundary
+## Splits and subsets
 
-Raw HLTV demo files are not included in the public release. Steam IDs, online account identifiers, raw demo identifiers, and player names are stripped from public artifacts. Player identity is represented only by `pov_idx`, an anonymized integer that is stable within a `match_id` and is not stable across matches.
+Splits are disjoint at the **match-map** level — the same match never appears in two splits.
 
-## Intended Uses
+| Split | POV-hours | Match-maps | Rounds | POV clips |
+|---|---:|---:|---:|---:|
+| train | 1,341.7 | 301 | 6,573 | 65,730 |
+| val   |    74.5 |  21 |   383 |  3,830 |
+| test  |    74.5 |  20 |   391 |  3,910 |
 
-CounterStrike-1K is intended for:
+Bandwidth-friendly subsets:
 
-- action-conditioned video prediction
-- game world modeling
-- synchronized multi-POV consistency evaluation
-- audio-conditioned prediction
-- state-conditioned modeling
-- representation learning
-- multimodal dataloader and streaming benchmarks
+```python
+ten_hours = pd.read_parquet(hf_hub_download(
+    "ArnieRamesh/CounterStrike-1K", "subsets/train_10h.parquet", repo_type="dataset",
+))
+dust2 = pd.read_parquet(hf_hub_download(
+    "ArnieRamesh/CounterStrike-1K", "subsets/dust2_100h.parquet", repo_type="dataset",
+))
+```
 
-## Out-Of-Scope Uses
+Available: `train_10h.parquet`, `train_50h.parquet`, `train_100h.parquet`, `train_500h.parquet`, `train_1000h.parquet`, `train_all.parquet`, `dust2_100h.parquet`, `full_demo_eval.parquet`.
 
-The dataset is not intended for:
+## Maps
 
-- recovering Steam IDs or online account identifiers
-- re-identifying players or linking `pov_idx` values across matches
-- unsupported claims about anti-cheat, player evaluation, or player profiling
-- commercial use if released under CC-BY-NC 4.0
+Ancient · Anubis · Dust2 · Inferno · Mirage · Nuke · Overpass — all 7 active-duty competitive maps, balanced by rendered POV-frame count.
 
-## Limitations
+## Intended uses
 
-- The data comes from professional CS2 matches and may not represent casual or matchmaking play.
-- Rendered POV-hours are not unique scene-hours because each round can include multiple synchronized player POVs.
-- Source availability and demo compatibility affect coverage.
-- The release covers seven active-duty maps; it is not exhaustive over all CS2 maps.
-- The release is anonymized, but gameplay and team/context patterns may still leak weak identity cues for well-known professional matches.
-- WebDataset shards are optimized for training and streaming. Full browser inspection is best done through the sample repo or a custom viewer.
+- Action-conditioned video prediction
+- Game world modeling
+- Multi-view and multi-agent consistency evaluation
+- Audio-conditioned prediction
+- State-conditioned modeling
+- Representation learning
 
-## License And Takedown
+## Out of scope
 
-CounterStrike-1K is released for non-commercial research under CC BY-NC 4.0
-unless otherwise noted in the final release metadata. This license applies to
-the released annotations, metadata, schemas, manifests, and derived rendered
-artifacts to the extent of the authors' rights. Counter-Strike 2 and underlying
-game assets remain property of Valve Corporation, and source HLTV demo files
-are not redistributed. Users are responsible for complying with applicable
-third-party terms.
+- Re-identifying players or linking players across matches
+- Recovering Steam IDs or online accounts
+- Player profiling, ranking, anti-cheat, surveillance
 
-For removal, correction, attribution, or licensing concerns, contact the dataset authors through the project page or Hugging Face repository discussions/issues.
+Public artifacts contain no Steam IDs, online account identifiers, raw HLTV identifiers, profile URLs, player names, or chat text. `pov_idx` is anonymous and only stable within a single match.
 
 ## Citation
 
-If you use CounterStrike-1K, please cite:
-
 ```bibtex
 @dataset{counterstrike1k2026,
-  title        = {CounterStrike-1K},
-  author       = {Ramesh, Anirudhh},
-  year         = {2026},
-  publisher    = {Hugging Face},
-  version      = {v1.0.0},
-  url          = {https://huggingface.co/datasets/ArnieRamesh/CounterStrike-1K}
+  title     = {CounterStrike-1K: Synchronized Multi-POV Counter-Strike 2 for World Modeling},
+  author    = {Ramesh, Anirudhh},
+  year      = {2026},
+  publisher = {Hugging Face},
+  version   = {1.0.0},
+  url       = {https://huggingface.co/datasets/ArnieRamesh/CounterStrike-1K}
 }
 ```
 
-Paper citation will be added after the accompanying paper/preprint is public.
-
-## Changelog
+## License
 
-- `v1.0.0`: Initial public release.
+CounterStrike-1K release artifacts are distributed for non-commercial research under CC BY-NC 4.0 to the extent of the authors' rights. Counter-Strike 2 and underlying game assets remain property of Valve Corporation. Raw HLTV demo files are not redistributed.

media/videos/introduction_video_wall_1000_hours.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90bcfb955149c17334481de6337c0e6b7324a30dc43cf68344dc841757d6c186
+size 6062211

media/videos/multi_pov_with_actions.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2dacccd7004326fe0411685005acd4a493fc3821e440f1ddc70a66d6ffd9593
+size 2231780

media/videos/seven_maps.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24934134a479771db25b514675bc70659bef8c55759f4f4864ce8f99ca78ad38
+size 3732419