Spaces:
Sleeping
Sleeping
| """ | |
| MODULE: FORECASTING ENGINE - EXPERT EDITION AMÉLIORÉE | |
| ====================================================== | |
| Responsabilité : Entraînement ML, Audit Comparatif (3 Modèles) et Prédiction. | |
| Fonctionnalités : | |
| - Split Train/Val/Test temporel | |
| - Prédiction récursive avec saisonnalité | |
| - SHAP systématique et lisible | |
| - Métriques explicatives pour non-techniciens | |
| - Visualisations avancées | |
| Améliorations v2.0 : | |
| ✅ Split 3 parties (Train 70% / Val 15% / Test 15%) | |
| ✅ Prédiction récursive (utilise ses propres lags) | |
| ✅ SHAP toujours affiché avec explication | |
| ✅ Tableau comparatif détaillé des modèles | |
| ✅ Intervalles de confiance sur prédictions | |
| ✅ Alertes automatiques sur anomalies prévues | |
| ✅ Export des prédictions | |
| """ | |
| import pandas as pd | |
| import numpy as np | |
| import streamlit as st | |
| import plotly.graph_objects as go | |
| from plotly.subplots import make_subplots | |
| from datetime import datetime, timedelta | |
| import warnings | |
| # ML Models | |
| from sklearn.ensemble import RandomForestRegressor | |
| from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score | |
| import xgboost as xgb | |
| import lightgbm as lgb | |
| # SHAP pour interprétabilité | |
| try: | |
| import shap | |
| import matplotlib.pyplot as plt | |
| SHAP_AVAILABLE = True | |
| except ImportError: | |
| SHAP_AVAILABLE = False | |
| warnings.filterwarnings('ignore') | |
| # ===================================================== | |
| # ============= MOTEUR DE PRÉDICTION ================== | |
| # ===================================================== | |
| class HospitalForecaster: | |
| """ | |
| Moteur de prédiction hospitalière avec comparaison de modèles | |
| et interprétabilité SHAP. | |
| """ | |
| def __init__(self, ml_dataset): | |
| self.df = ml_dataset.copy() | |
| self.df['date'] = pd.to_datetime(self.df['date']) | |
| # Stockage des modèles et résultats | |
| self.models = {} | |
| self.metrics = {} | |
| self.predictions = { | |
| 'train': {}, | |
| 'val': {}, | |
| 'test': {} | |
| } | |
| self.best_model_name = None | |
| # Datasets splits | |
| self.X_train = None | |
| self.X_val = None | |
| self.X_test = None | |
| self.y_train = None | |
| self.y_val = None | |
| self.y_test = None | |
| self.dates_train = None | |
| self.dates_val = None | |
| self.dates_test = None | |
| self.feature_names = None | |
| def prepare_data(self, target_col='nb_admissions', val_days=30, test_days=30): | |
| """ | |
| Split temporel en 3 parties : Train / Validation / Test. | |
| Args: | |
| target_col: Variable cible à prédire | |
| val_days: Nombre de jours pour validation | |
| test_days: Nombre de jours pour test | |
| Returns: | |
| Dictionnaire avec les plages de dates | |
| """ | |
| # Tri chronologique | |
| df = self.df.sort_values('date').reset_index(drop=True) | |
| # Exclusion des colonnes non-features | |
| exclude_cols = [ | |
| target_col, 'date', 'stay_id', 'patient_id', | |
| 'scenario', 'service_nom', 'periode_conges_label' | |
| ] | |
| # Sélection STRICTE des colonnes numériques uniquement | |
| all_cols = [c for c in df.columns if c not in exclude_cols] | |
| feature_cols = [c for c in all_cols if np.issubdtype(df[c].dtype, np.number)] | |
| # Vérification de la cible | |
| if target_col not in df.columns: | |
| raise ValueError(f"❌ Colonne cible '{target_col}' introuvable") | |
| # Calcul des indices de split | |
| n = len(df) | |
| test_start = n - test_days | |
| val_start = test_start - val_days | |
| # Extraction X et y | |
| X = df[feature_cols] | |
| y = df[target_col] | |
| dates = df['date'] | |
| # Split | |
| self.X_train = X.iloc[:val_start] | |
| self.X_val = X.iloc[val_start:test_start] | |
| self.X_test = X.iloc[test_start:] | |
| self.y_train = y.iloc[:val_start] | |
| self.y_val = y.iloc[val_start:test_start] | |
| self.y_test = y.iloc[test_start:] | |
| self.dates_train = dates.iloc[:val_start] | |
| self.dates_val = dates.iloc[val_start:test_start] | |
| self.dates_test = dates.iloc[test_start:] | |
| self.feature_names = feature_cols | |
| self.target_col = target_col | |
| # Informations de split | |
| split_info = { | |
| 'train': { | |
| 'start': self.dates_train.min(), | |
| 'end': self.dates_train.max(), | |
| 'n_samples': len(self.X_train) | |
| }, | |
| 'val': { | |
| 'start': self.dates_val.min(), | |
| 'end': self.dates_val.max(), | |
| 'n_samples': len(self.X_val) | |
| }, | |
| 'test': { | |
| 'start': self.dates_test.min(), | |
| 'end': self.dates_test.max(), | |
| 'n_samples': len(self.X_test) | |
| } | |
| } | |
| return split_info | |
| def train_all_models(self): | |
| """ | |
| Entraînement des 3 modèles avec validation. | |
| Returns: | |
| Dictionnaire des métriques | |
| """ | |
| progress_bar = st.progress(0, text=" Entraînement en cours...") | |
| # ===== 1. LightGBM ===== | |
| progress_bar.progress(0.1, text=" LightGBM...") | |
| lgb_model = lgb.LGBMRegressor( | |
| n_estimators=500, | |
| learning_rate=0.05, | |
| num_leaves=31, | |
| max_depth=6, | |
| min_child_samples=20, | |
| subsample=0.8, | |
| colsample_bytree=0.8, | |
| random_state=42, | |
| verbose=-1, | |
| n_jobs=-1 | |
| ) | |
| lgb_model.fit( | |
| self.X_train, self.y_train, | |
| eval_set=[(self.X_val, self.y_val)], | |
| callbacks=[lgb.early_stopping(stopping_rounds=50, verbose=False)] | |
| ) | |
| self.models['LightGBM'] = lgb_model | |
| self._evaluate_model('LightGBM', lgb_model) | |
| # ===== 2. XGBoost ===== | |
| progress_bar.progress(0.4, text=" XGBoost...") | |
| xgb_model = xgb.XGBRegressor( | |
| n_estimators=500, | |
| learning_rate=0.05, | |
| max_depth=6, | |
| min_child_weight=3, | |
| subsample=0.8, | |
| colsample_bytree=0.8, | |
| random_state=42, | |
| n_jobs=-1, | |
| early_stopping_rounds=50, | |
| eval_metric='rmse' | |
| ) | |
| xgb_model.fit( | |
| self.X_train, self.y_train, | |
| eval_set=[(self.X_val, self.y_val)], | |
| verbose=False | |
| ) | |
| self.models['XGBoost'] = xgb_model | |
| self._evaluate_model('XGBoost', xgb_model) | |
| # ===== 3. Random Forest ===== | |
| progress_bar.progress(0.7, text=" Random Forest...") | |
| rf_model = RandomForestRegressor( | |
| n_estimators=300, | |
| max_depth=15, | |
| min_samples_split=10, | |
| min_samples_leaf=5, | |
| max_features='sqrt', | |
| random_state=42, | |
| n_jobs=-1, | |
| verbose=0 | |
| ) | |
| rf_model.fit(self.X_train, self.y_train) | |
| self.models['Random Forest'] = rf_model | |
| self._evaluate_model('Random Forest', rf_model) | |
| progress_bar.progress(1.0, text="✅ Entraînement terminé!") | |
| progress_bar.empty() | |
| # Sélection du meilleur modèle | |
| self._select_best_model() | |
| return self.metrics | |
| def _evaluate_model(self, model_name, model): | |
| """ | |
| Évalue un modèle sur les 3 sets (train, val, test). | |
| Args: | |
| model_name: Nom du modèle | |
| model: Instance du modèle entraîné | |
| """ | |
| # Prédictions sur les 3 sets | |
| pred_train = model.predict(self.X_train) | |
| pred_val = model.predict(self.X_val) | |
| pred_test = model.predict(self.X_test) | |
| # Stockage des prédictions | |
| self.predictions['train'][model_name] = pred_train | |
| self.predictions['val'][model_name] = pred_val | |
| self.predictions['test'][model_name] = pred_test | |
| # Métriques sur le test set (évaluation finale) | |
| rmse = np.sqrt(mean_squared_error(self.y_test, pred_test)) | |
| mae = mean_absolute_error(self.y_test, pred_test) | |
| r2 = r2_score(self.y_test, pred_test) | |
| # MAPE (Mean Absolute Percentage Error) | |
| mask = self.y_test != 0 | |
| if mask.sum() > 0: | |
| mape = np.mean(np.abs((self.y_test[mask] - pred_test[mask]) / self.y_test[mask])) * 100 | |
| else: | |
| mape = np.nan | |
| # Métriques sur validation (pour early stopping) | |
| rmse_val = np.sqrt(mean_squared_error(self.y_val, pred_val)) | |
| mae_val = mean_absolute_error(self.y_val, pred_val) | |
| self.metrics[model_name] = { | |
| 'RMSE': rmse, | |
| 'MAE': mae, | |
| 'R²': r2, | |
| 'MAPE': mape, | |
| 'RMSE_val': rmse_val, | |
| 'MAE_val': mae_val | |
| } | |
| def _select_best_model(self): | |
| """ | |
| Sélection automatique du meilleur modèle basée sur RMSE + MAE. | |
| """ | |
| scores = {} | |
| for model_name, metrics in self.metrics.items(): | |
| # Score composite (moyenne normalisée RMSE + MAE) | |
| score = (metrics['RMSE'] + metrics['MAE']) / 2 | |
| scores[model_name] = score | |
| # Meilleur = score le plus bas | |
| self.best_model_name = min(scores, key=scores.get) | |
| def generate_future_forecast_recursive(self, months=3): | |
| """ | |
| Prédiction RÉCURSIVE vers le futur avec saisonnalité. | |
| Le modèle utilise ses propres prédictions comme lags pour | |
| les prédictions suivantes, conservant ainsi les tendances. | |
| Args: | |
| months: Nombre de mois à prédire | |
| Returns: | |
| Tuple (dates_futures, prédictions, intervalles_confiance) | |
| """ | |
| days = months * 30 | |
| model = self.models[self.best_model_name] | |
| # Dernière ligne connue (base pour récursion) | |
| last_row = self.df.iloc[-1:][self.feature_names].copy() | |
| last_date = self.df['date'].max() | |
| future_dates = [] | |
| future_predictions = [] | |
| # Identification des colonnes de lags | |
| lag_cols = [c for c in self.feature_names if '_lag_' in c] | |
| rolling_cols = [c for c in self.feature_names if any(x in c for x in ['_mean_', '_std_', '_min_', '_max_'])] | |
| # Prédiction jour par jour | |
| for i in range(1, days + 1): | |
| current_date = last_date + timedelta(days=i) | |
| future_dates.append(current_date) | |
| # Mise à jour des features temporelles | |
| row = last_row.copy() | |
| # Features temporelles basiques | |
| if 'jour_semaine' in row.columns: | |
| row['jour_semaine'] = current_date.dayofweek | |
| if 'mois' in row.columns: | |
| row['mois'] = current_date.month | |
| if 'trimestre' in row.columns: | |
| row['trimestre'] = current_date.quarter | |
| if 'jour_annee' in row.columns: | |
| row['jour_annee'] = current_date.dayofyear | |
| # Features cycliques | |
| if 'mois_sin' in row.columns: | |
| row['mois_sin'] = np.sin(2 * np.pi * current_date.month / 12) | |
| if 'mois_cos' in row.columns: | |
| row['mois_cos'] = np.cos(2 * np.pi * current_date.month / 12) | |
| if 'jour_semaine_sin' in row.columns: | |
| row['jour_semaine_sin'] = np.sin(2 * np.pi * current_date.dayofweek / 7) | |
| if 'jour_semaine_cos' in row.columns: | |
| row['jour_semaine_cos'] = np.cos(2 * np.pi * current_date.dayofweek / 7) | |
| # Features de périodes hospitalières | |
| mois = current_date.month | |
| if 'periode_grippe' in row.columns: | |
| row['periode_grippe'] = int((mois >= 11) or (mois <= 3)) | |
| if 'periode_canicule' in row.columns: | |
| row['periode_canicule'] = int((mois >= 6) and (mois <= 8)) | |
| if 'periode_gastro' in row.columns: | |
| row['periode_gastro'] = int((mois >= 11) or (mois <= 2)) | |
| if 'periode_bronchiolite' in row.columns: | |
| row['periode_bronchiolite'] = int((mois >= 10) and (mois <= 2)) | |
| # Weekend | |
| if 'est_weekend' in row.columns: | |
| row['est_weekend'] = int(current_date.dayofweek >= 5) | |
| # Prédiction | |
| pred = model.predict(row)[0] | |
| future_predictions.append(pred) | |
| # RÉCURSION : Mise à jour des lags avec la nouvelle prédiction | |
| # Pour le prochain jour, cette prédiction devient le lag_1 | |
| if len(future_predictions) >= 1 and f'{self.target_col}_lag_1' in lag_cols: | |
| row[f'{self.target_col}_lag_1'] = pred | |
| if len(future_predictions) >= 7 and f'{self.target_col}_lag_7' in lag_cols: | |
| row[f'{self.target_col}_lag_7'] = future_predictions[-7] | |
| if len(future_predictions) >= 14 and f'{self.target_col}_lag_14' in lag_cols: | |
| row[f'{self.target_col}_lag_14'] = future_predictions[-14] | |
| # Mise à jour des rolling stats (approximation simple) | |
| if len(future_predictions) >= 7: | |
| recent_7 = future_predictions[-7:] | |
| if f'{self.target_col}_mean_7j' in rolling_cols: | |
| row[f'{self.target_col}_mean_7j'] = np.mean(recent_7) | |
| if f'{self.target_col}_std_7j' in rolling_cols: | |
| row[f'{self.target_col}_std_7j'] = np.std(recent_7) | |
| if len(future_predictions) >= 14: | |
| recent_14 = future_predictions[-14:] | |
| if f'{self.target_col}_mean_14j' in rolling_cols: | |
| row[f'{self.target_col}_mean_14j'] = np.mean(recent_14) | |
| if f'{self.target_col}_std_14j' in rolling_cols: | |
| row[f'{self.target_col}_std_14j'] = np.std(recent_14) | |
| # Préparation pour la prochaine itération | |
| last_row = row | |
| # Calcul des intervalles de confiance (basé sur l'erreur du modèle) | |
| mae = self.metrics[self.best_model_name]['MAE'] | |
| lower_bound = np.array(future_predictions) - 1.96 * mae | |
| upper_bound = np.array(future_predictions) + 1.96 * mae | |
| confidence_intervals = { | |
| 'lower': lower_bound, | |
| 'upper': upper_bound | |
| } | |
| return future_dates, np.array(future_predictions), confidence_intervals | |
| def compute_shap_values(self, n_samples=200): | |
| """ | |
| Calcule les valeurs SHAP pour interprétabilité. | |
| Args: | |
| n_samples: Nombre d'échantillons pour le calcul | |
| Returns: | |
| Tuple (explainer, shap_values, X_sample) ou (None, None, None) | |
| """ | |
| if not SHAP_AVAILABLE: | |
| return None, None, None | |
| model = self.models[self.best_model_name] | |
| # Échantillonnage pour la vitesse | |
| X_sample = self.X_test.sample(n=min(n_samples, len(self.X_test)), random_state=42) | |
| try: | |
| # TreeExplainer optimisé pour les modèles d'arbres | |
| explainer = shap.TreeExplainer(model) | |
| shap_values = explainer.shap_values(X_sample) | |
| return explainer, shap_values, X_sample | |
| except Exception as e: | |
| st.warning(f"⚠️ Erreur SHAP : {str(e)}") | |
| return None, None, None | |
| def detect_future_anomalies(self, future_predictions, threshold_percentile=90): | |
| """ | |
| Détecte les anomalies prévues dans les prédictions futures. | |
| Args: | |
| future_predictions: Array des prédictions futures | |
| threshold_percentile: Percentile pour définir une anomalie | |
| Returns: | |
| Liste d'alertes | |
| """ | |
| # Calcul du seuil basé sur l'historique | |
| historical_values = self.df[self.target_col].values | |
| threshold = np.percentile(historical_values, threshold_percentile) | |
| # Détection des pics | |
| alerts = [] | |
| for i, pred in enumerate(future_predictions): | |
| if pred > threshold: | |
| alerts.append({ | |
| 'day': i + 1, | |
| 'value': pred, | |
| 'threshold': threshold, | |
| 'severity': 'HIGH' if pred > threshold * 1.2 else 'MEDIUM' | |
| }) | |
| return alerts | |
| # ===================================================== | |
| # ============= INTERFACE STREAMLIT =================== | |
| # ===================================================== | |
| def show_forecasting_module(client, sheet_name): | |
| """ | |
| Interface Streamlit pour le module de forecasting. | |
| """ | |
| st.markdown("## 🔮 ORACLE : FORECASTING & AUDIT") | |
| st.caption("Intelligence Artificielle de prédiction des flux hospitaliers avec interprétabilité complète.") | |
| # ===== VÉRIFICATION DONNÉES ===== | |
| if 'ml_features' not in st.session_state: | |
| st.error("❌ **Données ML absentes.** Veuillez d'abord exécuter le module **Feature Engineering**.") | |
| if st.button(" Aller au Feature Engineering"): | |
| st.switch_page("pages/03_Features.py") | |
| return | |
| df = st.session_state['ml_features'] | |
| st.success(f"✅ Dataset ML chargé : **{len(df):,}** échantillons") | |
| # ===== CONFIGURATION ===== | |
| st.divider() | |
| with st.expander(" Configuration de l'Entraînement", expanded=False): | |
| col1, col2, col3 = st.columns(3) | |
| with col1: | |
| target = st.selectbox( | |
| "Variable Cible", | |
| ['nb_admissions', 'taux_occupation', 'tension_personnel'], | |
| index=0, | |
| help="Variable à prédire" | |
| ) | |
| with col2: | |
| val_days = st.number_input( | |
| "Jours Validation", | |
| min_value=15, | |
| max_value=60, | |
| value=30, | |
| help="Nombre de jours pour le set de validation" | |
| ) | |
| with col3: | |
| test_days = st.number_input( | |
| "Jours Test", | |
| min_value=15, | |
| max_value=60, | |
| value=30, | |
| help="Nombre de jours pour le test final" | |
| ) | |
| # ===== ENTRAÎNEMENT ===== | |
| if 'forecaster' not in st.session_state or st.session_state.get('forecast_target') != target: | |
| st.info("🚀 **Lancement de l'entraînement des 3 modèles...**") | |
| forecaster = HospitalForecaster(df) | |
| try: | |
| # Préparation des données | |
| with st.spinner(" Préparation des données (Train/Val/Test)..."): | |
| split_info = forecaster.prepare_data( | |
| target_col=target, | |
| val_days=val_days, | |
| test_days=test_days | |
| ) | |
| # Affichage des plages de dates | |
| st.markdown("### Plages de Dates des Sets") | |
| col1, col2, col3 = st.columns(3) | |
| with col1: | |
| st.metric( | |
| "🟢 Train", | |
| f"{split_info['train']['n_samples']} jours", | |
| f"{split_info['train']['start'].strftime('%d/%m/%Y')} → {split_info['train']['end'].strftime('%d/%m/%Y')}" | |
| ) | |
| with col2: | |
| st.metric( | |
| "🟡 Validation", | |
| f"{split_info['val']['n_samples']} jours", | |
| f"{split_info['val']['start'].strftime('%d/%m/%Y')} → {split_info['val']['end'].strftime('%d/%m/%Y')}" | |
| ) | |
| with col3: | |
| st.metric( | |
| "🔴 Test", | |
| f"{split_info['test']['n_samples']} jours", | |
| f"{split_info['test']['start'].strftime('%d/%m/%Y')} → {split_info['test']['end'].strftime('%d/%m/%Y')}" | |
| ) | |
| st.divider() | |
| # Entraînement des modèles | |
| metrics = forecaster.train_all_models() | |
| # Stockage dans session_state | |
| st.session_state['forecaster'] = forecaster | |
| st.session_state['metrics'] = metrics | |
| st.session_state['split_info'] = split_info | |
| st.session_state['forecast_target'] = target | |
| st.success("✅ **Entraînement terminé avec succès !**") | |
| except Exception as e: | |
| st.error(f"❌ **Erreur lors de l'entraînement :** {str(e)}") | |
| import traceback | |
| with st.expander(" Détails de l'erreur"): | |
| st.code(traceback.format_exc()) | |
| return | |
| # ===== RÉCUPÉRATION DES RÉSULTATS ===== | |
| forecaster = st.session_state['forecaster'] | |
| metrics = st.session_state['metrics'] | |
| split_info = st.session_state['split_info'] | |
| best = forecaster.best_model_name | |
| # ===== ONGLETS PRINCIPAUX ===== | |
| tab_future, tab_audit, tab_export = st.tabs([ | |
| " Prédictions Futures", | |
| " Audit & Comparaison", | |
| " Export & Données" | |
| ]) | |
| # ================================================================ | |
| # ONGLET 1 : PRÉDICTIONS FUTURES | |
| # ================================================================ | |
| with tab_future: | |
| st.markdown("### Projections Récursives avec Saisonnalité") | |
| col_h1, col_h2 = st.columns([3, 1]) | |
| with col_h1: | |
| horizon_label = st.radio( | |
| "Horizon de prédiction", | |
| ["1 Mois", "3 Mois", "6 Mois", "12 Mois"], | |
| horizontal=True, | |
| index=1 | |
| ) | |
| with col_h2: | |
| show_confidence = st.checkbox("Intervalle de confiance", value=True) | |
| months_map = {"1 Mois": 1, "3 Mois": 3, "6 Mois": 6, "12 Mois": 12} | |
| months = months_map[horizon_label] | |
| with st.spinner(" Calcul de la trajectoire récursive avec saisonnalité..."): | |
| f_dates, f_values, conf_intervals = forecaster.generate_future_forecast_recursive(months) | |
| # Graphique des prédictions futures | |
| fig = go.Figure() | |
| # Historique récent (90 derniers jours) | |
| hist = df.iloc[-90:] | |
| fig.add_trace(go.Scatter( | |
| x=hist['date'], | |
| y=hist[target], | |
| name=" Historique Réel", | |
| line=dict(color='gray', width=2), | |
| opacity=0.6 | |
| )) | |
| # Prédictions futures | |
| fig.add_trace(go.Scatter( | |
| x=f_dates, | |
| y=f_values, | |
| name=f" Projection {best}", | |
| line=dict(color='#00E676', width=3), | |
| mode='lines+markers', | |
| marker=dict(size=5) | |
| )) | |
| # Intervalle de confiance | |
| if show_confidence: | |
| fig.add_trace(go.Scatter( | |
| x=f_dates + f_dates[::-1], | |
| y=list(conf_intervals['upper']) + list(conf_intervals['lower'][::-1]), | |
| fill='toself', | |
| fillcolor='rgba(0, 230, 118, 0.2)', | |
| line=dict(color='rgba(255,255,255,0)'), | |
| name='Intervalle de confiance (95%)', | |
| showlegend=True | |
| )) | |
| # Ligne verticale "Aujourd'hui" | |
| last_hist_date = hist['date'].max() | |
| # --- FIX COMPATIBILITÉ PANDAS 2.x --- | |
| # On convertit le Timestamp en millisecondes (float) pour éviter | |
| # l'erreur "Addition/subtraction of integers with Timestamp" | |
| # car Plotly utilise sum() en interne qui commence par 0. | |
| vline_x = last_hist_date.timestamp() * 1000 | |
| # ------------------------------------ | |
| fig.add_vline( | |
| x=vline_x, # On utilise la version convertie ici | |
| line_width=2, | |
| line_dash="dash", | |
| line_color="white", | |
| annotation_text="Aujourd'hui", | |
| annotation_position="top" | |
| ) | |
| fig.update_layout( | |
| title=f"Projection {horizon_label} - {target.replace('_', ' ').title()}", | |
| template="plotly_dark", | |
| height=500, | |
| hovermode="x unified", | |
| xaxis_title="Date", | |
| yaxis_title=target.replace('_', ' ').title() | |
| ) | |
| st.plotly_chart(fig, use_container_width=True) | |
| # Statistiques de la projection | |
| col1, col2, col3, col4 = st.columns(4) | |
| col1.metric("Moyenne Prévue", f"{np.mean(f_values):.1f}") | |
| col2.metric("Maximum Prévu", f"{np.max(f_values):.1f}") | |
| col3.metric("Minimum Prévu", f"{np.min(f_values):.1f}") | |
| col4.metric("Tendance", | |
| " Hausse" if f_values[-1] > f_values[0] else " Baisse", | |
| f"{((f_values[-1] / f_values[0]) - 1) * 100:+.1f}%") | |
| # Détection d'anomalies futures | |
| st.markdown("#### 🚨 Alertes Préventives") | |
| alerts = forecaster.detect_future_anomalies(f_values) | |
| if alerts: | |
| st.warning(f"⚠️ **{len(alerts)} pic(s) détecté(s)** dans les {months} prochains mois") | |
| for alert in alerts[:5]: # Top 5 | |
| severity_emoji = "🔴" if alert['severity'] == 'HIGH' else "🟠" | |
| st.write(f"{severity_emoji} **Jour +{alert['day']}** : Valeur prévue = **{alert['value']:.0f}** " | |
| f"(seuil normal : {alert['threshold']:.0f})") | |
| else: | |
| st.success("✅ Aucun pic anormal détecté dans la période") | |
| st.caption(f" Prédiction générée par **{best}** | Fiabilité : **{metrics[best]['R²']*100:.0f}%**") | |
| # ================================================================ | |
| # ONGLET 2 : AUDIT & COMPARAISON | |
| # ================================================================ | |
| with tab_audit: | |
| st.markdown("### Le Champion de la Prédiction") | |
| # Annonce du vainqueur | |
| col_winner, col_reset = st.columns([4, 1]) | |
| with col_winner: | |
| st.success(f""" | |
| ### Gagnant : **{best}** | |
| Sur les **{split_info['test']['n_samples']} derniers jours** de test, ce modèle a montré | |
| la meilleure précision avec une erreur moyenne de seulement **{metrics[best]['MAE']:.2f}** unités par jour. | |
| **Fiabilité globale :** {metrics[best]['R²']*100:.1f}% | |
| (Le modèle explique {metrics[best]['R²']*100:.1f}% des variations observées) | |
| """) | |
| with col_reset: | |
| if st.button(" Réinitialiser", help="Relancer l'entraînement"): | |
| for key in ['forecaster', 'metrics', 'split_info', 'forecast_target']: | |
| if key in st.session_state: | |
| del st.session_state[key] | |
| st.rerun() | |
| st.divider() | |
| # ===== TABLEAU COMPARATIF ===== | |
| st.markdown("### Tableau Comparatif Détaillé") | |
| comparison_data = [] | |
| for model_name in ['XGBoost', 'LightGBM', 'Random Forest']: | |
| m = metrics[model_name] | |
| comparison_data.append({ | |
| 'Modèle': f"{'🏆 ' if model_name == best else ''}{model_name}", | |
| 'R² (Fiabilité %)': f"{m['R²']*100:.2f}%", | |
| 'RMSE': f"{m['RMSE']:.2f}", | |
| 'MAE (Erreur Moy.)': f"{m['MAE']:.2f}", | |
| 'MAPE (Erreur %)': f"{m['MAPE']:.2f}%" if not np.isnan(m['MAPE']) else "N/A" | |
| }) | |
| comparison_df = pd.DataFrame(comparison_data) | |
| st.dataframe( | |
| comparison_df, | |
| use_container_width=True, | |
| hide_index=True | |
| ) | |
| # Explications des métriques | |
| with st.expander(" Comprendre les Métriques"): | |
| st.markdown(""" | |
| **R² (Coefficient de Détermination) :** | |
| - Mesure de 0% à 100% : plus c'est proche de 100%, mieux c'est | |
| - Indique quelle part de la variation est expliquée par le modèle | |
| - Exemple : 85% = le modèle comprend 85% des raisons des fluctuations | |
| **RMSE (Root Mean Squared Error) :** | |
| - Erreur moyenne au carré, puis racine carrée | |
| - Pénalise fortement les grandes erreurs | |
| - Plus la valeur est basse, mieux c'est | |
| - Utile en santé car les grosses erreurs sont graves | |
| **MAE (Mean Absolute Error) :** | |
| - Erreur moyenne en valeur absolue | |
| - S'exprime dans l'unité de la cible (ex: nombre d'admissions) | |
| - Plus facile à interpréter : "en moyenne, je me trompe de X unités" | |
| - Plus robuste aux valeurs extrêmes que RMSE | |
| **MAPE (Mean Absolute Percentage Error) :** | |
| - Erreur moyenne en pourcentage | |
| - Indépendant de l'échelle des données | |
| - Exemple : 5% = en moyenne, l'erreur est de 5% de la valeur réelle | |
| """) | |
| st.divider() | |
| # ===== GRAPHIQUE COMPARATIF SUR TEST SET ===== | |
| st.markdown("### Comparaison Visuelle sur le Test Set") | |
| fig_comp = go.Figure() | |
| # Réalité (en blanc épais) | |
| fig_comp.add_trace(go.Scatter( | |
| x=forecaster.dates_test, | |
| y=forecaster.y_test, | |
| name=" RÉALITÉ", | |
| line=dict(color='white', width=4, dash='dot'), | |
| mode='lines+markers', | |
| marker=dict(size=6) | |
| )) | |
| # Les 3 modèles | |
| colors = { | |
| 'XGBoost': '#1f77b4', | |
| 'LightGBM': '#ff7f0e', | |
| 'Random Forest': '#2ca02c' | |
| } | |
| for model_name in ['XGBoost', 'LightGBM', 'Random Forest']: | |
| pred = forecaster.predictions['test'][model_name] | |
| is_best = (model_name == best) | |
| fig_comp.add_trace(go.Scatter( | |
| x=forecaster.dates_test, | |
| y=pred, | |
| name=f"{'🏆 ' if is_best else ''}{model_name}", | |
| line=dict( | |
| color=colors[model_name], | |
| width=3 if is_best else 1.5, | |
| dash='solid' if is_best else 'dash' | |
| ), | |
| opacity=1.0 if is_best else 0.5 | |
| )) | |
| fig_comp.update_layout( | |
| title="Prédictions vs Réalité sur la Période de Test", | |
| template="plotly_dark", | |
| height=500, | |
| hovermode="x unified", | |
| xaxis_title="Date", | |
| yaxis_title=target.replace('_', ' ').title() | |
| ) | |
| st.plotly_chart(fig_comp, use_container_width=True) | |
| st.caption(" **Plus une ligne colorée est proche de la ligne blanche, meilleur est le modèle**") | |
| st.divider() | |
| # ===== SHAP : INTERPRÉTABILITÉ ===== | |
| st.markdown("### Comprendre les Décisions de l'IA (SHAP)") | |
| st.info(""" | |
| **SHAP** (SHapley Additive exPlanations) révèle **quelles variables influencent le plus** | |
| les prédictions du modèle. | |
| Plus la barre est longue, plus cette feature est importante pour les décisions de l'IA. | |
| """) | |
| if SHAP_AVAILABLE: | |
| with st.spinner(" Calcul des valeurs SHAP (analyse d'importance)..."): | |
| explainer, shap_values, X_sample = forecaster.compute_shap_values(n_samples=200) | |
| if shap_values is not None: | |
| # Summary plot (importance globale) | |
| fig_shap, ax = plt.subplots(figsize=(10, 6)) | |
| fig_shap.patch.set_facecolor('#0e1117') | |
| ax.set_facecolor('#0e1117') | |
| shap.summary_plot( | |
| shap_values, | |
| X_sample, | |
| max_display=15, | |
| plot_type="bar", | |
| show=False, | |
| color='#00E676' | |
| ) | |
| # Styling pour fond sombre | |
| ax.tick_params(colors='white', labelsize=11) | |
| ax.xaxis.label.set_color('white') | |
| ax.yaxis.label.set_color('white') | |
| ax.set_xlabel('Impact sur la prédiction', color='white', fontsize=12) | |
| ax.set_title(f'Top 15 Features les Plus Importantes - {best}', | |
| color='white', fontsize=14, fontweight='bold') | |
| st.pyplot(fig_shap) | |
| plt.close() | |
| # Explications textuelles | |
| st.markdown("#### Interprétation") | |
| # Top 5 features | |
| feature_importance = pd.DataFrame({ | |
| 'Feature': X_sample.columns, | |
| 'Importance': np.abs(shap_values).mean(axis=0) | |
| }).sort_values('Importance', ascending=False).head(5) | |
| st.write("**Les 5 facteurs clés identifiés par l'IA :**") | |
| for idx, row in feature_importance.iterrows(): | |
| feature = row['Feature'] | |
| # Traduction en français | |
| if 'lag' in feature: | |
| explanation = f" Historique récent ({feature})" | |
| elif 'mean' in feature or 'rolling' in feature: | |
| explanation = f" Tendance sur plusieurs jours ({feature})" | |
| elif 'taux' in feature: | |
| explanation = f" Taux ou ratio ({feature})" | |
| elif 'personnel' in feature: | |
| explanation = f" Ressources humaines ({feature})" | |
| elif 'scenario' in feature or 'intensity' in feature: | |
| explanation = f" Scénario/événement ({feature})" | |
| elif 'mois' in feature or 'jour' in feature: | |
| explanation = f" Facteur temporel ({feature})" | |
| else: | |
| explanation = f" {feature}" | |
| st.write(f"- {explanation}") | |
| else: | |
| st.warning("⚠️ Impossible de calculer les valeurs SHAP pour ce modèle") | |
| else: | |
| st.warning("⚠️ **SHAP n'est pas installé.** Installez avec : `pip install shap`") | |
| # ================================================================ | |
| # ONGLET 3 : EXPORT & DONNÉES | |
| # ================================================================ | |
| with tab_export: | |
| st.markdown("### 📥 Téléchargement des Résultats") | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| # Export des métriques | |
| st.markdown("#### Métriques des Modèles") | |
| metrics_df = pd.DataFrame(metrics).T | |
| metrics_csv = metrics_df.to_csv(index=True).encode('utf-8') | |
| st.download_button( | |
| label="📥 Télécharger Métriques (CSV)", | |
| data=metrics_csv, | |
| file_name=f'model_metrics_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv', | |
| mime='text/csv' | |
| ) | |
| st.dataframe(metrics_df, use_container_width=True) | |
| with col2: | |
| # Export des prédictions sur test | |
| st.markdown("#### Prédictions Test Set") | |
| predictions_df = pd.DataFrame({ | |
| 'date': forecaster.dates_test, | |
| 'reel': forecaster.y_test, | |
| 'XGBoost': forecaster.predictions['test']['XGBoost'], | |
| 'LightGBM': forecaster.predictions['test']['LightGBM'], | |
| 'Random_Forest': forecaster.predictions['test']['Random Forest'] | |
| }) | |
| predictions_csv = predictions_df.to_csv(index=False).encode('utf-8') | |
| st.download_button( | |
| label="📥 Télécharger Prédictions (CSV)", | |
| data=predictions_csv, | |
| file_name=f'predictions_test_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv', | |
| mime='text/csv' | |
| ) | |
| st.dataframe(predictions_df.head(10), use_container_width=True) | |
| # Export des prédictions futures | |
| st.markdown("#### Prédictions Futures") | |
| if 'f_dates' in locals() and 'f_values' in locals(): | |
| future_df = pd.DataFrame({ | |
| 'date': f_dates, | |
| 'prediction': f_values, | |
| 'lower_bound': conf_intervals['lower'], | |
| 'upper_bound': conf_intervals['upper'] | |
| }) | |
| future_csv = future_df.to_csv(index=False).encode('utf-8') | |
| st.download_button( | |
| label="📥 Télécharger Prédictions Futures (CSV)", | |
| data=future_csv, | |
| file_name=f'predictions_futures_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv', | |
| mime='text/csv' | |
| ) | |
| st.dataframe(future_df.head(30), use_container_width=True) | |
| # Point d'entrée si appelé directement | |
| if __name__ == "__main__": | |
| # Pour test standalone | |
| show_forecasting_module(None, None) |