Releasing Dataset

.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,739 @@
+---
+license: cc-by-4.0
+task_categories:
+  - video-classification
+  - reinforcement-learning
+  - other
+language:
+  - en
+tags:
+  - opencs2
+  - counter-strike-2
+  - webdataset
+  - wids
+  - torchcodec
+  - video
+  - audio
+  - parquet
+pretty_name: "OpenCS2 - POV Renders WebDataset"
+configs:
+  - config_name: train
+    data_files:
+      - split: train
+        path: shards/*.train.tar
+    default: true
+---
+
+# OpenCS2 - POV Renders WebDataset
+
+![OpenCS2](https://huggingface.co/datasets/blanchon/opencs2_dataset_wds/resolve/main/static/header.webp)
+
+> Browse with the [OpenCS2 Viewer](https://huggingface.co/spaces/blanchon/counter-strike-2-dataset-viewer) - every match, map and round, with all 10 player POVs synced on one timeline.
+
+Tick-aligned Counter-Strike 2 POV training clips, rendered from
+[`blanchon/cs2_dataset_demo`](https://huggingface.co/datasets/blanchon/cs2_dataset_demo). Each
+sample is one player's perspective for one round; ten POVs per round share the same tick clock.
+
+Per POV round:
+
+- **Video** - 1280x720 @ 32 fps, near-lossless H.264, faststart, muxed with audio.
+- **Audio** - per-player stereo, mixed from that player's position and orientation.
+- **Inputs** - every tick: keys, mouse delta, view angles, fire/jump/use, weapon switches.
+- **World state** - every tick: player position, velocity, view, health, armor, weapon, alive flag.
+
+This repo is the WebDataset packaging of [`blanchon/opencs2_dataset`](https://huggingface.co/datasets/blanchon/opencs2_dataset):
+the same POV rounds, grouped into large uncompressed tar shards with byte-offset indexes for fast
+streaming and sparse random access.
+
+The loose-file version is also mirrored as a Hugging Face Storage Bucket:
+[`hf://buckets/blanchon/opencs2_dataset`](https://huggingface.co/buckets/blanchon/opencs2_dataset).
+
+Current build: `165,270` POV samples (`2974.2` POV video hours, `528.0` synced
+round-timeline hours) across `2,574` uncompressed tar shards.
+
+The lightweight preview WebDataset is separate: [`blanchon/opencs2_dataset_preview_wds`](https://huggingface.co/datasets/blanchon/opencs2_dataset_preview_wds).
+
+## Usage
+
+The media-heavy training data is in tar shards; metadata/configs stay as parquet so filtering is
+cheap before media access.
+
+| Config | Row | Use |
+| --- | --- | --- |
+| `train` (default) | WebDataset samples: `mp4` + `ticks.parquet` + `json` | high-throughput training, sequential shard streaming |
+| `wds_samples` | one row per `(match_id, map_name, round, player_slot)` with tar byte offsets | random access, exact MP4/ticks range reads, download-size estimates |
+| `wds_shards` | one row per tar shard | shard scheduling, cache planning, WIDS setup |
+| `pov_rounds` | one row per player POV round with original loose media paths | filtering, compatibility with the base dataset |
+| `matches` | one row per `(match_id, map_name)` with team/event metadata | match/map filtering |
+| `rounds` | one row per round with tick boundaries and round outcome | round filtering |
+| `kills`, `duels`, `clip_events`, `round_player` | analytical event tables | mining clips such as AWP 1v1s, clutches, smoke kills |
+| `ticks` | map-level tick/input/world-state parquet files | position/input/world-state filtering before media access |
+| `enums` | enum lookup table | mapping compact `*_id` columns back to labels |
+
+## Layout
+
+```text
+shards/
+  opencs2-<match_id>-<map_name>-<shard>.train.tar
+index/
+  wids_train.json          # WIDS shard descriptor
+  wds_samples.parquet      # one row per POV sample, with tar byte offsets
+  wds_shards.parquet       # one row per tar shard
+  matches.parquet          # one row per rendered match/map
+  rounds.parquet           # one row per round
+  pov_rounds.parquet       # one row per player POV round
+events/
+  kills.parquet
+  duels.parquet
+  clip_events.parquet
+  round_player.parquet
+metadata/
+  enums.parquet
+ticks/
+  match_id=<id>/map_name=<map>/ticks.parquet
+```
+
+The tar shards are plain `.tar`, not `.tar.gz`, so byte offsets stay valid. A sample member set looks like:
+
+```text
+2391545-de_anubis-r01-p00.mp4
+2391545-de_anubis-r01-p00.ticks.parquet
+2391545-de_anubis-r01-p00.json
+```
+
+## Parquet Tables
+
+String-like filter columns are dictionary encoded where useful, and most have a matching `*_id`
+column for fast integer joins or enum-based modeling. Player identity is always `player_slot`
+(`0..9`), not Steam ID or username.
+
+| File | Rows | Purpose | Main schema |
+| --- | ---: | --- | --- |
+| `index/wds_samples.parquet` | 165,270 | WebDataset sample index and byte offsets | `media_id`, `match_id`, `map_name`, `round`, `player_slot`, `duration_s`, `frames`, `width`, `height`, `sample_key`, `shard_path`, `shard_size`, `mp4_member`, `mp4_offset`, `mp4_size`, `ticks_member`, `ticks_offset`, `ticks_size`, `json_member`, `json_offset`, `json_size` |
+| `index/wds_shards.parquet` | 2,711 | Shard inventory | `shard_path`, `shard_size`, `n_samples`, `round_min`, `round_max`, `payload_bytes_sum`, `match_ids`, `map_names`, `player_slots` |
+| `index/pov_rounds.parquet` | 165,270 | One row per player POV round | match keys, side/weapon summary, capture ticks, death/survival, dimensions, `duration_s`, `video_frames`, original `video` path, `media_bytes`, original preview path/bytes, `ticks_parquet_path` |
+| `index/matches.parquet` | 794 | One row per match/map | `match_id`, `map_name`, `map_index`, `hltv_demo_id`, `match_url`, `event`, teams, scores, winner, format, stars, `match_date`, `rounds_played` |
+| `index/rounds.parquet` | 16,527 | One row per round | round tick boundaries, duration, winner/reason/bomb site, kill counts, side counts, opening kill summary, `had_clutch_context`, `had_1v1` |
+| `events/kills.parquet` | 111,715 | One row per kill | attacker/victim slots and sides, `tick`, `event_seconds`, weapon/class, hit details, alive counts before/after, trade/1v1/clutch/opening flags |
+| `events/duels.parquet` | 111,715 | Kill events normalized as winner/loser duels | winner/loser slots and sides, weapon/class, distance, damage, hit details, alive counts, trade/1v1/clutch/opening flags |
+| `events/clip_events.parquet` | 111,715 | Generic event table for clip mining | `event_type`, target/other slots, `event_seconds`, weapon/class, boolean flags such as `headshot`, `through_smoke`, `one_v_one`, `clutch_context` |
+| `events/round_player.parquet` | 168,294 | Per-player round stats | match keys, `player_slot`, start side, kills, deaths, assists, headshots, `kast` |
+| `ticks/**/*.parquet` | map-level | Tick/input/world-state index outside the tar shards | `media_id`, `round`, `player_slot`, `tick`, `t`, input button lists, view angles, weapon, health/armor, position, velocity |
+| `metadata/enums.parquet` | 115 | Enum lookup | `enum_name`, `enum_id`, `value` |
+
+Tick column `t` is the timestamp in the POV video. `event_seconds` is already on the POV video timeline. You can seek media directly with
+`event_video_seconds = event_seconds`, or join event `tick` against the selected POV
+`ticks.parquet` and use tick column `t`. Use `media_bytes` or `mp4_size` to estimate
+download cost before touching media.
+
+## Install
+
+```bash
+uv pip install duckdb pyarrow pandas requests huggingface_hub torch torchcodec pillow webdataset wids
+```
+
+For metadata-only work you only need `duckdb`, `pyarrow`, and `huggingface_hub`.
+
+## Filter Without Downloading Media
+
+Use DuckDB over the parquet files. This only downloads the selected parquet row groups, not MP4s.
+
+```python
+import duckdb
+
+con = duckdb.connect()
+con.sql("INSTALL httpfs; LOAD httpfs;")
+
+awp_1v1 = con.sql("""
+SELECT
+  d.match_id,
+  d.map_name,
+  d.round,
+  d.winner_player_slot AS player_slot,
+  d.event_seconds AS event_table_seconds,
+  d.event_seconds AS event_video_seconds,
+  d.weapon,
+  s.shard_path,
+  s.mp4_offset,
+  s.mp4_size,
+  s.ticks_offset,
+  s.ticks_size
+FROM 'hf://datasets/blanchon/opencs2_dataset_wds/events/duels.parquet' AS d
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/wds_samples.parquet' AS s
+  ON d.match_id = s.match_id
+ AND d.map_name = s.map_name
+ AND d.round = s.round
+ AND d.winner_player_slot = s.player_slot
+WHERE d.weapon = 'awp'
+  AND d.is_1v1_before
+""").df()
+
+print(awp_1v1.head())
+print("estimated MP4 bytes:", int(awp_1v1["mp4_size"].sum()))
+```
+
+Other useful filters:
+
+```sql
+-- Long Mirage rounds with a bomb plant.
+SELECT *
+FROM 'hf://datasets/blanchon/opencs2_dataset_wds/index/rounds.parquet'
+WHERE map_name = 'de_mirage' AND has_bomb_plant AND round_duration_s > 60;
+
+-- All kills through smoke, with killer POV.
+SELECT k.*, s.shard_path, s.mp4_offset, s.mp4_size
+FROM 'hf://datasets/blanchon/opencs2_dataset_wds/events/kills.parquet' k
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/wds_samples.parquet' s
+  ON k.match_id = s.match_id
+ AND k.map_name = s.map_name
+ AND k.round = s.round
+ AND k.attacker_player_slot = s.player_slot
+WHERE k.through_smoke;
+```
+
+## Verified Clip Recipes
+
+> [!TIP]
+> These filters were tested by exporting 10 local examples each. For kill-derived examples, center the clip on
+> `event_seconds`.
+
+Common helper:
+
+This helper writes video-only MP4 clips through TorchCodec. It decodes the selected range as a
+PyTorch `uint8` tensor, then encodes it back to H.264 MP4.
+
+```python
+import json
+import re
+from pathlib import Path
+
+import duckdb
+from huggingface_hub import hf_hub_url
+from PIL import Image
+from torchcodec.decoders import VideoDecoder
+from torchcodec.encoders import VideoEncoder
+
+REPO = "blanchon/opencs2_dataset_wds"
+OUT = Path("opencs2_examples")
+FPS = 32.0
+
+def hf_path_to_url(path):
+    repo_id, revision, filename = re.match(r"hf://datasets/([^@]+)@([^/]+)/(.+)", path).groups()
+    return hf_hub_url(repo_id=repo_id, repo_type="dataset", revision=revision, filename=filename)
+
+def open_mp4(row):
+    return hf_path_to_url(row["video_path"])
+
+def save_clip(row, name, before=5.0, after=5.0):
+    center = float(row["event_video_seconds"])
+    start = max(0.0, center - before)
+    stop = min(float(row["duration_s"]), center + after)
+    out = OUT / name / f"{row['event_id']}.mp4"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    frames = VideoDecoder(
+        open_mp4(row),
+        seek_mode="approximate",
+        dimension_order="NCHW",
+    ).get_frames_played_in_range(start_seconds=start, stop_seconds=stop, fps=FPS)
+    VideoEncoder(frames.data, frame_rate=FPS).to_file(
+        out,
+        codec="libx264",
+        pixel_format="yuv420p",
+        crf=20,
+        preset="veryfast",
+        extra_options={"x264-params": "keyint=32:min-keyint=1:scenecut=0:open-gop=0"},
+    )
+    return out
+
+def save_png(frame_hwc, path):
+    Image.fromarray(frame_hwc.cpu().numpy()).save(path)
+
+def save_frame_pair(row, name):
+    out = OUT / name / f"{row['media_id']}-{int(row['tick'])}"
+    out.mkdir(parents=True, exist_ok=True)
+    frames = VideoDecoder(
+        open_mp4(row),
+        seek_mode="approximate",
+        dimension_order="NHWC",
+    ).get_frames_played_at(seconds=[float(row["t"]), float(row["next_t"])])
+    frame_t = frames.data[0]
+    frame_t1 = frames.data[1]
+
+    save_png(frame_t, out / "frame_t.png")
+    save_png(frame_t1, out / "frame_t_plus_1.png")
+
+    tick_t = {k: v for k, v in row.items() if not k.startswith("next_") and k != "video_path"}
+    tick_t_plus_1 = {**tick_t, "tick": int(row["next_tick"]), "t": float(row["next_t"])}
+    (out / "tick_t.json").write_text(json.dumps(tick_t, indent=2, default=str) + "\n")
+    (out / "tick_t_plus_1.json").write_text(json.dumps(tick_t_plus_1, indent=2, default=str) + "\n")
+    return out
+
+con = duckdb.connect()
+con.sql("INSTALL httpfs; LOAD httpfs;")
+```
+
+<details>
+<summary><strong>AWP 1v1 duel, winner POV</strong></summary>
+
+```python
+rows = con.sql("""
+SELECT d.duel_id AS event_id, d.event_seconds AS event_video_seconds,
+       d.weapon, d.distance, d.headshot, p.duration_s,
+       struct_extract(p.video, 'path') AS video_path
+FROM 'hf://datasets/blanchon/opencs2_dataset_wds/events/duels.parquet' d
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/pov_rounds.parquet' p
+  ON d.match_id=p.match_id AND d.map_name=p.map_name AND d.round=p.round
+ AND d.winner_player_slot=p.player_slot
+WHERE d.weapon='awp' AND d.is_1v1_before
+  AND p.duration_s >= d.event_seconds + 5.0
+ORDER BY d.event_seconds
+LIMIT 10
+""").df()
+
+for row in rows.to_dict("records"):
+    save_clip(row, "awp_1v1_duel")
+```
+
+</details>
+
+<details>
+<summary><strong>Kill through smoke, attacker POV</strong></summary>
+
+```python
+rows = con.sql("""
+SELECT k.kill_id AS event_id, k.event_seconds AS event_video_seconds,
+       k.weapon, k.distance, k.headshot, p.duration_s,
+       struct_extract(p.video, 'path') AS video_path
+FROM 'hf://datasets/blanchon/opencs2_dataset_wds/events/kills.parquet' k
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/pov_rounds.parquet' p
+  ON k.match_id=p.match_id AND k.map_name=p.map_name AND k.round=p.round
+ AND k.attacker_player_slot=p.player_slot
+WHERE k.through_smoke
+  AND p.duration_s >= k.event_seconds + 5.0
+ORDER BY k.event_seconds
+LIMIT 10
+""").df()
+
+for row in rows.to_dict("records"):
+    save_clip(row, "kill_through_smoke")
+```
+
+</details>
+
+<details>
+<summary><strong>Noscope or wallbang highlight</strong></summary>
+
+```python
+rows = con.sql("""
+SELECT k.kill_id AS event_id, k.event_seconds AS event_video_seconds,
+       k.weapon, k.noscope, k.wallbang, k.penetrated, p.duration_s,
+       struct_extract(p.video, 'path') AS video_path
+FROM 'hf://datasets/blanchon/opencs2_dataset_wds/events/kills.parquet' k
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/pov_rounds.parquet' p
+  ON k.match_id=p.match_id AND k.map_name=p.map_name AND k.round=p.round
+ AND k.attacker_player_slot=p.player_slot
+WHERE (k.noscope OR k.wallbang OR k.penetrated > 0)
+  AND p.duration_s >= k.event_seconds + 5.0
+ORDER BY k.noscope DESC, k.wallbang DESC, k.penetrated DESC
+LIMIT 10
+""").df()
+
+for row in rows.to_dict("records"):
+    save_clip(row, "noscope_wallbang")
+```
+
+</details>
+
+<details>
+<summary><strong>Knife kill</strong></summary>
+
+```python
+rows = con.sql("""
+SELECT k.kill_id AS event_id, k.event_seconds AS event_video_seconds,
+       k.weapon, p.duration_s, struct_extract(p.video, 'path') AS video_path
+FROM 'hf://datasets/blanchon/opencs2_dataset_wds/events/kills.parquet' k
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/pov_rounds.parquet' p
+  ON k.match_id=p.match_id AND k.map_name=p.map_name AND k.round=p.round
+ AND k.attacker_player_slot=p.player_slot
+WHERE (lower(k.weapon_class)='knife' OR lower(k.weapon) LIKE '%knife%'
+       OR lower(k.weapon) LIKE '%bayonet%' OR lower(k.weapon) LIKE '%karambit%')
+  AND p.duration_s >= k.event_seconds + 5.0
+LIMIT 10
+""").df()
+
+for row in rows.to_dict("records"):
+    save_clip(row, "knife_kill")
+```
+
+</details>
+
+<details>
+<summary><strong>Five kills by the same player in under 10 seconds</strong></summary>
+
+```python
+rows = con.sql("""
+WITH streaks AS (
+  SELECT match_id, map_name, round, attacker_player_slot AS player_slot,
+         COUNT(*) AS n_kills,
+         MIN(event_seconds) AS first_kill_video_seconds,
+         MAX(event_seconds) AS last_kill_video_seconds
+  FROM 'hf://datasets/blanchon/opencs2_dataset_wds/events/kills.parquet'
+  GROUP BY match_id, map_name, round, attacker_player_slot
+  HAVING COUNT(*) >= 5 AND MAX(event_seconds) - MIN(event_seconds) < 10.0
+)
+SELECT concat('streak-', s.match_id, '-', s.map_name, '-r', s.round, '-p', s.player_slot) AS event_id,
+       s.first_kill_video_seconds AS event_video_seconds,
+       s.last_kill_video_seconds, s.n_kills, p.duration_s,
+       struct_extract(p.video, 'path') AS video_path
+FROM streaks s
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/pov_rounds.parquet' p
+  ON s.match_id=p.match_id AND s.map_name=p.map_name AND s.round=p.round
+ AND s.player_slot=p.player_slot
+ORDER BY s.last_kill_video_seconds - s.first_kill_video_seconds
+LIMIT 10
+""").df()
+
+for row in rows.to_dict("records"):
+    save_clip(row, "five_kills_under_10s", before=2.0, after=row["last_kill_video_seconds"] - row["event_video_seconds"] + 2.0)
+```
+
+</details>
+
+<details>
+<summary><strong>Very long distance kill</strong></summary>
+
+```python
+rows = con.sql("""
+SELECT k.kill_id AS event_id, k.event_seconds AS event_video_seconds,
+       k.weapon, k.distance, p.duration_s, struct_extract(p.video, 'path') AS video_path
+FROM 'hf://datasets/blanchon/opencs2_dataset_wds/events/kills.parquet' k
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/pov_rounds.parquet' p
+  ON k.match_id=p.match_id AND k.map_name=p.map_name AND k.round=p.round
+ AND k.attacker_player_slot=p.player_slot
+WHERE k.distance IS NOT NULL
+  AND p.duration_s >= k.event_seconds + 5.0
+ORDER BY k.distance DESC
+LIMIT 10
+""").df()
+
+for row in rows.to_dict("records"):
+    save_clip(row, "long_distance_kill")
+```
+
+</details>
+
+<details>
+<summary><strong>Specific map position, video clip</strong></summary>
+
+```python
+rows = con.sql("""
+WITH t AS (
+  SELECT DISTINCT ON (media_id) media_id, match_id, map_name, round, player_slot,
+         t AS event_video_seconds, x, y, z, input_weapon
+  FROM 'hf://datasets/blanchon/opencs2_dataset_wds/ticks/match_id=2391545/map_name=de_anubis/ticks.parquet'
+  WHERE is_alive AND tick % 64 = 0 AND t >= 5.0
+    AND x BETWEEN -875 AND -625 AND y BETWEEN 125 AND 375
+  ORDER BY media_id, t
+)
+SELECT concat('pos-', t.media_id, '-', round(t.event_video_seconds, 2)) AS event_id,
+       t.*, p.duration_s, struct_extract(p.video, 'path') AS video_path
+FROM t
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/pov_rounds.parquet' p
+  ON t.media_id=p.media_id
+LIMIT 10
+""").df()
+
+for row in rows.to_dict("records"):
+    save_clip(row, "position_based_clip")
+```
+
+</details>
+
+<details>
+<summary><strong>boosting_top_player: higher player POV</strong></summary>
+
+Use ticks to find a higher player above a nearby lower player for multiple consecutive ticks. This
+is a heuristic, so visually inspect results.
+
+```sql
+-- Core condition used in the verified examples:
+xy_distance < 36
+z_delta BETWEEN 45 AND 90
+abs(top.velocity_z) < 12
+abs(lower.velocity_z) < 12
+support_ticks >= 16
+```
+
+</details>
+
+<details>
+<summary><strong>frame_pair_preview: frame pair at a specific position</strong></summary>
+
+```python
+rows = con.sql("""
+WITH ticks AS (
+  SELECT media_id, match_id, map_name, round, player_slot, tick, t, x, y, z
+  FROM 'hf://datasets/blanchon/opencs2_dataset_wds/ticks/match_id=2391545/map_name=de_anubis/ticks.parquet'
+  WHERE is_alive AND t > 5.0
+),
+anchors AS (
+  SELECT * FROM ticks
+  WHERE tick % 64 = 0
+    AND x BETWEEN -875 AND -625 AND y BETWEEN 125 AND 375
+),
+pairs AS (
+  SELECT DISTINCT ON (a.media_id) a.*, b.tick AS next_tick, b.t AS next_t
+  FROM anchors a JOIN ticks b ON a.media_id=b.media_id AND a.tick + 2 = b.tick
+  ORDER BY a.media_id, a.t
+)
+SELECT pairs.*, struct_extract(p.video, 'path') AS video_path
+FROM pairs
+JOIN 'hf://datasets/blanchon/opencs2_dataset_wds/index/pov_rounds.parquet' p
+  ON pairs.media_id=p.media_id
+LIMIT 10
+""").df()
+
+for row in rows.to_dict("records"):
+    save_frame_pair(row, "frame_pair_preview")
+```
+
+</details>
+
+## Read One POV Or One Timestamp
+
+`index/wds_samples.parquet` stores the byte range of each MP4 inside its tar shard. The MP4 bytes
+are identical to a standalone MP4; the reader below shifts all HTTP range requests by the tar
+member offset.
+
+```python
+import io
+import os
+import requests
+from huggingface_hub import hf_hub_url
+from torchcodec.decoders import AudioDecoder, VideoDecoder
+
+REPO = "blanchon/opencs2_dataset_wds"
+
+class HfTarMember(io.RawIOBase):
+    def __init__(self, shard_url, offset, size, token=None, session=None):
+        self.shard_url = shard_url
+        self.offset = int(offset)
+        self.size = int(size)
+        self.pos = 0
+        self.session = session or requests.Session()
+        self.headers = {}
+        token = token or os.environ.get("HF_TOKEN")
+        if token:
+            self.headers["Authorization"] = f"Bearer {token}"
+
+    def readable(self):
+        return True
+
+    def seekable(self):
+        return True
+
+    def tell(self):
+        return self.pos
+
+    def seek(self, offset, whence=io.SEEK_SET):
+        if whence == io.SEEK_SET:
+            self.pos = offset
+        elif whence == io.SEEK_CUR:
+            self.pos += offset
+        elif whence == io.SEEK_END:
+            self.pos = self.size + offset
+        self.pos = max(0, min(self.pos, self.size))
+        return self.pos
+
+    def read(self, n=-1):
+        if self.pos >= self.size:
+            return b""
+        if n is None or n < 0:
+            n = self.size - self.pos
+        n = min(n, self.size - self.pos)
+        start = self.offset + self.pos
+        stop = start + n - 1
+        headers = dict(self.headers)
+        headers["Range"] = f"bytes={start}-{stop}"
+        r = self.session.get(self.shard_url, headers=headers, timeout=60)
+        r.raise_for_status()
+        data = r.content
+        self.pos += len(data)
+        return data
+
+def member_url(row):
+    return hf_hub_url(REPO, row["shard_path"], repo_type="dataset")
+
+def open_mp4(row):
+    return HfTarMember(member_url(row), row["mp4_offset"], row["mp4_size"])
+
+# row can come from DuckDB, pandas, or pyarrow.
+row = awp_1v1.iloc[0].to_dict()
+start = max(0.0, row["event_video_seconds"] - 5.0)
+stop = row["event_video_seconds"] + 5.0
+
+video = VideoDecoder(open_mp4(row), seek_mode="approximate", dimension_order="NHWC")
+clip = video.get_frames_played_in_range(start_seconds=start, stop_seconds=stop)
+
+audio = AudioDecoder(open_mp4(row))
+samples = audio.get_samples_played_in_range(start_seconds=start, stop_seconds=stop)
+```
+
+For a browser viewer, use the same `shard_path`, `mp4_offset`, and `mp4_size`: create a URL source
+for the shard, slice `[mp4_offset, mp4_offset + mp4_size)`, then give the slice to the MP4 demuxer.
+
+## Read The Tick Sidecar
+
+Each WDS sample also contains its per-POV tick parquet. Fetch it by range from the same tar shard:
+
+```python
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+def read_member_bytes(row, offset_col, size_col):
+    f = HfTarMember(member_url(row), row[offset_col], row[size_col])
+    return f.read()
+
+tick_bytes = read_member_bytes(row, "ticks_offset", "ticks_size")
+ticks = pq.read_table(pa.BufferReader(tick_bytes)).to_pandas()
+```
+
+For global filtering by position, weapon, or health across many samples, use the external
+`ticks/match_id=<id>/map_name=<map>/ticks.parquet` files instead. They are map-level parquet
+indexes and avoid opening tar shards during the filtering phase.
+
+```sql
+SELECT media_id, round, player_slot, tick, t, x, y, z, input_weapon
+FROM 'hf://datasets/blanchon/opencs2_dataset_wds/ticks/match_id=2391545/map_name=de_anubis/ticks.parquet'
+WHERE x BETWEEN -500 AND 500
+  AND y BETWEEN -2000 AND -1200
+  AND is_alive;
+```
+
+## Frame Pair Samples
+
+For `(frame_t, tick_t, frame_t+1, tick_t+1)`, use the video WDS and decode frames on demand. This
+keeps storage smaller than a pre-extracted frame dataset while preserving arbitrary temporal access.
+
+```python
+import numpy as np
+
+t0 = 12.0
+t1 = t0 + 1.0 / 32.0
+
+tick0 = ticks.iloc[(ticks["t"] - t0).abs().argmin()]
+tick1 = ticks.iloc[(ticks["t"] - t1).abs().argmin()]
+
+frames = VideoDecoder(open_mp4(row), seek_mode="approximate", dimension_order="NHWC").get_frames_played_at(
+    seconds=[float(tick0["t"]), float(tick1["t"])]
+)
+
+frame_t = frames.data[0]
+frame_t1 = frames.data[1]
+```
+
+For throughput, sample several timestamps from the same POV and call `get_frames_played_at()` once
+with the full timestamp list; reopening the decoder for each frame pair is much slower.
+
+## High-Throughput Training
+
+Use the parquet tables to build the sample set first, then feed only selected shards/samples to the
+loader. The fastest pattern depends on access shape:
+
+- full or mostly-full rounds: use WebDataset/WIDS with a local NVMe shard cache;
+- sparse 10 second clips: use `wds_samples.parquet` byte offsets and TorchCodec range reads;
+- frame pairs: group many requested timestamps by `media_id`, decode them in batches, then shuffle
+  the emitted pairs.
+
+Recommended randomness strategy:
+
+1. shuffle shards each epoch;
+2. shuffle samples within each shard;
+3. keep a bounded cross-shard sample buffer, for example 64-256 samples per worker;
+4. group nearby timestamps from the same `media_id` before decoding, then shuffle outputs after decode.
+
+WIDS descriptor:
+
+```python
+from huggingface_hub import hf_hub_url
+import wids
+
+index_url = hf_hub_url(
+    "blanchon/opencs2_dataset_wds",
+    "index/wids_train.json",
+    repo_type="dataset",
+)
+
+ds = wids.ShardListDataset(
+    index_url,
+    cache_dir="/local_nvme/opencs2_wids",
+    lru_size=16,
+)
+sample = ds[0]
+```
+
+Classic streaming WebDataset:
+
+```python
+import pyarrow.parquet as pq
+import webdataset as wds
+from huggingface_hub import hf_hub_download, hf_hub_url
+
+repo = "blanchon/opencs2_dataset_wds"
+index_path = hf_hub_download(repo, "index/wds_shards.parquet", repo_type="dataset")
+shard_paths = pq.read_table(index_path, columns=["shard_path"]).column("shard_path").to_pylist()
+urls = [hf_hub_url(repo, path, repo_type="dataset") for path in shard_paths]
+
+dataset = (
+    wds.WebDataset(urls, shardshuffle=True)
+    .shuffle(128)
+)
+```
+
+For this dataset, prefer the explicit shard list from `index/wds_shards.parquet` or
+`index/wids_train.json` over a brace pattern: shard names include match IDs and map names.
+
+## Downloading
+
+Metadata only:
+
+```bash
+hf download blanchon/opencs2_dataset_wds --repo-type dataset \
+  --include "index/*.parquet" \
+  --include "events/*.parquet" \
+  --include "metadata/*.parquet"
+```
+
+One shard:
+
+```bash
+hf download blanchon/opencs2_dataset_wds --repo-type dataset \
+  --include "shards/opencs2-2391545-de_anubis-000000.train.tar"
+```
+
+For programmatic URL construction, use `huggingface_hub.hf_hub_url()` for range reads and DuckDB
+`hf://datasets/...` URLs for parquet scans.
+
+## Creation
+
+Built from HLTV `.dem` files with a headless CS2 recorder. The recorder replays demos, captures all
+10 player POVs, validates tick/frame boundaries, muxes audio into the MP4, and writes typed parquet
+sidecars. This WebDataset repo repackages the round-based media from `blanchon/opencs2_dataset` into large
+tar shards plus byte-offset indexes to avoid the many-small-files problem.
+
+## Licensing
+
+`.dem` source data is mirrored from HLTV; downstream use is bound by the original tournament terms.
+Renders and metadata are released as **CC-BY-4.0**.
+
+## Citation
+
+```bibtex
+@misc{blanchon2026opencs2,
+  author       = {Julien Blanchon},
+  title        = {OpenCS2 Dataset},
+  year         = {2026},
+  publisher    = {Hugging Face},
+  howpublished = {\url{https://github.com/julien-blanchon/opencs2-dataset}}
+}
+```

