Anyuhhh/pandaskill-lol-gold

PandaSkill Gold-Tier -- Player Performance Models

This repository contains role-specific XGBoost models, scalers, and baseline percentile curves for evaluating League of Legends player performance in Gold-tier ranked play. The work adapts the PandaSkill framework (De Bois et al., 2025) from professional esports data to amateur ranked gameplay, with an added real-time troll detection system.

The training dataset used to produce these models is available at Anyuhhh/pandaskill-lol-gold-data.

Model Description

• Model type: Binary classification (win/loss prediction from player statistics)
• Architecture: XGBoost with monotonicity constraints
• Roles: Top, Jungle, Mid, Bot, Support (one model per role)
• Base framework: PandaSkill by PandaScore
• Training data: ~8,768 Gold-tier NA ranked matches via Riot Match v5 + Timeline API

Repository Structure

Path	Description
models_15_features/	5 role models + 5 scalers trained on full end-game 15-feature set (paper reproduction)
gold_tier_models/	5 role models + 5 scalers trained on 9 timeline-available features (real-time compatible)
gold_tier_models/training_summary.json	Training metrics and configuration summary

Two Model Variants

models_15_features -- Paper Reproduction

Trained on end-game statistics using the full 15-feature set defined in the original PandaSkill paper (Section IV-A, V-B). Each role model is paired with a corresponding scaler for standardization (zero mean, unit variance) applied before inference.

Input features (15): Kill-life-assist ratio, Gold per minute, Experience per minute, Creep score per minute, Wards placed per minute, Damage dealt to champions (normalized), Damage dealt per gold, Damage taken (normalized), Damage taken per gold, Largest multi-kill, Largest killing spree (normalized), Worthless death ratio, Free kill ratio, Objective contest win rate, Objective contest loss rate.

Monotonicity constraints: All features constrained to increase win probability except Worthless death ratio and Objective contest loss rate (constrained to decrease).

gold_tier_models -- Real-Time Compatible

Retrained using only the 9 features extractable from the Riot Timeline API during an active game. Damage-dealt statistics and kill-streak features are set to zero, as the Timeline API does not expose mid-game damage data. Feature importance analysis confirmed these features contribute near-zero predictive power, making the 9-feature model suitable for real-time scoring without significant accuracy loss.

Active features (9): Kill-life-assist ratio, Gold per minute, Experience per minute, Creep score per minute, Wards placed per minute, Damage taken (normalized), Worthless death ratio, Free kill ratio, Objective contest rates.

Training and Evaluation

Training configuration:

• n_estimators: 2,000
• Learning rate: 0.01
• Objective: binary:logistic
• Cross-validation: 5-fold stratified
• Features standardized to zero mean and unit variance

Results (models_15_features):

Metric	Value
Accuracy (5-fold avg)	90.74%
Standard deviation	0.60%
Expected Calibration Error (ECE)	0.93%

This matches the 90.74% accuracy reported in the original PandaSkill paper, confirming successful reproduction of the framework on Gold-tier data.

Scoring Formula

Performance scores are mapped to a 0-10 scale compatible with OP.GG's scoring convention:

score_10 = (relative + 1) / 2 * 10
relative  = 2 * (percentile / 100) - 1

A score of 5.0 represents an average Gold-tier player. Scores below 3.0 indicate bottom-10th-percentile performance and are flagged for troll detection review.

Troll Detection

The window-based detection algorithm compares recent performance slope against early-game baseline using a 3-checkpoint rolling window:

delta_recent = mean(score[t-2 : t+1])
delta_base   = mean(score[0 : t-3])
rel_collapse = delta_recent - delta_base

Collapse flags are suppressed until sufficient game history exists (checkpoint >= 3). Vision-related flags apply only to Support and Jungle roles after minute 12.

Usage

import xgboost as xgb
import json
import numpy as np

# Load model and scaler for a given role
role = "mid"
model = xgb.XGBClassifier()
model.load_model(f"models_15_features/{role}_model.json")

with open(f"models_15_features/{role}_scaler.json") as f:
    scaler_params = json.load(f)

# Standardize features (zero mean, unit variance)
features = np.array([[...]])  # shape (1, 15)
features_scaled = (features - scaler_params["mean"]) / scaler_params["std"]

# Predict win probability
win_prob = model.predict_proba(features_scaled)[0][1]

Intended Uses and Limitations

Intended uses:

• Post-game player performance scoring in Gold-tier ranked play
• Real-time in-game performance monitoring via the Timeline API
• Research into extending professional esports analytics to amateur gameplay
• Abnormal behavior detection for player experience analysis

Limitations:

• Models are trained on NA Gold-tier data and may not generalize to other regions or rank tiers
• The 9-feature real-time model zeroes out damage features unavailable from the Timeline API
• Riot API dev keys expire every 24 hours; production use requires a production key

Citation

@article{debois2025pandaskill,
  title={PandaSkill - Player Performance and Skill Rating in Esports:
         Application to League of Legends},
  author={De Bois, Maxime and Parmentier, Flora and Puget, Raphael
          and Tanti, Matthew and Peltier, Jordan},
  journal={arXiv preprint arXiv:2501.10049},
  year={2025}
}