Datasets:

Pierrax
/

ffe-history

#!/usr/bin/env python3
"""Feature Engineering pour ALICE - Pipeline ML.
Ce module orchestre le pipeline de feature engineering.
Les features sont extraites par des modules specialises (ISO 5055 SRP).
Modules:
- features/reliability.py: Fiabilite club/joueur
- features/performance.py: Forme, couleur, position
- features/standings.py: Classement, zones d'enjeu
- features/advanced.py: H2H, fatigue, trajectoire Elo
- features/ffe_features.py: Features reglementaires FFE
- features/pipeline.py: Orchestration extraction/merge
Conformite ISO/IEC:
- 5055: Code maintenable (<300 lignes, SRP)
- 5259: Qualite donnees ML
- 25010: Qualite systeme
- 42001: Gouvernance IA
Usage:
    python scripts/feature_engineering.py
    python scripts/feature_engineering.py --output-dir data/features
"""

from __future__ import annotations

import argparse
import logging
from pathlib import Path

import pandas as pd

from scripts.features.pipeline import extract_all_features, merge_all_features

# Configuration paths
PROJECT_DIR = Path(__file__).parent.parent
DEFAULT_DATA_DIR = PROJECT_DIR / "data"

# Logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)-7s | %(message)s",
    datefmt="%H:%M:%S",
)
logger = logging.getLogger(__name__)


# ==============================================================================
# SPLIT TEMPOREL
# ==============================================================================


def temporal_split(
    df: pd.DataFrame,
    train_end: int = 2022,
    valid_end: int = 2023,
) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
    """Split temporel des données pour éviter data leakage."""
    logger.info(
        f"Split temporel: train<={train_end}, valid={train_end + 1}-{valid_end}, test>{valid_end}"
    )

    train = df[df["saison"] <= train_end]
    valid = df[(df["saison"] > train_end) & (df["saison"] <= valid_end)]
    test = df[df["saison"] > valid_end]

    for name, split in [("Train", train), ("Valid", valid), ("Test", test)]:
        if not split.empty and "saison" in split.columns:
            logger.info(
                f"  {name}: {len(split):,} échiquiers "
                f"({split['saison'].min()}-{split['saison'].max()})"
            )
        else:
            logger.info(f"  {name}: {len(split):,} échiquiers")

    return train, valid, test


# ==============================================================================
# PIPELINE V2 - SANS DATA LEAKAGE (ISO 5259 / 42001)
# ==============================================================================


def compute_features_for_split(
    df_split: pd.DataFrame,
    df_history: pd.DataFrame,
    split_name: str,
    include_advanced: bool = True,
) -> pd.DataFrame:
    """Calcule les features pour un split avec historique approprié.
    ISO 5259: Pas de data leakage - historique limité au passé visible.
    ISO 5055: Complexité réduite via helpers (merge_helpers.py).
    """
    logger.info(
        f"  Computing features for {split_name} using {len(df_history):,} historical records..."
    )

    # Filter played games only
    df_history_played = df_history[
        ~df_history["type_resultat"].isin(
            ["non_joue", "forfait_blanc", "forfait_noir", "double_forfait"]
        )
    ]

    # Extract all features from history
    features = extract_all_features(df_history, df_history_played, include_advanced)

    # Merge features onto split
    result = merge_all_features(df_split.copy(), features, include_advanced)

    # Direct features (no history needed, computed per-row)
    _add_direct_features(result)

    # Temporal + adversaire features
    _add_contextual_features(result, df_history_played)

    logger.info(f"  {split_name}: {len(result):,} samples, {len(result.columns)} features")
    return result


def _add_direct_features(result: pd.DataFrame) -> None:
    """Add features computed directly from the row (no history needed)."""
    from scripts.features.composition import extract_home_feature, extract_title_features
    from scripts.features.player_enrichment import enrich_from_joueurs

    # Titre FIDE numérique + diff_titre
    title_feats = extract_title_features(result)
    for col in title_feats.columns:
        result[col] = title_feats[col]

    # Domicile blanc
    home_feat = extract_home_feature(result)
    for col in home_feat.columns:
        result[col] = home_feat[col]

    # Enrichissement joueur depuis joueurs.parquet (elo_type, categorie, k_coefficient)
    joueurs_path = DEFAULT_DATA_DIR / "joueurs.parquet"
    enrich_from_joueurs(result, joueurs_path)


def _add_contextual_features(result: pd.DataFrame, df_history_played: pd.DataFrame) -> None:
    """Add temporal, adversaire, and match context features."""
    from scripts.features.pipeline_extended import (
        extract_adversaire_niveau,
        extract_match_important,
        extract_temporal_features,
    )
    from scripts.features.standings import calculate_standings

    extract_temporal_features(result)
    standings = calculate_standings(df_history_played)
    extract_adversaire_niveau(result, standings)
    # match_important needs zone_enjeu columns already merged
    extract_match_important(result)


