Datasets:
File size: 4,884 Bytes
bcf9c29 | 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 | """Présence joueur (ALI) - ISO 5055/5259.
Ce module calcule les features de présence pour ALI
(Adversarial Lineup Inference).
Features (DOCUMENTÉES ISO 5259):
- taux_presence_saison: % rondes jouées cette saison [0, 1]
- derniere_presence: Nombre de rondes depuis dernière apparition
- regularite: Classification basée sur taux de présence
- 'regulier': > 70% des rondes (titulaire stable)
- 'occasionnel': 30-70% des rondes (rotation)
- 'rare': < 30% des rondes (remplaçant, blessé, indisponible)
Justification seuils:
- 70%: Joueur présent 6+ rondes sur 9 = titulaire
- 30%: Joueur présent 2-3 rondes sur 9 = remplaçant occasionnel
- Référence: Analyse statistique compositions interclubs FFE
Conformité:
- ISO 5055: Module <300 lignes, responsabilité unique
- ISO 5259: Features depuis données réelles, seuils documentés
- ISO 42001: Prédictions AI traçables
"""
from __future__ import annotations
import logging
import pandas as pd
logger = logging.getLogger(__name__)
def calculate_presence_features(
df: pd.DataFrame,
saison: int | None = None,
) -> pd.DataFrame:
"""Calcule les features de présence par joueur.
Args:
----
df: DataFrame échiquiers avec colonnes joueur, ronde, saison
saison: Saison à analyser (None = toutes)
Returns:
-------
DataFrame avec colonnes:
- joueur_nom: nom joueur
- saison: saison concernée
- taux_presence_saison: float [0, 1]
- derniere_presence: int (nb rondes depuis dernier match)
- nb_rondes_jouees: int
- nb_rondes_total: int
- regularite: 'regulier', 'occasionnel', 'rare'
ISO 5259: Présence calculée depuis historique réel.
"""
logger.info("Calcul features présence joueur...")
df_filtered = _filter_by_saison(df, saison)
if df_filtered.empty:
return pd.DataFrame()
presence_data = _collect_presence_data(df_filtered)
result = _aggregate_presence_data(presence_data)
logger.info(f" {len(result)} joueurs avec features présence")
return result
def _filter_by_saison(df: pd.DataFrame, saison: int | None) -> pd.DataFrame:
"""Filtre le DataFrame par saison."""
if df.empty:
return pd.DataFrame()
if saison is not None:
return df[df["saison"] == saison].copy()
return df
def _collect_presence_data(df: pd.DataFrame) -> list[dict]:
"""Collecte les donnees de presence par joueur/saison."""
presence_data = []
for s in df["saison"].unique():
df_saison = df[df["saison"] == s]
nb_rondes_total = df_saison["ronde"].nunique()
if nb_rondes_total == 0:
continue
ronde_max = df_saison["ronde"].max()
_collect_saison_presence(df_saison, s, nb_rondes_total, ronde_max, presence_data)
return presence_data
def _collect_saison_presence(
df_saison: pd.DataFrame, s: int, nb_rondes_total: int, ronde_max: int, presence_data: list
) -> None:
"""Collecte presence pour une saison."""
for couleur in ["blanc", "noir"]:
nom_col = f"{couleur}_nom"
if nom_col not in df_saison.columns:
continue
for joueur, group in df_saison.groupby(nom_col):
entry = _compute_player_presence(joueur, group, s, nb_rondes_total, ronde_max)
presence_data.append(entry)
def _compute_player_presence(
joueur: str, group: pd.DataFrame, saison: int, nb_rondes_total: int, ronde_max: int
) -> dict:
"""Calcule les stats de presence d'un joueur."""
rondes_jouees = group["ronde"].unique()
nb_rondes_jouees = len(rondes_jouees)
taux = nb_rondes_jouees / nb_rondes_total
regularite = _classify_regularite(taux)
return {
"joueur_nom": joueur,
"saison": saison,
"taux_presence_saison": round(taux, 3),
"derniere_presence": ronde_max - max(rondes_jouees),
"nb_rondes_jouees": nb_rondes_jouees,
"nb_rondes_total": nb_rondes_total,
"regularite": regularite,
}
def _classify_regularite(taux: float) -> str:
"""Classifie la regularite du joueur."""
if taux > 0.7:
return "regulier"
if taux >= 0.3:
return "occasionnel"
return "rare"
def _aggregate_presence_data(presence_data: list[dict]) -> pd.DataFrame:
"""Agrege les donnees de presence."""
result = pd.DataFrame(presence_data)
if not result.empty:
result = (
result.groupby(["joueur_nom", "saison"])
.agg(
taux_presence_saison=("taux_presence_saison", "max"),
derniere_presence=("derniere_presence", "min"),
nb_rondes_jouees=("nb_rondes_jouees", "max"),
nb_rondes_total=("nb_rondes_total", "first"),
regularite=("regularite", "first"),
)
.reset_index()
)
return result
|