Upload code/scripts/features/advanced/pressure.py with huggingface_hub

code/scripts/features/advanced/pressure.py

@@ -0,0 +1,155 @@
+"""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"