def run_feature_engineering_v2(
    data_dir: Path,
    output_dir: Path,
    include_advanced: bool = True,
) -> None:
    """Pipeline feature engineering V2 - SANS DATA LEAKAGE.
    ISO/IEC 42001, 5259 Conformant.
    """
    logger.info("=" * 60)
    logger.info("ALICE Engine - Feature Engineering V2 (No Leakage)")
    logger.info("ISO/IEC 42001, 5259 Conformant")
    logger.info("=" * 60)

    # Charger données
    echiquiers_path = data_dir / "echiquiers.parquet"
    if not echiquiers_path.exists():
        logger.error(f"Fichier non trouvé: {echiquiers_path}")
        logger.error("Exécutez d'abord: python scripts/parse_dataset.py")
        return

    logger.info(f"\nChargement {echiquiers_path}...")
    df = pd.read_parquet(echiquiers_path)
    logger.info(f"  {len(df):,} échiquiers chargés")

    # 1. Filtrer parties jouées et Elo valide
    logger.info("\n[1/4] Filtrage données...")
    df_played = df[
        ~df["type_resultat"].isin(["non_joue", "forfait_blanc", "forfait_noir", "double_forfait"])
    ]
    df_clean = df_played[(df_played["blanc_elo"] > 0) & (df_played["noir_elo"] > 0)]
    logger.info(f"  {len(df_clean):,} parties valides")

    # 2. SPLIT TEMPOREL D'ABORD (crucial pour éviter leakage)
    logger.info("\n[2/4] Split temporel AVANT features...")
    train_raw, valid_raw, test_raw = temporal_split(df_clean)

    # 3. Calculer features PAR SPLIT avec historique approprié
    logger.info("\n[3/4] Calcul features per-split (no leakage)...")

    # Train: features calculées sur train uniquement
    logger.info("\n  --- TRAIN ---")
    train = compute_features_for_split(
        df_split=train_raw,
        df_history=df[df["saison"] <= train_raw["saison"].max()],
        split_name="train",
        include_advanced=include_advanced,
    )

    # Valid: features calculées sur train + valid historique
    logger.info("\n  --- VALID ---")
    valid_history = df[df["saison"] <= valid_raw["saison"].max()]
    valid = compute_features_for_split(
        df_split=valid_raw,
        df_history=valid_history,
        split_name="valid",
        include_advanced=include_advanced,
    )

    # Test: features calculées sur tout l'historique (avant test)
    logger.info("\n  --- TEST ---")
    test_history = df[df["saison"] <= test_raw["saison"].min() - 1]
    test = compute_features_for_split(
        df_split=test_raw,
        df_history=test_history,
        split_name="test",
        include_advanced=include_advanced,
    )

    # 4. Export
    logger.info("\n[4/4] Export...")
    output_dir.mkdir(parents=True, exist_ok=True)

    train.to_parquet(output_dir / "train.parquet", index=False)
    valid.to_parquet(output_dir / "valid.parquet", index=False)
    test.to_parquet(output_dir / "test.parquet", index=False)

    # Résumé
    logger.info("\n" + "=" * 60)
    logger.info("Feature engineering V2 terminé!")
    logger.info("=" * 60)
    logger.info(f"\nFichiers générés dans {output_dir}/:")
    logger.info(f"  - train.parquet ({len(train):,} échiquiers, {len(train.columns)} features)")
    logger.info(f"  - valid.parquet ({len(valid):,} échiquiers)")
    logger.info(f"  - test.parquet ({len(test):,} échiquiers)")
    logger.info("\nDATA LEAKAGE: CORRIGÉ")
    logger.info("  - Split temporel effectué AVANT calcul des features")
    logger.info("  - Chaque split utilise uniquement les données historiques visibles")


