Unit293/CQ-Avatar-Training

CQ-AVATAR: CS2 Pro Player Behavioral Sequence Dataset

Author: Eimantas Kulbe
Project: CounterQuant — CS2 Intelligence Platform
License: CC BY 4.0 — free to use with attribution

If you use this dataset in research or a product, citation is required. See the 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

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

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 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:

@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

---

Contact

Eimantas Kulbe
CounterQuant — CS2 Intelligence Platform
counterquant.com