CS2-Major-ELO-PickEm-Predictor

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

CS2-Major-ELO-PickEm-Predictor

★ 12 Open GitHub ↗

ELO based CS2 Major Swiss stage and Pick'Em predictor

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# CS2 Major Swiss System Predictor

[中文](README_CN.md) | English

This project predicts CS2 Major Swiss stage results with ELO ratings, Monte Carlo simulation, and Valve's Buchholz pairing rules.

It runs Swiss round simulations, then searches valid Pick'Em combinations for the highest pass rate.

**v2.0 supports GPU acceleration** through PyTorch. Credit to **[Tenzray](https://github.com/Tenzray)** for the PR.

## Recent Updates (2026-05-27)

- `cs2_gen_preresult.py` now uses [Valve Ranking System](https://github.com/ValveSoftware/counter-strike_regional_standings) snapshots as the rating anchor.
- Initial ratings blend VRS-derived ELO with HLTV player stats.
- ELO replay uses the configured pre-event window.
- `PREDICTION_CUTOFF_DATE` sets the prediction data snapshot date.
- LAN weighting, event quality, form variance, anti-farm weighting, and VRS reliability prior are controlled by feature switches.
- `output/intermediate_sim_data.json` stores `config_snapshot`.

Default feature settings:

```python
LAN_WEIGHT_MODE = "neutral"
EVENT_QUALITY_MODE = "off"
FORM_VARIANCE_MODE = "fixed"
USE_ANTI_FARM = False
USE_VRS_RELIABILITY_PRIOR = True
```

## Data Format (Must follow this format when modifying match and team data)

### `data/cs2_cleaned_matches.csv`

CSV file without header, 7 columns:

```
date,team1,score1,score2,team2,tournament,format
2025-11-21,Team A,2,1,Team B,Example Tournament,bo3
2025-11-20,Team C,16,14,Team D,Example League,bo1
```

- `date`: YYYY-MM-DD format
- `team1`, `team2`: Team names. They must match `SEEDED_TEAMS`.
- `score1`, `score2`: Match scores
- `tournament`: Tournament label
- `format`: `bo1`, `bo3`, or `bo5`

### `data/hltv_ratings.txt` (optional)

CSV with header, HLTV ratings:

```csv
team,Maps,KD_diff,KD,Rating
Team A,120,+250,1.08,1.09
Team B,95,+180,1.06,1.07
```

Only `team` and `Rating` are used.

## Usage

### 1. Install dependencies

```bash
pip install -r requirements.txt
```

For GPU acceleration, install CUDA. PyTorch will use the GPU when available.

### 2. Configure simulation settings

Edit `batchsize.yaml` to adjust performance:

```yaml
simulation:
  num_simulations: 500  # Number of Monte Carlo simulations

performance:
  eval_batch_size: 5000  # Adjust based on GPU memory
  save_every: 1000000    # Checkpoint frequency

device:
  use_gpu: true          # true for GPU, false for CPU
  gpu_id: 0              # GPU device ID (usually 0)
```

### 3. Edit seed rankings

Edit `cs2_gen_preresult.py`:

```python
SEEDED_TEAMS = [
    "Team A",  # Seed 1
    "Team B",  # Seed 2
    # ... 16 teams total, in seed order
]

ROUND1_MATCHUPS = [
    ("Team A", "Team I"),
    ("Team B", "Team J"),
    # ... 8 official round 1 matchups
]
```

Replace the placeholders with real team names. `SEEDED_TEAMS` must follow official seed order. `ROUND1_MATCHUPS` must match the official round 1 schedule.

Set `REQUIRE_ROUND1_CONFIRMATION = True` if you want a schedule check before running.

### 4. Run two-step workflow

**Step 1: Generate simulation data**

```bash
python cs2_gen_preresult.py
```

This creates `output/intermediate_sim_data.json`.

**Step 2: GPU-accelerated Pick'Em optimization**

```bash
python cs2_gen_final.py
```

## Core Logic

### ELO Rating System

The current predictor uses:

- VRS-based initial ratings
- HLTV player stats as a secondary rating signal
- ELO replay over the configured pre-event window
- Time decay for older matches
- Format weights: BO1=0.8, BO3=1.0, BO5=1.2
- Optional LAN, event-quality, anti-farm, and VRS reliability switches
- Form variance for Swiss simulation randomness

Win probability: `P = 1 / (1 + 10^((rating2-rating1)/400))`

### Buchholz Swiss Pairing

Based on [Valve's official rules](https://github.com/ValveSoftware/counter-strike_rules_and_regs/blob/main/major-supplemental-rulebook.md)

### Pick'Em Search

Brute-force enumerates all valid combinations:

- 2 teams with 3-0
- 6 teams with 3-1 or 3-2
- 2 teams with 0-3

Total: C(16,6) × C(10,2) × C(8,2) = 10,090,080 combinations

Selects the combo with highest success rate (at least 5 hits) from 100k simulations.

**v2.0 GPU optimization:** PyTorch tensors and matrix multiplication are used for batch evaluation.

### Final Output

**Generated files:**

- `output/final_prediction.json` - Full results with best Pick'Em combination
- `output/optimized_report.txt` - Human-readable recommendations
- `output/intermediate_sim_data.json` - Cached simulation data (from step 1)
- `gpu_checkpoint.json` - Auto-saved progress (can resume if interrupted)

**Notes:**

- Each team needs at least 10 historical matches for reliable predictions
- Delete `gpu_checkpoint.json` if you want to restart optimization from scratch
- The two-step design allows you to rerun step 2 with different settings without regenerating simulations
- CPU version `cs2_swiss_predictor_cpu.py` available for users without GPU

Finally, this project is inspired by [claabs/cs-buchholz-simulator](https://github.com/claabs/cs-buchholz-simulator)

CS2-Major-ELO-PickEm-Predictor

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README