Upload train2_model.py

train2_model.py

@@ -0,0 +1,711 @@
+import os
+import json
+import joblib
+import datetime
+import warnings
+import requests
+import numpy as np
+import pandas as pd
+from io import StringIO
+from tqdm import tqdm
+from xgboost import XGBClassifier
+from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import classification_report, roc_auc_score, brier_score_loss, confusion_matrix
+from sklearn.pipeline import Pipeline
+from sklearn.multioutput import MultiOutputClassifier
+from sklearn.base import clone
+from sklearn.calibration import CalibratedClassifierCV
+from imblearn.over_sampling import SMOTE, ADASYN, BorderlineSMOTE
+from imblearn.combine import SMOTEENN, SMOTETomek
+from imblearn.pipeline import Pipeline as ImbPipeline
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Ignorer les avertissements spécifiques
+warnings.filterwarnings("ignore", category=UserWarning)
+
+# Constantes
+LEAGUES = {
+    'F1': 'France Ligue 1', 'F2': 'France Ligue 2',
+    'E0': 'England Premier League', 'E1': 'Championship',
+    'D1': 'Germany Bundesliga', 'D2': '2. Bundesliga',
+    'I1': 'Italy Serie A', 'I2': 'Serie B',
+    'SP1': 'Spain La Liga', 'SP2': 'Segunda Division',
+}
+REQUIRED_COLS = ['Date', 'HomeTeam', 'AwayTeam', 'FTHG', 'FTAG', 'FTR']
+BASE_URL = "https://www.football-data.co.uk/mmz4281"
+TARGET_COLUMNS = ['Home_Win', 'Away_Win', 'Draw', 'Over2.5', 'BTTS']
+
+def fetch_football_data():
+    """Télécharge les données de football des 5 dernières saisons pour les ligues majeures européennes"""
+    current_year = datetime.datetime.now().year
+    seasons = [f"{str(y-1)[-2:]}{str(y)[-2:]}" for y in range(current_year-6, current_year)]
+    all_data = []
+
+    for season in tqdm(seasons, desc="Chargement des saisons"):
+        season_code = season[-4:]
+        for league_code, league_name in LEAGUES.items():
+            try:
+                url = f"{BASE_URL}/{season_code[:2]}{season_code[2:]}/{league_code}.csv"
+                response = requests.get(url, timeout=15)
+                response.raise_for_status()
+
+                # Essayer différents encodages
+                for encoding in ['utf-8', 'latin1', 'iso-8859-1']:
+                    try:
+                        df = pd.read_csv(StringIO(response.text), encoding=encoding,
+                                         parse_dates=['Date'], dayfirst=True, on_bad_lines='warn')
+                        break
+                    except Exception:
+                        continue
+                else:
+                    print(f"⚠️ Erreur d'encodage : {league_code} {season}")
+                    continue
+
+                if not all(col in df.columns for col in REQUIRED_COLS):
+                    print(f"⚠️ Colonnes manquantes : {league_code} {season}")
+                    continue
+
+                df['Season'] = season
+                df['League'] = league_name
+                df['League_Code'] = league_code
+                all_data.append(df)
+            except Exception as e:
+                print(f"⚠️ Erreur {league_code} {season}: {str(e)}")
+                continue
+
+    if not all_data:
+        raise ValueError("Aucune donnée valide chargée.")
+
+    result_df = pd.concat(all_data, ignore_index=True).sort_values('Date')
+    print(f"📊 Données chargées : {len(result_df)} matchs de {len(seasons)} saisons")
+    return result_df
+
+def preprocess_data(df):
+    """Prétraite les données et calcule des caractéristiques additionnelles"""
+    # Nettoyer les noms de colonnes
+    df.columns = [col.strip() for col in df.columns]
+
+    # Mapping pour gérer différentes notations entre saisons
+    mapping = {
+        'HST': ['HST', 'HS', 'HSTS'],  # Plus de variantes pour shots
+        'AST': ['AST', 'AS', 'ASTS'],
+        'HF': ['HF', 'HomeF', 'HFauls'],  # Nouvelles métriques: fautes
+        'AF': ['AF', 'AwayF', 'AFauls'],
+        'HY': ['HY', 'HomeY'], # Cartes jaunes
+        'AY': ['AY', 'AwayY'],
+        'HR': ['HR', 'HomeR'], # Cartes rouges
+        'AR': ['AR', 'AwayR'],
+        'HC': ['HC'], 'AC': ['AC'],
+        'B365H': ['B365H', 'BbHwin'], 'B365D': ['B365D', 'BbDwin'], 'B365A': ['B365A', 'BbAwin'],
+        'B365O2.5': ['B365O2.5', 'BbOver'], 'B365U2.5': ['B365U2.5', 'BbUnder'],
+        'B365GG': ['B365GG', 'BBBTS']
+    }
+
+    # Harmonisation des colonnes basée sur le mapping
+    for target, sources in mapping.items():
+        for col in sources:
+            if col in df.columns:
+                df[target] = pd.to_numeric(df[col], errors='coerce')
+                break
+
+    # Caractéristiques de base des matchs
+    df['Goal_Diff'] = df['FTHG'] - df['FTAG']
+    df['Total_Goals'] = df['FTHG'] + df['FTAG']
+    df['Shot_Diff'] = df.get('HST', 0) - df.get('AST', 0)
+    df['Corners_Diff'] = df.get('HC', 0) - df.get('AC', 0)
+    df['Fouls_Diff'] = df.get('HF', 0) - df.get('AF', 0)
+    df['Yellow_Diff'] = df.get('HY', 0) - df.get('AY', 0)
+    df['Red_Diff'] = df.get('HR', 0) - df.get('AR', 0)
+
+    # Variables cibles
+    df['BTTS'] = ((df['FTHG'] > 0) & (df['FTAG'] > 0)).astype(int)
+    df['Over2.5'] = (df['Total_Goals'] > 2.5).astype(int)
+
+    # Caractéristiques avancées: forme récente (3 et 5 derniers matchs)
+    for team in ['Home', 'Away']:
+        team_col = f'{team}Team'
+
+        # Moyenne des 3 derniers matchs pour diverses statistiques
+        for stat in ['FTHG', 'FTAG', 'Total_Goals', 'BTTS', 'Over2.5']:
+            if stat in df.columns:
+                df[f'{team}_{stat}_Last3'] = df.groupby(team_col)[stat].transform(
+                    lambda x: x.rolling(3, min_periods=1).mean().shift(1))
+
+                # Ajouter moyenne sur 5 matchs
+                df[f'{team}_{stat}_Last5'] = df.groupby(team_col)[stat].transform(
+                    lambda x: x.rolling(5, min_periods=1).mean().shift(1))
+
+        # Statistiques défensives
+        if team == 'Home':
+            df[f'{team}_Goals_Conceded_Last3'] = df.groupby(team_col)['FTAG'].transform(
+                lambda x: x.rolling(3, min_periods=1).mean().shift(1))
+            df[f'{team}_Goals_Conceded_Last5'] = df.groupby(team_col)['FTAG'].transform(
+                lambda x: x.rolling(5, min_periods=1).mean().shift(1))
+        else:
+            df[f'{team}_Goals_Conceded_Last3'] = df.groupby(team_col)['FTHG'].transform(
+                lambda x: x.rolling(3, min_periods=1).mean().shift(1))
+            df[f'{team}_Goals_Conceded_Last5'] = df.groupby(team_col)['FTHG'].transform(
+                lambda x: x.rolling(5, min_periods=1).mean().shift(1))
+
+        # Statistiques de cartes
+        for card_type in ['HY', 'AY', 'HR', 'AR']:
+            if card_type in df.columns:
+                prefix = card_type[0]  # H ou A
+                if (prefix == 'H' and team == 'Home') or (prefix == 'A' and team == 'Away'):
+                    df[f'{team}_Cards_Last3'] = df.groupby(team_col)[card_type].transform(
+                        lambda x: x.rolling(3, min_periods=1).mean().shift(1))
+
+    # Probabilités implicites depuis les cotes
+    odds_columns = {
+        'Implied_Prob_Home': 'B365H',
+        'Implied_Prob_Draw': 'B365D',
+        'Implied_Prob_Away': 'B365A',
+        'Implied_Prob_Over2.5': 'B365O2.5',
+        'Implied_Prob_BTTS': 'B365GG'
+    }
+
+    for prob_col, odds_col in odds_columns.items():
+        if odds_col in df.columns:
+            df[prob_col] = 1 / df[odds_col]
+        else:
+            df[prob_col] = 0.5  # Valeur par défaut si cote non disponible
+
+    # Normalisation des probabilités (somme = 1 pour HDA)
+    if all(col in df.columns for col in ['Implied_Prob_Home', 'Implied_Prob_Draw', 'Implied_Prob_Away']):
+        total_prob = (df['Implied_Prob_Home'].fillna(0) +
+                      df['Implied_Prob_Draw'].fillna(0) +
+                      df['Implied_Prob_Away'].fillna(0))
+        for prob_col in ['Implied_Prob_Home', 'Implied_Prob_Draw', 'Implied_Prob_Away']:
+            df[prob_col] = df[prob_col] / total_prob
+
+    # Points et forme
+    df['Points_Home'] = df['FTR'].map({'H': 3, 'D': 1, 'A': 0})
+    df['Points_Away'] = df['FTR'].map({'A': 3, 'D': 1, 'H': 0})
+
+    # Forme sur différentes périodes
+    for period in [3, 5, 10]:
+        df[f'Home_Form{period}'] = df.groupby('HomeTeam')['Points_Home'].transform(
+            lambda x: x.rolling(period, min_periods=1).mean().shift(1))
+        df[f'Away_Form{period}'] = df.groupby('AwayTeam')['Points_Away'].transform(
+            lambda x: x.rolling(period, min_periods=1).mean().shift(1))
+
+    # Nettoyage final
+    df = df.dropna(subset=['FTHG', 'FTAG', 'FTR', 'Date'])
+    df['Date'] = pd.to_datetime(df['Date'], errors='coerce')
+    df = df.dropna(subset=['Date']).reset_index(drop=True)
+
+    # Ajouter jour de la semaine et mois
+    df['DayOfWeek'] = df['Date'].dt.dayofweek
+    df['Month'] = df['Date'].dt.month
+
+    # Classements au moment du match
+    # Simuler un classement simple en fonction des points accumulés
+    seasons = df['Season'].unique()
+    leagues = df['League'].unique()
+
+    for season in seasons:
+        for league in leagues:
+            season_league_mask = (df['Season'] == season) & (df['League'] == league)
+            season_league_data = df[season_league_mask].sort_values('Date')
+
+            # Initialiser dictionnaires pour les points et matchs joués
+            team_points = {}
+            team_matches = {}
+
+            # Parcourir les matchs chronologiquement
+            for idx, row in season_league_data.iterrows():
+                home_team = row['HomeTeam']
+                away_team = row['AwayTeam']
+
+                # Initialiser si équipes pas encore rencontrées
+                for team in [home_team, away_team]:
+                    if team not in team_points:
+                        team_points[team] = 0
+                        team_matches[team] = 0
+
+                # Enregistrer le classement avant le match
+                df.loc[idx, 'Home_Rank'] = sorted(
+                    [(team, pts/max(1, matches)) for team, pts, matches in
+                     zip(team_points.keys(), team_points.values(), team_matches.values())],
+                    key=lambda x: x[1], reverse=True
+                ).index((home_team, team_points[home_team]/max(1, team_matches[home_team]))) + 1
+
+                df.loc[idx, 'Away_Rank'] = sorted(
+                    [(team, pts/max(1, matches)) for team, pts, matches in
+                     zip(team_points.keys(), team_points.values(), team_matches.values())],
+                    key=lambda x: x[1], reverse=True
+                ).index((away_team, team_points[away_team]/max(1, team_matches[away_team]))) + 1
+
+                # Mettre à jour les points après le match
+                if row['FTR'] == 'H':
+                    team_points[home_team] += 3
+                elif row['FTR'] == 'A':
+                    team_points[away_team] += 3
+                else:  # Draw
+                    team_points[home_team] += 1
+                    team_points[away_team] += 1
+
+                # Mettre à jour les matchs joués
+                team_matches[home_team] += 1
+                team_matches[away_team] += 1
+
+    # Différence de classement
+    df['Rank_Diff'] = df['Home_Rank'] - df['Away_Rank']
+
+    return df
+
+def prepare_features(df):
+    """Prépare les features et les cibles pour l'entraînement"""
+    # Sélection des 5 caractéristiques à utiliser
+    features = [
+        'Shot_Diff',                   # Donne une idée du rapport de force offensif
+        'Home_Total_Goals_Last5',     # Forme récente (attaque)
+        'Away_Total_Goals_Last5',     # Forme récente (attaque)
+        'Home_BTTS_Last5',            # Tendance à marquer + encaisser
+        'Implied_Prob_Home'           # Sentiment des bookmakers
+    ]
+
+    # Filtrer pour ne garder que les colonnes disponibles
+    available_features = [f for f in features if f in df.columns]
+
+    print(f"Features disponibles: {len(available_features)}/{len(features)}")
+    if len(available_features) < len(features):
+        print(f"Features manquantes: {set(features) - set(available_features)}")
+
+    X = df[available_features].copy()
+
+    # Conversion et imputation
+    X = X.apply(pd.to_numeric, errors='coerce')
+
+    # Imputation plus robuste
+    for col in X.columns:
+        # Utiliser la médiane pour l'imputation (plus robuste que la moyenne)
+        X[col] = X[col].fillna(X[col].median())
+
+    # Préparation des variables cibles
+    y = pd.DataFrame({
+        'Home_Win': (df['FTR'] == 'H').astype(int),
+        'Away_Win': (df['FTR'] == 'A').astype(int),
+        'Draw': (df['FTR'] == 'D').astype(int),
+        'Over2.5': (df['Total_Goals'] > 2.5).astype(int),
+        'BTTS': ((df['FTHG'] > 0) & (df['FTAG'] > 0)).astype(int)
+    })
+
+    # Analyse des distributions des cibles
+    for col in y.columns:
+        positive_rate = y[col].mean() * 100
+        print(f"{col}: {positive_rate:.1f}% des cas")
+
+    return X, y
+
+def plot_feature_importance(model, feature_names, targets, save_dir="ml/plots"):
+    """Génère des graphiques de l'importance des features pour chaque cible"""
+    os.makedirs(save_dir, exist_ok=True)
+    estimators = model.named_steps['model'].estimators_
+
+    for i, (target, estimator) in enumerate(zip(targets, estimators)):
+        # Vérifier si l'estimateur est un CalibratedClassifierCV
+        if hasattr(estimator, 'base_estimator'):
+            # Accéder à l'estimateur sous-jacent
+            base_estimator = estimator.base_estimator
+            if hasattr(base_estimator, 'feature_importances_'):
+                importance = base_estimator.feature_importances_
+            else:
+                print(f"L'estimateur pour {target} n'a pas d'attribut feature_importances_")
+                continue
+        elif hasattr(estimator, 'feature_importances_'):
+            importance = estimator.feature_importances_
+        else:
+            print(f"L'estimateur pour {target} n'a pas d'attribut feature_importances_")
+            continue
+
+        indices = np.argsort(importance)[::-1]
+
+        # Graphique des 15 features les plus importantes
+        plt.figure(figsize=(10, 8))
+        plt.title(f'Importance des features pour {target}')
+        plt.barh(range(min(15, len(feature_names))),
+                importance[indices][:15], align='center')
+        plt.yticks(range(min(15, len(feature_names))),
+                  [feature_names[i] for i in indices[:15]])
+        plt.xlabel('Importance relative')
+        plt.tight_layout()
+        plt.savefig(f"{save_dir}/feature_importance_{target}.png")
+        plt.close()
+
+def train_model(X, y):
+    """Entraîne des modèles spécifiques pour chaque cible en utilisant XGBoost"""
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42, stratify=y['Draw'])
+
+    # Définir un modèle de base
+    base_model = XGBClassifier(
+        use_label_encoder=False,
+        eval_metric='logloss',
+        random_state=42,
+        n_jobs=-1
+    )
+
+    # Hyperparamètres à optimiser pour chaque cible
+    param_grids = {
+        'Home_Win': {
+            'n_estimators': [300, 400, 500],
+            'max_depth': [3, 4, 5],
+            'learning_rate': [0.01, 0.03],
+            'subsample': [0.8, 0.9],
+            'colsample_bytree': [0.8, 0.9]
+        },
+        'Away_Win': {
+            'n_estimators': [300, 400, 500],
+            'max_depth': [3, 4, 5],
+            'learning_rate': [0.01, 0.03],
+            'subsample': [0.8, 0.9],
+            'colsample_bytree': [0.8, 0.9]
+        },
+        'Draw': {  # Paramètres plus robustes pour la classe minoritaire
+            'n_estimators': [400, 500, 600],
+            'max_depth': [4, 5, 6],  # Légèrement plus profond pour capturer patterns complexes
+            'learning_rate': [0.005, 0.01, 0.02],  # Taux d'apprentissage plus faible
+            'subsample': [0.8, 0.9],
+            'colsample_bytree': [0.8, 0.9],
+            'scale_pos_weight': [3]  # Donner plus de poids aux exemples minoritaires
+        },
+        'Over2.5': {
+            'n_estimators': [300, 400, 500],
+            'max_depth': [4, 5, 6],
+            'learning_rate': [0.01, 0.03],
+            'subsample': [0.8, 0.9],
+            'colsample_bytree': [0.8, 0.9]
+        },
+        'BTTS': {
+            'n_estimators': [300, 400, 500],
+            'max_depth': [4, 5, 6],
+            'learning_rate': [0.01, 0.03],
+            'subsample': [0.8, 0.9],
+            'colsample_bytree': [0.8, 0.9]
+        }
+    }
+
+    # Techniques de rééquilibrage pour chaque cible
+    resampling_methods = {
+        'Home_Win': SMOTE(random_state=42),
+        'Away_Win': SMOTE(random_state=42),
+        'Draw': SMOTETomek(random_state=42),  # Méthode plus agressive pour la classe la plus déséquilibrée
+        'Over2.5': SMOTEENN(random_state=42),
+        'BTTS': SMOTEENN(random_state=42)
+    }
+
+    # Préparation des pipelines et modèles optimisés pour chaque cible
+    best_params = {}
+    estimators = []
+    scaler = StandardScaler()  # Utiliser StandardScaler au lieu de MinMaxScaler
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+
+    print("\n🔍 Optimisation des hyperparamètres pour chaque cible...")
+
+    for target in y_train.columns:
+        print(f"\nOptimisation pour {target}...")
+
+        # Recherche en grille avec validation croisée stratifiée
+        grid_search = GridSearchCV(
+            estimator=base_model,
+            param_grid=param_grids[target],
+            cv=StratifiedKFold(n_splits=5, shuffle=True, random_state=42),
+            scoring='roc_auc',
+            n_jobs=-1,
+            verbose=0
+        )
+
+        # Appliquer le rééquilibrage et entraîner
+        resampler = resampling_methods[target]
+        X_train_res, y_train_res = resampler.fit_resample(X_train_scaled, y_train[target])
+
+        # Entraîner la recherche en grille
+        grid_search.fit(X_train_res, y_train_res)
+
+        # Récupérer les meilleurs paramètres
+        best_params[target] = grid_search.best_params_
+        print(f"Meilleurs paramètres pour {target}: {best_params[target]}")
+        print(f"Meilleur score: {grid_search.best_score_:.4f}")
+
+        # Créer et entraîner le modèle avec les meilleurs paramètres
+        best_model = XGBClassifier(**best_params[target], random_state=42, use_label_encoder=False)
+
+        # Entraîner avec les données rééquilibrées
+        best_model.fit(
+            X_train_res, y_train_res,
+            eval_set=[(X_test_scaled, y_test[target])],
+            early_stopping_rounds=20,
+            verbose=False
+        )
+
+        # Pour Draw, Over2.5 et BTTS, ajouter une calibration de probabilité
+        if target in ['Draw', 'Over2.5', 'BTTS']:
+            print(f"Calibration des probabilités pour {target}...")
+            calibrated_model = CalibratedClassifierCV(
+                best_model,
+                method='isotonic',  # ou 'sigmoid' selon le cas
+                cv='prefit'  # le modèle est déjà entraîné
+            )
+            calibrated_model.fit(X_train_scaled, y_train[target])
+            estimators.append(calibrated_model)
+        else:
+            estimators.append(best_model)
+
+    # Construire le pipeline complet avec les modèles optimisés
+    multi_model = MultiOutputClassifier(base_model)
+    multi_model.estimators_ = estimators
+
+    pipeline = Pipeline([
+        ('scaler', scaler),
+        ('model', multi_model)
+    ])
+
+    # Générer les graphiques d'importance des features
+    plot_feature_importance(pipeline, X.columns, y.columns)
+
+    return pipeline, X_test, y_test, best_params
+
+def evaluate_model(model, X_test, y_test):
+    """Évalue la performance du modèle et génère des visualisations"""
+    try:
+        y_pred = model.predict(X_test)
+        y_proba = [est.predict_proba(X_test)[:, 1] for est in model.named_steps['model'].estimators_]
+
+        # Créer des dossiers pour les visualisations
+        os.makedirs("ml/plots2", exist_ok=True)
+
+        # Résultats par cible
+        proba_results = {}
+        print("\n==== RÉSULTATS D'ÉVALUATION ====")
+
+        plt.figure(figsize=(12, 10))
+
+        for i, target in enumerate(y_test.columns):
+            proba = y_proba[i]
+            proba_results[target] = proba
+
+            print(f"\n=== Évaluation pour {target} ===")
+            print(classification_report(y_test[target], y_pred[:, i]))
+
+            # Métriques supplémentaires
+            roc_auc = roc_auc_score(y_test[target], proba)
+            brier = brier_score_loss(y_test[target], proba)
+            print(f"ROC AUC: {roc_auc:.3f}")
+            print(f"Brier Score: {brier:.3f}")
+
+            # Confusion matrix
+            cm = confusion_matrix(y_test[target], y_pred[:, i])
+            print(f"Matrice de confusion:\n{cm}")
+
+            # Plot de la matrice de confusion
+            plt.subplot(2, 3, i+1)
+            sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False)
+            plt.title(f'Matrice de confusion: {target}\nAUC: {roc_auc:.3f}')
+            plt.ylabel('Réel')
+            plt.xlabel('Prédit')
+
+        plt.tight_layout()
+        plt.savefig("ml/plots2/confusion_matrices.png")
+        plt.close()
+
+        # Dataframe avec les probabilités prédites
+        proba_df = pd.DataFrame(proba_results, index=X_test.index)
+
+        # Identification de la prédiction avec la probabilité la plus élevée
+        proba_df['Highest_Proba'] = proba_df[y_test.columns].idxmax(axis=1)
+        proba_df['Highest_Proba_Value'] = proba_df[y_test.columns].max(axis=1)
+
+        # Analyse des distributions de probabilités
+        print("\n=== Probabilités moyennes ===")
+        mean_probas = proba_df[y_test.columns].mean().sort_values(ascending=False)
+        print(mean_probas)
+
+        # Distribution des probabilités par classe
+        plt.figure(figsize=(12, 8))
+        for i, target in enumerate(y_test.columns):
+            plt.subplot(2, 3, i+1)
+            sns.histplot(proba_df[target], bins=20, kde=True)
+            plt.axvline(0.5, color='r', linestyle='--')
+            plt.title(f'Distribution des probabilités: {target}')
+            plt.xlabel('Probabilité')
+            plt.ylabel('Fréquence')
+
+        plt.tight_layout()
+        plt.savefig("ml/plots2/probability_distributions.png")
+        plt.close()
+
+        # Calibration des probabilités
+        plt.figure(figsize=(12, 8))
+
+        for i, target in enumerate(y_test.columns):
+            plt.subplot(2, 3, i+1)
+
+            # Regrouper les prédictions en buckets
+            n_bins = 10
+            bins = np.linspace(0, 1, n_bins + 1)
+            binned_preds = np.digitize(proba_df[target], bins) - 1
+            bin_accs = np.zeros(n_bins)
+            bin_confs = np.zeros(n_bins)
+            bin_sizes = np.zeros(n_bins)
+
+            for j in range(n_bins):
+                bin_mask = binned_preds == j
+                if np.sum(bin_mask) > 0:
+                    bin_accs[j] = np.mean(y_test[target].values[bin_mask])
+                    bin_confs[j] = np.mean(proba_df[target].values[bin_mask])
+                    bin_sizes[j] = np.sum(bin_mask)
+
+            # Tracer la courbe de calibration
+            plt.plot(bin_confs, bin_accs, marker='o', linewidth=2, label='Calibration')
+            plt.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Parfaite calibration')
+            plt.title(f'Courbe de calibration: {target}')
+            plt.xlabel('Probabilité prédite')
+            plt.ylabel('Fréquence observée')
+            plt.legend(loc='lower right')
+
+            # Ajouter la taille des bins
+            for j in range(n_bins):
+                if bin_sizes[j] > 0:
+                    plt.text(bin_confs[j], bin_accs[j], f' {int(bin_sizes[j])}',
+                            ha='left', va='center', fontsize=8)
+
+        plt.tight_layout()
+        plt.savefig("ml/plots2/calibration_curves.png")
+        plt.close()
+
+        # Afficher les prédictions les plus confiantes
+        print("\n=== Top 5 des prédictions les plus confiantes ===")
+        print(proba_df.sort_values('Highest_Proba_Value', ascending=False).head(5))
+
+        # Analyse des erreurs les plus importantes
+        print("\n=== Analyse des erreurs ===")
+        errors = pd.DataFrame()
+
+        for target in y_test.columns:
+            # Identifier les faux positifs les plus confiants
+            false_positives = proba_df[
+                (y_test[target] == 0) & (proba_df[target] > 0.75)
+            ].sort_values(target, ascending=False)
+
+            if not false_positives.empty:
+                print(f"\nFaux positifs les plus confiants pour {target}:")
+                print(false_positives.head(3))
+
+            # Identifier les faux négatifs les plus confiants
+            false_negatives = proba_df[
+                (y_test[target] == 1) & (proba_df[target] < 0.25)
+            ].sort_values(target)
+
+            if not false_negatives.empty:
+                print(f"\nFaux négatifs les plus confiants pour {target}:")
+                print(false_negatives.head(3))
+
+        return proba_df
+
+    except Exception as e:
+        print(f"\n❌ Erreur lors de l'évaluation : {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+def save_model_info(model, X, best_params, targets):
+    """Sauvegarde le modèle et les informations associées"""
+    os.makedirs("ml", exist_ok=True)
+
+    # Sauvegarder le modèle
+    joblib.dump(model, "ml/multi_output_model_5.joblib")
+
+    # Sauvegarder les caractéristiques et les paramètres
+    model_info = {
+        "features": list(X.columns),
+        "targets": targets,
+        "best_params": best_params,
+        "created_at": datetime.datetime.now().isoformat()
+    }
+
+    with open("ml/model_info_5.json", "w") as f:
+        json.dump(model_info, f, indent=2)
+
+    print("\n✅ Modèle sauvegardé dans ml/multi_output_model_5.joblib")
+    print("✅ Informations du modèle sauvegardées dans ml/model_info_5.json")
+
+def predict_new_matches(model, features_df, feature_names):
+    """Réalise des prédictions sur de nouveaux matchs"""
+    # S'assurer que les features sont dans le bon ordre
+    X_new = features_df[feature_names].copy()
+
+    # Appliquer le modèle pour obtenir les probabilités
+    y_proba = [est.predict_proba(X_new)[:, 1] for est in model.named_steps['model'].estimators_]
+
+    # Créer le DataFrame de résultats
+    results = pd.DataFrame()
+
+    for i, target in enumerate(TARGET_COLUMNS):
+        results[target] = y_proba[i]
+
+    # Ajouter la prédiction avec la plus haute probabilité
+    results['Highest_Proba'] = results[TARGET_COLUMNS].idxmax(axis=1)
+    results['Highest_Proba_Value'] = results[TARGET_COLUMNS].max(axis=1)
+
+    return results
+
+def main():
+    """Fonction principale"""
+    try:
+        print("🚀 Démarrage du processus d'analyse et modélisation...")
+
+        # Étape 1: Téléchargement des données
+        print("\n⏳ Téléchargement des données...")
+        df = fetch_football_data()
+
+        # Étape 2: Prétraitement
+        print("\n🧹 Prétraitement des données...")
+        df = preprocess_data(df)
+        print(f"\n📊 {len(df)} matchs prêts à l'analyse.")
+
+        # Étape 3: Préparation des features
+        print("\n🔧 Préparation des features...")
+        X, y = prepare_features(df)
+        print(f"\nFeatures utilisées ({len(X.columns)}):")
+        print(", ".join(X.columns))
+
+        # Étape 4: Entraînement du modèle
+        print("\n🤖 Entraînement du modèle...")
+        model, X_test, y_test, best_params = train_model(X, y)
+
+        # Étape 5: Évaluation finale
+        print("\n🔍 Évaluation finale...")
+        evaluate_model(model, X_test, y_test)
+
+        # Étape 6: Sauvegarde
+        save_model_info(model, X, best_params, list(y.columns))
+
+        # Bonus: Préparer un modèle pour de futures prédictions
+        latest_data = df.sort_values('Date').tail(100)
+        print(f"\n📝 Les {len(latest_data)} matchs les plus récents sont disponibles pour des prédictions futures.")
+
+        # Démonstration: prédire les 5 prochains matchs (simulation)
+        print("\n🔮 Démonstration de prédiction pour les 5 derniers matchs:")
+        sample_matches = X_test.head(5)
+        predictions = predict_new_matches(model, sample_matches, X.columns)
+
+        # Afficher HomeTeam et AwayTeam s'ils sont disponibles dans l'index
+        if 'HomeTeam' in df.columns and 'AwayTeam' in df.columns:
+            sample_info = df.loc[sample_matches.index, ['HomeTeam', 'AwayTeam']]
+            predictions = pd.concat([sample_info, predictions], axis=1)
+
+        print(predictions)
+
+        print("\n✅ Processus terminé avec succès!")
+
+    except Exception as e:
+        print(f"\n❌ Erreur: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()