Datasets:
File size: 5,209 Bytes
ccbe718 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 | """Performance sous pression (matchs décisifs) - ISO 5055/5259.
Ce module implémente le calcul de la performance sous pression.
Feature psychologique: performance en fin de saison ou matchs serrés.
Matchs décisifs (SEUILS DOCUMENTÉS ISO 5259):
- Dernière ronde (ronde >= 7): Format interclubs FFE standard 7-11 rondes.
Les 3 dernières rondes sont généralement décisives pour le classement final.
Référence: Règlement FFE A02, format compétition interclubs.
- Score serré (écart <= 1 point): Match où chaque partie compte.
Justification: pression psychologique maximale quand résultat incertain.
Clutch factor (SEUILS DOCUMENTÉS):
- > 0.1: "clutch" - joueur surperforme sous pression
- < -0.1: "choke" - joueur sous-performe sous pression
- [-0.1, 0.1]: "stable" - pas d'effet significatif
Seuil 0.1 = ~10% de différence de score, significatif statistiquement.
Sources:
- AI Sports Predictions 2025 (ainewshub.org)
- Sports Prediction PMC - "Psychological factors in sports"
- Règlement FFE A02 - Format interclubs
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 numpy as np
import pandas as pd
logger = logging.getLogger(__name__)
def calculate_pressure_performance(df: pd.DataFrame, min_games: int = 3) -> pd.DataFrame:
"""Calcule la performance sous pression (matchs décisifs).
Feature psychologique: performance en fin de saison ou matchs serrés.
Matchs décisifs:
- Dernière ronde (ronde >= 7)
- Score serré (écart <= 1 point)
Args:
----
df: DataFrame échiquiers
min_games: Minimum de matchs décisifs
Returns:
-------
DataFrame avec colonnes:
- joueur_nom: nom joueur
- score_normal: performance matchs normaux
- score_pression: performance matchs décisifs
- nb_pression: nombre matchs décisifs
- clutch_factor: score_pression - score_normal
- pressure_type: 'clutch' (>0.1), 'choke' (<-0.1), 'stable'
ISO 5259: Performance pression depuis contexte réel.
"""
logger.info("Calcul performance sous pression...")
if df.empty:
return pd.DataFrame()
parties = _prepare_pressure_df(df)
pressure_stats = _collect_pressure_stats(parties)
result = _build_pressure_result(pressure_stats, min_games)
logger.info(f" {len(result)} joueurs avec stats pression")
return result
def _prepare_pressure_df(df: pd.DataFrame) -> pd.DataFrame:
"""Prepare le DataFrame avec flag decisif."""
parties = df[
~df["type_resultat"].isin(["non_joue", "forfait_blanc", "forfait_noir", "double_forfait"])
].copy()
parties["is_decisive"] = parties.apply(_is_decisive, axis=1)
return parties
def _is_decisive(row: pd.Series) -> bool:
"""Determine si un match est decisif."""
ronde = row.get("ronde", 0)
score_dom = row.get("score_dom", 0)
score_ext = row.get("score_ext", 0)
return ronde >= 7 or abs(score_dom - score_ext) <= 1
def _collect_pressure_stats(parties: pd.DataFrame) -> dict[str, dict[str, list[float]]]:
"""Collecte les stats de pression par joueur."""
pressure_stats: dict[str, dict[str, list[float]]] = {}
for couleur in ["blanc", "noir"]:
nom_col, res_col = f"{couleur}_nom", f"resultat_{couleur}"
if nom_col not in parties.columns or res_col not in parties.columns:
continue
for _, row in parties.iterrows():
joueur = str(row[nom_col])
if joueur not in pressure_stats:
pressure_stats[joueur] = {"normal": [], "pressure": []}
key = "pressure" if row["is_decisive"] else "normal"
pressure_stats[joueur][key].append(row[res_col])
return pressure_stats
def _build_pressure_result(
pressure_stats: dict[str, dict[str, list[float]]], min_games: int
) -> pd.DataFrame:
"""Construit le DataFrame resultat."""
result_data = []
for joueur, stats in pressure_stats.items():
entry = _compute_player_pressure(joueur, stats, min_games)
if entry:
result_data.append(entry)
return pd.DataFrame(result_data)
def _compute_player_pressure(joueur: str, stats: dict, min_games: int) -> dict | None:
"""Calcule les stats de pression d'un joueur."""
nb_pressure, nb_normal = len(stats["pressure"]), len(stats["normal"])
if nb_pressure < min_games or nb_normal < min_games:
return None
score_normal = np.mean(stats["normal"])
score_pressure = np.mean(stats["pressure"])
clutch = score_pressure - score_normal
ptype = _classify_pressure_type(clutch)
return {
"joueur_nom": joueur,
"score_normal": score_normal,
"score_pression": score_pressure,
"nb_normal": nb_normal,
"nb_pression": nb_pressure,
"clutch_factor": clutch,
"pressure_type": ptype,
}
def _classify_pressure_type(clutch: float) -> str:
"""Classifie le type de pression."""
if clutch > 0.1:
return "clutch"
if clutch < -0.1:
return "choke"
return "stable"
|