--- annotations_creators: - machine-generated language: - en license: cc-by-4.0 pretty_name: "CQ-AVATAR: CS2 Pro Player Behavioral Sequence Dataset" size_categories: - 1M 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)