events/clip_events.parquet

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

events/duels.parquet

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

events/kills.parquet

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

events/round_player.parquet

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

index/matches.parquet

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

index/pov_rounds.parquet

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

index/rounds.parquet

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

index/wds_samples.parquet

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

index/wds_shards.parquet

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

metadata/enums.parquet

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

shards/opencs2-2391545-de_anubis-000000.train.tar

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

shards/opencs2-2391545-de_anubis-000001.train.tar

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

shards/opencs2-2391545-de_anubis-000002.train.tar

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

shards/opencs2-2391545-de_mirage-000000.train.tar

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

shards/opencs2-2391545-de_mirage-000001.train.tar

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

shards/opencs2-2391545-de_mirage-000002.train.tar

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

shards/opencs2-2391545-de_overpass-000000.train.tar

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

shards/opencs2-2391545-de_overpass-000001.train.tar

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

shards/opencs2-2391545-de_overpass-000002.train.tar

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

shards/opencs2-2391545-de_overpass-000003.train.tar

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

shards/opencs2-2391547-de_dust2-000000.train.tar

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

shards/opencs2-2391547-de_dust2-000001.train.tar

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

shards/opencs2-2391547-de_dust2-000002.train.tar

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

shards/opencs2-2391547-de_overpass-000000.train.tar

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

