| """Trajectoire Elo (progression/régression) - ISO 5055/5259. |
| |
| Ce module implémente le calcul de la trajectoire Elo par joueur. |
| Feature importante: un joueur en progression peut surperformer son Elo actuel. |
| |
| Classification trajectoire (SEUILS DOCUMENTÉS ISO 5259): |
| - "progression": delta > +50 pts - Joueur en amélioration significative |
| - "regression": delta < -50 pts - Joueur en déclin significatif |
| - "stable": -50 <= delta <= +50 - Performance constante |
| |
| Justification seuil ±50 pts: |
| - Correspond à environ 1 catégorie FFE (50-100 pts par catégorie) |
| - Variation significative mesurable sur 6 matchs (window par défaut) |
| - Référence FIDE Handbook: K-factor implique ~12-20 pts par partie |
| - Statistiquement: ~1 écart-type de variation Elo sur une saison |
| |
| Momentum (SEUIL DOCUMENTÉ): |
| - Normalisé sur [-1, 1] avec diviseur 200 pts |
| - 200 pts = progression/régression extrême sur 6 matchs |
| - Permet comparaison entre joueurs |
| |
| Sources: |
| - EloMetrics IEEE 2025 (https://ieeexplore.ieee.org/document/10879733/) |
| - AI Sports Predictions 2025 (ainewshub.org) |
| - FIDE Handbook - Elo Rating System (K-factor rules) |
| |
| Conformité: |
| - ISO 5055: Module <300 lignes, responsabilité unique |
| - ISO 5259: Features calculées depuis données réelles, seuils documentés |
| """ |
|
|
| from __future__ import annotations |
|
|
| import logging |
|
|
| import pandas as pd |
|
|
| logger = logging.getLogger(__name__) |
|
|
|
|
| def calculate_elo_trajectory(df: pd.DataFrame, window: int = 6) -> pd.DataFrame: |
| """Calcule la trajectoire Elo (progression/régression) par joueur. |
| |
| Feature importante: un joueur en progression peut surperformer son Elo. |
| |
| Args: |
| ---- |
| df: DataFrame échiquiers avec colonnes Elo et date |
| window: Nombre de matchs pour calculer tendance |
| |
| Returns: |
| ------- |
| DataFrame avec colonnes: |
| - joueur_nom: nom joueur |
| - elo_debut: Elo au début de la fenêtre |
| - elo_fin: Elo en fin de fenêtre |
| - elo_delta: variation absolue |
| - elo_trajectory: 'progression' (>50), 'stable' (+-50), 'regression' (<-50) |
| - momentum: score basé sur tendance récente |
| |
| ISO 5259: Trajectoire calculée depuis historique Elo réel. |
| """ |
| logger.info(f"Calcul trajectoire Elo (window={window})...") |
|
|
| df_dated = _prepare_elo_df(df) |
| if df_dated.empty: |
| return pd.DataFrame() |
|
|
| trajectory_data = _collect_trajectory_data(df_dated, window) |
| result = _aggregate_trajectory_data(trajectory_data) |
|
|
| logger.info(f" {len(result)} joueurs avec trajectoire Elo") |
| return result |
|
|
|
|
| def _prepare_elo_df(df: pd.DataFrame) -> pd.DataFrame: |
| """Prepare le DataFrame pour calcul trajectoire.""" |
| if df.empty: |
| return pd.DataFrame() |
|
|
| if "date" not in df.columns: |
| logger.warning(" Colonne date manquante pour trajectoire Elo") |
| return pd.DataFrame() |
|
|
| df_dated = df[df["date"].notna()].copy() |
| df_dated["date"] = pd.to_datetime(df_dated["date"]) |
| return df_dated |
|
|
|
|
| def _collect_trajectory_data(df_dated: pd.DataFrame, window: int) -> list[dict]: |
| """Collecte les donnees de trajectoire par joueur.""" |
| trajectory_data = [] |
|
|
| for couleur in ["blanc", "noir"]: |
| nom_col, elo_col = f"{couleur}_nom", f"{couleur}_elo" |
|
|
| if nom_col not in df_dated.columns or elo_col not in df_dated.columns: |
| continue |
|
|
| for joueur, group in df_dated.groupby(nom_col): |
| entry = _compute_player_trajectory(joueur, group, window, elo_col) |
| if entry: |
| trajectory_data.append(entry) |
|
|
| return trajectory_data |
|
|
|
|
| def _compute_player_trajectory( |
| joueur: str, group: pd.DataFrame, window: int, elo_col: str |
| ) -> dict | None: |
| """Calcule la trajectoire d'un joueur.""" |
| if len(group) < window: |
| return None |
|
|
| elos = group.sort_values("date")[elo_col].dropna().tolist() |
| if len(elos) < window: |
| return None |
|
|
| elo_debut, elo_fin = elos[0], elos[-1] |
| delta = elo_fin - elo_debut |
| trajectory, momentum = _classify_trajectory(delta) |
|
|
| return { |
| "joueur_nom": joueur, |
| "elo_debut": elo_debut, |
| "elo_fin": elo_fin, |
| "elo_delta": delta, |
| "elo_trajectory": trajectory, |
| "momentum": momentum, |
| "nb_matchs": len(elos), |
| } |
|
|
|
|
| def _classify_trajectory(delta: float) -> tuple[str, float]: |
| """Classifie la trajectoire et calcule le momentum.""" |
| if delta > 50: |
| return "progression", min(1.0, delta / 200) |
| if delta < -50: |
| return "regression", max(-1.0, delta / 200) |
| return "stable", 0.0 |
|
|
|
|
| def _aggregate_trajectory_data(trajectory_data: list[dict]) -> pd.DataFrame: |
| """Agrege les donnees de trajectoire.""" |
| result = pd.DataFrame(trajectory_data) |
| if not result.empty: |
| result = ( |
| result.groupby("joueur_nom") |
| .agg( |
| elo_debut=("elo_debut", "first"), |
| elo_fin=("elo_fin", "last"), |
| elo_delta=("elo_delta", "mean"), |
| elo_trajectory=("elo_trajectory", "first"), |
| momentum=("momentum", "mean"), |
| nb_matchs=("nb_matchs", "sum"), |
| ) |
| .reset_index() |
| ) |
| return result |
|
|
