README.md

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