Add professional dataset card (author: Eimantas Kulbe, CC BY 4.0)

README.md

@@ -0,0 +1,198 @@
+---
+annotations_creators:
+  - machine-generated
+language:
+  - en
+license: cc-by-4.0
+pretty_name: "CQ-AVATAR: CS2 Pro Player Behavioral Sequence Dataset"
+size_categories:
+  - 1M<n<10M
+tags:
+  - counter-strike
+  - cs2
+  - esports
+  - player-behavior
+  - sequence-modeling
+  - transformer
+  - behavioral-cloning
+task_categories:
+  - other
+task_ids:
+  - other-other-sequence-prediction
+dataset_info:
+  features:
+    - name: steamid
+      dtype: string
+    - name: map_name
+      dtype: string
+    - name: game
+      dtype: string
+    - name: features
+      dtype: binary
+  splits:
+    - name: train
+      num_examples: 1827929
+    - name: validation
+      num_examples: 202652
+---
+
+# CQ-AVATAR: CS2 Pro Player Behavioral Sequence Dataset
+
+**Author:** Eimantas Kulbe  
+**Project:** [CounterQuant](https://counterquant.com) — CS2 Intelligence Platform  
+**License:** [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) — free to use with attribution
+
+> If you use this dataset in research or a product, citation is required. See the [Citation](#citation) section below.
+
+---
+
+## Dataset Summary
+
+CQ-AVATAR is a large-scale behavioral sequence dataset derived from professional Counter-Strike 2 (CS2) match demos. It captures the moment-to-moment game state experienced by individual players across thousands of professional matches, enabling sequence modeling, behavioral cloning, and player-style representation learning.
+
+Each record is a fixed-length window of 512 game ticks (~8 seconds at 64 Hz) from a single player's perspective, encoded as a 41-dimensional feature vector per tick. The dataset covers 910 unique professional players across multiple maps and tournament tiers.
+
+---
+
+## Dataset Statistics
+
+| Statistic | Value |
+|-----------|-------|
+| Total sequences | 2,030,581 |
+| Train split | 1,827,929 (90%) |
+| Validation split | 202,652 (10%) |
+| Sequence length | 512 ticks (480 input + 32 prediction horizon) |
+| Features per tick | 41 |
+| Unique players | 910 |
+| Game tick rate | 64 Hz (~8 seconds per sequence) |
+| Raw file size | ~37 GB (Parquet, Snappy compressed) |
+
+---
+
+## Feature Description
+
+Each sequence contains 41 features per tick, split into two groups:
+
+### Player State (29 features)
+Position (x, y, z), velocity (vx, vy, vz), view angles (yaw, pitch), health, armor, active weapon, ammo, crouching state, in-air flag, flash duration, scoped flag, accuracy penalty, fire count, reload state, and movement smoothness metrics.
+
+### Teammate Context (12 features)
+Aggregate statistics over the player's 4 teammates: average health, alive count, average position delta, nearest teammate distance, team economic value, defuse kit presence, and coordinated movement indicators.
+
+### Prediction Target
+The model is trained to predict the player's state 32 ticks (~0.5 seconds) into the future — a causal next-state prediction objective that forces the backbone to learn game physics, positioning logic, and tactical intent.
+
+---
+
+## Data Format
+
+The dataset is stored as a single Parquet file (`avatar_sequences.parquet`) with the following schema:
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `steamid` | string | Player's Steam ID (64-bit) |
+| `map_name` | string | CS2 map name (e.g. `de_mirage`) |
+| `game` | string | Game variant (`cs2` or `csgo`) |
+| `seq_len` | int32 | Actual sequence length (≤512) |
+| `n_feats` | int32 | Feature dimensionality (41) |
+| `features` | binary | Raw float32 array: shape `(seq_len, n_feats)`, row-major |
+
+### Loading Example
+
+```python
+import polars as pl
+import numpy as np
+
+df = pl.read_parquet("avatar_sequences.parquet")
+
+# Decode a single sequence
+row = df.row(0, named=True)
+seq = np.frombuffer(row["features"], dtype=np.float32).reshape(row["seq_len"], row["n_feats"])
+# seq.shape → (512, 41)
+
+x = seq[:-32]   # input: ticks 0–479
+y = seq[32:]    # target: ticks 32–511 (causal shift)
+```
+
+### PyTorch DataLoader Example
+
+```python
+from torch.utils.data import IterableDataset
+import pyarrow.parquet as pq
+import numpy as np, torch
+
+class AvatarDataset(IterableDataset):
+    def __init__(self, path):
+        self.path = path
+        self.pf   = pq.ParquetFile(path)
+
+    def __iter__(self):
+        for batch in self.pf.iter_batches(batch_size=256, columns=["features", "seq_len", "n_feats"]):
+            for feat_bytes, seq_len, n_feats in zip(
+                batch["features"].to_pylist(),
+                batch["seq_len"].to_pylist(),
+                batch["n_feats"].to_pylist(),
+            ):
+                seq = np.frombuffer(feat_bytes, dtype=np.float32).reshape(seq_len, n_feats)
+                x   = torch.from_numpy(seq[:-32].copy())
+                y   = torch.from_numpy(seq[32:].copy())
+                yield x, y
+```
+
+---
+
+## Source & Construction
+
+Sequences were extracted from professional CS2 and CS:GO match demos obtained from HLTV.org. Demos were parsed using [demoparser2](https://github.com/LaihoE/demoparser2) at the tick level. Per-player sequences were extracted with a stride of 64 ticks, filtered to rounds with ≥ 480 clean ticks, and normalized per-feature using robust statistics (median + IQR).
+
+The train/validation split is **per-player** — all sequences from a given player appear in exactly one split, preventing data leakage across the sequence boundary.
+
+---
+
+## Intended Use
+
+This dataset is intended for:
+- **Sequence modeling** of CS2 player behavior (transformer, LSTM, state-space models)
+- **Behavioral cloning** — learning pro-level positioning and movement
+- **Player style representation** — embedding player identity from game state alone
+- **Anomaly detection** — identifying unusual in-game behavior
+- **CS2 AI research** — any task requiring structured, large-scale pro-play data
+
+### Out-of-Scope Use
+- Real-time cheating detection tools intended to flag live players
+- Surveillance or profiling of players without consent
+- Any commercial use without written permission from the author
+
+---
+
+## Licensing & Citation
+
+This dataset is released under the **Creative Commons Attribution 4.0 International (CC BY 4.0)** license. You are free to use, share, and adapt this dataset for any purpose, including commercial, **as long as you provide appropriate credit and cite the dataset**.
+
+### Citation
+
+If you use this dataset in a publication, product, or project, you **must** cite it as follows:
+
+```bibtex
+@dataset{kulbe2025cqavatar,
+  author    = {Kulbe, Eimantas},
+  title     = {{CQ-AVATAR}: {CS2} Pro Player Behavioral Sequence Dataset},
+  year      = {2025},
+  publisher = {CounterQuant},
+  url       = {https://huggingface.co/datasets/Unit293/CQ-Avatar-Training},
+  note      = {2.03M sequences extracted from professional CS2 match demos.
+               Released under CC BY 4.0. Attribution required.}
+}
+```
+
+For non-academic use (blog posts, products, apps), please include:
+
+> Dataset by Eimantas Kulbe / CounterQuant — [counterquant.com](https://counterquant.com)
+
+---
+
+## Contact
+
+**Eimantas Kulbe**  
+CounterQuant — CS2 Intelligence Platform  
+[counterquant.com](https://counterquant.com)