shards/opencs2-2391547-de_overpass-000001.train.tar

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

shards/opencs2-2391547-de_overpass-000002.train.tar

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

shards/opencs2-2391551-de_dust2-000000.train.tar

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

shards/opencs2-2391551-de_dust2-000001.train.tar

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

shards/opencs2-2391551-de_dust2-000002.train.tar

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

shards/opencs2-2391551-de_dust2-000003.train.tar

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

shards/opencs2-2391551-de_inferno-000000.train.tar

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

shards/opencs2-2391551-de_inferno-000001.train.tar

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

shards/opencs2-2391551-de_inferno-000002.train.tar

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

shards/opencs2-2391551-de_inferno-000003.train.tar

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

shards/opencs2-2391551-de_nuke-000000.train.tar

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

shards/opencs2-2391551-de_nuke-000001.train.tar

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

shards/opencs2-2391551-de_nuke-000002.train.tar

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

shards/opencs2-2391561-de_nuke-000000.train.tar

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

shards/opencs2-2391561-de_nuke-000001.train.tar

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

shards/opencs2-2391561-de_nuke-000002.train.tar

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

shards/opencs2-2391806-de_inferno-000000.train.tar

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

shards/opencs2-2391806-de_inferno-000001.train.tar

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

shards/opencs2-2391806-de_inferno-000002.train.tar

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

shards/opencs2-2391806-de_inferno-000003.train.tar

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

shards/opencs2-2391806-de_nuke-000000.train.tar

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

shards/opencs2-2391806-de_nuke-000001.train.tar

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

shards/opencs2-2391806-de_nuke-000002.train.tar

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