README v2: sample provenance + quickstart notebook

README.md

@@ -1,29 +1,81 @@
 ---
 license: cc-by-nc-4.0
 pretty_name: CounterStrike-1K Sample
+task_categories:
+- video-classification
+- reinforcement-learning
+- video-to-video
 tags:
 - counter-strike-2
-- webdataset
-- video
+- world-model
+- video-prediction
+- action-conditioned-video
+- multi-view
 - sample
+- audio
+- esports
+size_categories:
+- n<1K
 ---
 
 # CounterStrike-1K Sample
 
-This is a small unsharded reviewer/developer sample for CounterStrike-1K. It
-uses the same v12 per-sample schema as the full release, but stores ordinary
-files instead of WebDataset tar shards.
+This is the reviewer/developer sample for [CounterStrike-1K](https://huggingface.co/datasets/ArnieRamesh/CounterStrike-1K). It contains one Dust2 match-map, 16 released rounds, all 10 synchronized player POVs per round, 160 clips total, and about 2 GB of 360p media. It is intended for inspecting video/audio quality, validating the v12 schema, building loaders, and running quick local experiments without downloading the full release.
 
-## Contents
+## How this sample was created
 
-- Resolution: `360p`
-- Match-map demos: 1
-- Map(s): dust2
-- Rounds: 16
-- Samples: 160
-- Rendered POV-hours: 2.630
+The sample was created from the same public v12 postprocessing and QA pipeline as the full CounterStrike-1K release:
 
-Each sample has:
+1. We selected one QA-passing Dust2 match-map from the full release manifest.
+2. We kept the first 16 released rounds from that match-map, preserving all 10 synchronized active-player POVs for each round.
+3. We used the same v12 artifacts as the full release: rendered MP4 video/audio, dense per-frame `actions.bin`, dense per-frame `state.bin`, sparse `events.json`, and public metadata sidecars.
+4. We downsampled the sample media to 360p for reviewer convenience while preserving the same 32 FPS frame grid, per-frame action/state alignment, and anonymized metadata schema.
+5. We stored the artifacts as ordinary files instead of WebDataset tar shards, so reviewers can browse and download individual clips directly.
+
+The exact sample membership is listed in `subsets/sample.parquet`. This sample is representative of the dataset format and synchronization/annotation quality, but it is not intended to be statistically representative of all maps, teams, matches, or gameplay situations in the full release.
+
+## Quickstart
+
+Start a fresh `uv` project and add the loader:
+
+```bash
+mkdir cs1k-demo && cd cs1k-demo
+uv init
+uv add "counterstrike1k @ git+https://github.com/AnirudhhRamesh/counterstrike1k"
+```
+
+<details>
+<summary>Using pip instead</summary>
+
+```bash
+mkdir cs1k-demo && cd cs1k-demo
+python -m venv .venv && source .venv/bin/activate
+pip install "counterstrike1k @ git+https://github.com/AnirudhhRamesh/counterstrike1k"
+```
+</details>
+
+```python
+from counterstrike1k import load_sample
+
+for sample in load_sample():
+    print(sample["metadata"]["sample_key"])
+    print(sample["actions"].shape, sample["state"].shape, len(sample["video"]))
+    break
+```
+
+`load_sample()` downloads this repo on first call, then iterates decoded samples in manifest order:
+
+- `video`: mp4 bytes (H.264 + AAC, 640×360 @ 32 FPS with synchronized stereo audio)
+- `actions`: structured numpy array (per-frame `tick`, `delta_pitch`, `delta_yaw`, 12-button bitmask)
+- `state`: structured numpy array (per-frame view, position, weapon, ammo, HP, money, score, …)
+- `events`: list of sparse round/kill/bomb events
+- `metadata`: public sample metadata
+
+For a Jupyter walkthrough, use [`examples/quickstart.ipynb`](examples/quickstart.ipynb) in this sample repo or the same notebook in the [source repo](https://github.com/AnirudhhRamesh/CounterStrike-1K).
+
+## Layout
+
+Direct files (not WebDataset shards), organized by modality:
 
 ```text
 videos/360p/{sample_key}.mp4
@@ -31,27 +83,12 @@ actions/{sample_key}.actions.bin
 state/{sample_key}.state.bin
 events/{sample_key}.events.json
 metadata/{sample_key}.json
+manifest.parquet
+round_index.parquet
 ```
 
-The package also includes `manifest.parquet`, `round_index.parquet`,
-`match_index.parquet`, `subsets/sample.parquet`, and the public schema files.
-
-## Loading
+The full release uses WebDataset shards instead — see [`CounterStrike-1K-360-wds`](https://huggingface.co/datasets/ArnieRamesh/CounterStrike-1K-360-wds) and [`CounterStrike-1K-720-wds`](https://huggingface.co/datasets/ArnieRamesh/CounterStrike-1K-720-wds).
 
-```python
-from pathlib import Path
-from huggingface_hub import snapshot_download
-from counterstrike1k import CounterStrike1K
-
-root = Path(snapshot_download(
-    repo_id="ArnieRamesh/CounterStrike-1K-sample",
-    repo_type="dataset",
-))
-ds = CounterStrike1K(root, subset="sample", resolution="360p")
-sample = next(iter(ds))
-print(sample["metadata"]["sample_key"])
-print(sample["actions"].shape, sample["state"].shape, sample["player_alive"].mean())
-```
+## License & citation
 
-No raw demos, Steam IDs, account identifiers, raw HLTV identifiers, player
-names, or chat text are included.
+CC BY-NC 4.0. Citation in the [main dataset card](https://huggingface.co/datasets/ArnieRamesh/CounterStrike-1K). No raw demos, Steam IDs, account identifiers, raw HLTV identifiers, player names, or chat text are included.

examples/quickstart.ipynb

@@ -0,0 +1,295 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "intro",
+   "metadata": {},
+   "source": "# CounterStrike-1K — Quickstart\n\nThis notebook runs end-to-end against the public preview repo. No environment variables, no config files. Open and run all.\n\n**What you'll see**: 1) browse the manifest, 2) decode one sample, 3) inspect actions/state, 4) watch the video, 5) **HUD overlay to verify action–video alignment**, 6) load all 10 synchronized POVs of one round.\n\n**Setup** (run once in a fresh project directory):\n\n```bash\nmkdir cs1k-demo && cd cs1k-demo\nuv init\nuv add datasets \"counterstrike1k @ git+https://github.com/AnirudhhRamesh/counterstrike1k\" jupyterlab matplotlib pandas\n```\n\nOr with pip:\n\n```bash\nmkdir cs1k-demo && cd cs1k-demo\npython -m venv .venv && source .venv/bin/activate\npip install datasets \"counterstrike1k @ git+https://github.com/AnirudhhRamesh/counterstrike1k\" jupyterlab matplotlib pandas\n```"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "browse-md",
+   "metadata": {},
+   "source": [
+    "## 1. Browse the manifest\n",
+    "\n",
+    "The manifest is a small Parquet file (~25 MB) listing every released POV sample with split, map, weapon, kill counts, and round/match grouping. Read it with pandas — no media is downloaded here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "browse-code",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "\n",
+    "manifest = pd.read_parquet(hf_hub_download(\n",
+    "    \"ArnieRamesh/CounterStrike-1K\", \"manifest.parquet\", repo_type=\"dataset\",\n",
+    "))\n",
+    "print(f\"{len(manifest):,} POV samples across all splits\")\n",
+    "manifest.head()[[\"sample_key\", \"split\", \"map_slug\", \"round_id\", \"pov_idx\", \"duration_s\", \"frames\"]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "filter-md",
+   "metadata": {},
+   "source": [
+    "Boolean masks give you fast, vectorized filtering — much faster than `.filter(lambda)`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "filter-code",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mirage_train = manifest[(manifest[\"map_slug\"] == \"mirage\") & (manifest[\"split\"] == \"train\")]\n",
+    "print(f\"{len(mirage_train):,} Mirage train clips\")\n",
+    "manifest[\"map_slug\"].value_counts()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "decode-md",
+   "metadata": {},
+   "source": [
+    "## 2. Stream one sample\n",
+    "\n",
+    "We stream from the small preview repo (no full download). `decode_sample` turns one shard sample into numpy arrays plus mp4 bytes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "decode-code",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from counterstrike1k import load_sample\n",
+    "\n",
+    "samples = list(load_sample())  # downloads ~2 GB on first call, then cached.\n",
+    "sample = samples[0]\n",
+    "\n",
+    "print(\"key:    \", sample[\"key\"])\n",
+    "print(\"actions:\", sample[\"actions\"].shape, sample[\"actions\"].dtype.names)\n",
+    "print(\"state:  \", sample[\"state\"].shape, sample[\"state\"].dtype.names[:6], \"...\")\n",
+    "print(\"events: \", len(sample[\"events\"]), \"events\")\n",
+    "print(\"video:  \", len(sample[\"video\"]), \"mp4 bytes\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "buttons-md",
+   "metadata": {},
+   "source": [
+    "## 3. Inspect actions and state\n",
+    "\n",
+    "Buttons are stored as a `uint16` bitmask. `unpack_buttons` expands them into one boolean array per button (`FORWARD`, `FIRE`, `JUMP`, ...)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "buttons-code",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from counterstrike1k import unpack_buttons\n",
+    "\n",
+    "buttons = unpack_buttons(sample[\"actions\"])\n",
+    "pressed = {name: int(values.sum()) for name, values in buttons.items() if values.any()}\n",
+    "print(\"pressed frames per button:\", pressed)\n",
+    "\n",
+    "state = sample[\"state\"]\n",
+    "print(\"\\nFirst frame:\")\n",
+    "print(f\"  pos    = ({state['pos_x'][0]:.1f}, {state['pos_y'][0]:.1f}, {state['pos_z'][0]:.1f})\")\n",
+    "print(f\"  view   = pitch {state['pitch'][0]:.1f}°, yaw {state['yaw'][0]:.1f}°\")\n",
+    "print(f\"  health = {state['health'][0]}, armor = {state['armor_value'][0]}\")\n",
+    "print(f\"  score  = T {state['t_score'][0]} : CT {state['ct_score'][0]}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "video-md",
+   "metadata": {},
+   "source": [
+    "## 4. Watch the video\n",
+    "\n",
+    "Write the mp4 bytes to a file and embed the player. Audio plays in browsers that allow it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "video-code",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "from IPython.display import Video\n",
+    "\n",
+    "out = Path(\"data/quickstart\") / f\"{sample['key']}.mp4\"\n",
+    "out.parent.mkdir(parents=True, exist_ok=True)\n",
+    "out.write_bytes(sample[\"video\"])\n",
+    "Video(str(out), embed=False, html_attributes=\"controls\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "overlay-md",
+   "metadata": {},
+   "source": [
+    "## 5. Verify alignment with the debug overlay\n",
+    "\n",
+    "When working with action-conditioned video, the first thing you want to check is: *do the labels actually align with the video?* `overlay_frame` draws a HUD with the WASD keys, FIRE/JUMP/DUCK chips, mouse delta, HP/armor/money, and current score onto any frame.\n",
+    "\n",
+    "Pick a frame around something interesting — e.g., the first frame where FIRE is pressed:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "overlay-code-frame",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from counterstrike1k import overlay_frame\n",
+    "\n",
+    "fire_frames = buttons[\"FIRE\"].nonzero()[0]\n",
+    "frame_idx = int(fire_frames[0]) if len(fire_frames) else len(sample[\"actions\"]) // 2\n",
+    "print(f\"showing frame {frame_idx}\")\n",
+    "overlay_frame(sample, frame_idx)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "overlay-video-md",
+   "metadata": {},
+   "source": [
+    "For a moving overlay, `overlay_video` writes a debug mp4. This is what to share with collaborators when you're explaining what's in the dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "overlay-code-video",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from counterstrike1k import overlay_video\n",
+    "\n",
+    "debug_path = Path(\"data/quickstart\") / f\"{sample['key']}.debug.mp4\"\n",
+    "overlay_video(sample, debug_path, max_frames=192)  # ~6 seconds at 32 FPS\n",
+    "Video(str(debug_path), embed=False, html_attributes=\"controls\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "round-md",
+   "metadata": {},
+   "source": [
+    "## 6. Load all 10 POVs of one synchronized round\n",
+    "\n",
+    "Every round has exactly 10 synchronized POVs sharing a `round_id`. Group them with the manifest, then pull each one."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "round-code",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rows = pd.DataFrame([{**s[\"metadata\"], \"frames_actual\": len(s[\"actions\"])} for s in samples])\n",
+    "round_id = rows[\"round_id\"].iloc[0]\n",
+    "round_samples = rows[rows[\"round_id\"] == round_id].sort_values(\"pov_idx\")\n",
+    "print(f\"round {round_id}: {len(round_samples)} POVs\")\n",
+    "round_samples[[\"sample_key\", \"pov_idx\", \"team_side\", \"frames_actual\", \"alive_duration_s\"]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "grid-md",
+   "metadata": {},
+   "source": [
+    "## 7. (Optional) Display all 10 POVs as a grid\n",
+    "\n",
+    "Decodes the midpoint frame from each POV and stacks them into a 5×2 grid."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "grid-code",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import io\n",
+    "import av\n",
+    "from PIL import Image, ImageDraw\n",
+    "\n",
+    "def midpoint_frame(video_bytes):\n",
+    "    with av.open(io.BytesIO(video_bytes)) as container:\n",
+    "        frames = list(container.decode(video=0))\n",
+    "    return frames[len(frames) // 2].to_image()\n",
+    "\n",
+    "by_pov = {int(s[\"metadata\"][\"pov_idx\"]): s for s in samples if s[\"metadata\"][\"round_id\"] == round_id}\n",
+    "tile_w = 320\n",
+    "tiles = []\n",
+    "for pov in sorted(by_pov):\n",
+    "    img = midpoint_frame(by_pov[pov][\"video\"])\n",
+    "    th = int(round(tile_w * img.height / img.width))\n",
+    "    tiles.append((pov, by_pov[pov][\"metadata\"].get(\"team_side\", \"\"), img.resize((tile_w, th))))\n",
+    "\n",
+    "tw, th = tiles[0][2].size\n",
+    "cols, rows_n = 5, 2\n",
+    "grid = Image.new(\"RGB\", (cols * tw + 4, rows_n * (th + 22) + 4), (18, 18, 18))\n",
+    "draw = ImageDraw.Draw(grid)\n",
+    "for i, (pov, side, img) in enumerate(tiles):\n",
+    "    r, c = divmod(i, cols)\n",
+    "    x, y = c * tw + 2, r * (th + 22) + 2\n",
+    "    draw.text((x + 4, y), f\"pov {pov} {side}\", fill=(245, 245, 245))\n",
+    "    grid.paste(img, (x, y + 22))\n",
+    "grid"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "next-md",
+   "metadata": {},
+   "source": [
+    "## What's next\n",
+    "\n",
+    "- For training: stream the **360p** or **720p** WebDataset shards. See `examples/torch_dataset.py`.\n",
+    "- For full schema details: open the [`schema/` folder](https://huggingface.co/datasets/ArnieRamesh/CounterStrike-1K/tree/main/schema) on the dataset card.\n",
+    "- For deeper exploration (parquet+offset access, smoke checks): see `examples/advanced/`."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}