def main() -> None:
    """Point d'entrée."""
    parser = argparse.ArgumentParser(description="Feature engineering ALICE")
    parser.add_argument(
        "--data-dir",
        type=Path,
        default=DEFAULT_DATA_DIR,
        help="Répertoire des données sources",
    )
    parser.add_argument(
        "--output-dir",
        type=Path,
        default=DEFAULT_DATA_DIR / "features",
        help="Répertoire de sortie",
    )
    parser.add_argument(
        "--no-advanced",
        action="store_true",
        help="Désactiver features avancées (H2H, fatigue, etc.)",
    )
    args = parser.parse_args()

    run_feature_engineering_v2(
        args.data_dir,
        args.output_dir,
        include_advanced=not args.no_advanced,
    )


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Feature Engineering pour ALICE - Pipeline ML.

	Ce module orchestre le pipeline de feature engineering.
	Les features sont extraites par des modules specialises (ISO 5055 SRP).

	Modules:
	- features/reliability.py: Fiabilite club/joueur
	- features/performance.py: Forme, couleur, position
	- features/standings.py: Classement, zones d'enjeu
	- features/advanced.py: H2H, fatigue, trajectoire Elo
	- features/ffe_features.py: Features reglementaires FFE
	- features/pipeline.py: Orchestration extraction/merge

	Conformite ISO/IEC:
	- 5055: Code maintenable (<300 lignes, SRP)
	- 5259: Qualite donnees ML
	- 25010: Qualite systeme
	- 42001: Gouvernance IA

	Usage:
	python scripts/feature_engineering.py
	python scripts/feature_engineering.py --output-dir data/features
	"""

	from __future__ import annotations

	import argparse
	import logging
	from pathlib import Path

	import pandas as pd

	from scripts.features.pipeline import extract_all_features, merge_all_features

	# Configuration paths
	PROJECT_DIR = Path(__file__).parent.parent
	DEFAULT_DATA_DIR = PROJECT_DIR / "data"

	# Logging
	logging.basicConfig(
	level=logging.INFO,
	format="%(asctime)s \| %(levelname)-7s \| %(message)s",
	datefmt="%H:%M:%S",
	)
	logger = logging.getLogger(__name__)


	# ==============================================================================
	# SPLIT TEMPOREL
	# ==============================================================================


	def temporal_split(
	df: pd.DataFrame,
	train_end: int = 2022,
	valid_end: int = 2023,
	) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
	"""Split temporel des données pour éviter data leakage."""
	logger.info(
	f"Split temporel: train<={train_end}, valid={train_end + 1}-{valid_end}, test>{valid_end}"
	)

	train = df[df["saison"] <= train_end]
	valid = df[(df["saison"] > train_end) & (df["saison"] <= valid_end)]
	test = df[df["saison"] > valid_end]

	for name, split in [("Train", train), ("Valid", valid), ("Test", test)]:
	if not split.empty and "saison" in split.columns:
	logger.info(
	f" {name}: {len(split):,} échiquiers "
	f"({split['saison'].min()}-{split['saison'].max()})"
	)
	else:
	logger.info(f" {name}: {len(split):,} échiquiers")

	return train, valid, test


	# ==============================================================================
	# PIPELINE V2 - SANS DATA LEAKAGE (ISO 5259 / 42001)
	# ==============================================================================


	def compute_features_for_split(
	df_split: pd.DataFrame,
	df_history: pd.DataFrame,
	split_name: str,
	include_advanced: bool = True,
	) -> pd.DataFrame:
	"""Calcule les features pour un split avec historique approprié.

	ISO 5259: Pas de data leakage - historique limité au passé visible.
	ISO 5055: Complexité réduite via helpers (merge_helpers.py).
	"""
	logger.info(
	f" Computing features for {split_name} using {len(df_history):,} historical records..."
	)

	# Filter played games only
	df_history_played = df_history[
	~df_history["type_resultat"].isin(
	["non_joue", "forfait_blanc", "forfait_noir", "double_forfait"]
	)
	]

	# Extract all features from history
	features = extract_all_features(df_history, df_history_played, include_advanced)

	# Merge features onto split
	result = merge_all_features(df_split.copy(), features, include_advanced)

	# Direct features (no history needed, computed per-row)
	_add_direct_features(result)

	# Temporal + adversaire features
	_add_contextual_features(result, df_history_played)

	logger.info(f" {split_name}: {len(result):,} samples, {len(result.columns)} features")
	return result


	def _add_direct_features(result: pd.DataFrame) -> None:
	"""Add features computed directly from the row (no history needed)."""
	from scripts.features.composition import extract_home_feature, extract_title_features
	from scripts.features.player_enrichment import enrich_from_joueurs

	# Titre FIDE numérique + diff_titre
	title_feats = extract_title_features(result)
	for col in title_feats.columns:
	result[col] = title_feats[col]

	# Domicile blanc
	home_feat = extract_home_feature(result)
	for col in home_feat.columns:
	result[col] = home_feat[col]

	# Enrichissement joueur depuis joueurs.parquet (elo_type, categorie, k_coefficient)
	joueurs_path = DEFAULT_DATA_DIR / "joueurs.parquet"
	enrich_from_joueurs(result, joueurs_path)


	def _add_contextual_features(result: pd.DataFrame, df_history_played: pd.DataFrame) -> None:
	"""Add temporal, adversaire, and match context features."""
	from scripts.features.pipeline_extended import (
	extract_adversaire_niveau,
	extract_match_important,
	extract_temporal_features,
	)
	from scripts.features.standings import calculate_standings

	extract_temporal_features(result)
	standings = calculate_standings(df_history_played)
	extract_adversaire_niveau(result, standings)
	# match_important needs zone_enjeu columns already merged
	extract_match_important(result)


	def run_feature_engineering_v2(
	data_dir: Path,
	output_dir: Path,
	include_advanced: bool = True,
	) -> None:
	"""Pipeline feature engineering V2 - SANS DATA LEAKAGE.

	ISO/IEC 42001, 5259 Conformant.
	"""
	logger.info("=" * 60)
	logger.info("ALICE Engine - Feature Engineering V2 (No Leakage)")
	logger.info("ISO/IEC 42001, 5259 Conformant")
	logger.info("=" * 60)

	# Charger données
	echiquiers_path = data_dir / "echiquiers.parquet"
	if not echiquiers_path.exists():
	logger.error(f"Fichier non trouvé: {echiquiers_path}")
	logger.error("Exécutez d'abord: python scripts/parse_dataset.py")
	return

	logger.info(f"\nChargement {echiquiers_path}...")
	df = pd.read_parquet(echiquiers_path)
	logger.info(f" {len(df):,} échiquiers chargés")

	# 1. Filtrer parties jouées et Elo valide
	logger.info("\n[1/4] Filtrage données...")
	df_played = df[
	~df["type_resultat"].isin(["non_joue", "forfait_blanc", "forfait_noir", "double_forfait"])
	]
	df_clean = df_played[(df_played["blanc_elo"] > 0) & (df_played["noir_elo"] > 0)]
	logger.info(f" {len(df_clean):,} parties valides")

	# 2. SPLIT TEMPOREL D'ABORD (crucial pour éviter leakage)
	logger.info("\n[2/4] Split temporel AVANT features...")
	train_raw, valid_raw, test_raw = temporal_split(df_clean)

	# 3. Calculer features PAR SPLIT avec historique approprié
	logger.info("\n[3/4] Calcul features per-split (no leakage)...")

	# Train: features calculées sur train uniquement
	logger.info("\n --- TRAIN ---")
	train = compute_features_for_split(
	df_split=train_raw,
	df_history=df[df["saison"] <= train_raw["saison"].max()],
	split_name="train",
	include_advanced=include_advanced,
	)

	# Valid: features calculées sur train + valid historique
	logger.info("\n --- VALID ---")
	valid_history = df[df["saison"] <= valid_raw["saison"].max()]
	valid = compute_features_for_split(
	df_split=valid_raw,
	df_history=valid_history,
	split_name="valid",
	include_advanced=include_advanced,
	)

	# Test: features calculées sur tout l'historique (avant test)
	logger.info("\n --- TEST ---")
	test_history = df[df["saison"] <= test_raw["saison"].min() - 1]
	test = compute_features_for_split(
	df_split=test_raw,
	df_history=test_history,
	split_name="test",
	include_advanced=include_advanced,
	)

	# 4. Export
	logger.info("\n[4/4] Export...")
	output_dir.mkdir(parents=True, exist_ok=True)

	train.to_parquet(output_dir / "train.parquet", index=False)
	valid.to_parquet(output_dir / "valid.parquet", index=False)
	test.to_parquet(output_dir / "test.parquet", index=False)

	# Résumé
	logger.info("\n" + "=" * 60)
	logger.info("Feature engineering V2 terminé!")
	logger.info("=" * 60)
	logger.info(f"\nFichiers générés dans {output_dir}/:")
	logger.info(f" - train.parquet ({len(train):,} échiquiers, {len(train.columns)} features)")
	logger.info(f" - valid.parquet ({len(valid):,} échiquiers)")
	logger.info(f" - test.parquet ({len(test):,} échiquiers)")
	logger.info("\nDATA LEAKAGE: CORRIGÉ")
	logger.info(" - Split temporel effectué AVANT calcul des features")
	logger.info(" - Chaque split utilise uniquement les données historiques visibles")


	def main() -> None:
	"""Point d'entrée."""
	parser = argparse.ArgumentParser(description="Feature engineering ALICE")
	parser.add_argument(
	"--data-dir",
	type=Path,
	default=DEFAULT_DATA_DIR,
	help="Répertoire des données sources",
	)
	parser.add_argument(
	"--output-dir",
	type=Path,
	default=DEFAULT_DATA_DIR / "features",
	help="Répertoire de sortie",
	)
	parser.add_argument(
	"--no-advanced",
	action="store_true",
	help="Désactiver features avancées (H2H, fatigue, etc.)",
	)
	args = parser.parse_args()

	run_feature_engineering_v2(
	args.data_dir,
	args.output_dir,
	include_advanced=not args.no_advanced,
	)


	if __name__ == "__main__":
	main()