Update src/module/Forecasting.py

src/module/Forecasting.py

@@ -1,839 +1,276 @@
 """
-MODULE: FORECASTING & MODEL COMPARISON
-======================================
-Responsabilité : Entraînement, évaluation et comparaison de modèles ML
-pour la prédiction des besoins hospitaliers.
-Style : Gotham UI
-
-Modèles Entraînés :
-- XGBoost : Champion des compétitions, excellent sur données tabulaires
-- LightGBM : Rapide, performant, moins de surapprentissage
-- Random Forest : Baseline robuste et interprétable
-
-Métriques de Performance :
-- RMSE : Pénalise fortement les grandes erreurs (critique en santé)
-- MAE : Robuste aux outliers
-- MAPE : Erreur en pourcentage (compréhensible business)
-- R² : Variance expliquée
-- SHAP : Interprétabilité des prédictions
+MODULE: FORECASTING ENGINE (GOTHAM UI - EXPERT EDITION)
+=======================================================
+Responsabilité : Entraînement ML, Audit Comparatif (3 Modèles) et Prédiction.
+Fonctionnalités : Comparaison Visuelle, SHAP, et Projection Multi-Horizon.
 """
 
 import pandas as pd
 import numpy as np
 import streamlit as st
-import plotly.express as px
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-from datetime import datetime
+from datetime import timedelta
 import warnings
-warnings.filterwarnings('ignore')
+import copy
 
 # ML Models
 from sklearn.ensemble import RandomForestRegressor
 from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
-from sklearn.preprocessing import LabelEncoder
 import xgboost as xgb
 import lightgbm as lgb
 
-# SHAP pour l'interprétabilité
+# Sécurité SHAP (Graphiques d'interprétabilité)
 try:
     import shap
+    import matplotlib.pyplot as plt # Requis pour certains plots SHAP
     SHAP_AVAILABLE = True
 except ImportError:
     SHAP_AVAILABLE = False
 
+warnings.filterwarnings('ignore')
 
 class HospitalForecaster:
-    """Moteur de prédiction hospitalière avec comparaison de modèles"""
-    
     def __init__(self, ml_dataset):
         self.df = ml_dataset.copy()
+        self.df['date'] = pd.to_datetime(self.df['date'])
         self.models = {}
-        self.predictions = {}
         self.metrics = {}
+        self.test_predictions = {} # Pour stocker les courbes des 3 modèles
         self.best_model_name = None
+        self.last_train_date = self.df['date'].max()
         
-        # Encodeurs pour variables catégorielles
-        self.label_encoders = {}
-        
-    def prepare_data(self, target_col='nb_admissions', test_size=0.15, val_size=0.15):
-        """
-        Préparation des données avec split temporel (CRITIQUE pour séries temporelles).
-        
-        Args:
-            target_col: Variable cible à prédire
-            test_size: Proportion pour test set
-            val_size: Proportion pour validation set
-            
-        Returns:
-            Tuple (X_train, X_val, X_test, y_train, y_val, y_test, feature_names)
-        """
-        df = self.df.copy()
-        
-        # Tri chronologique (essentiel pour séries temporelles)
-        df = df.sort_values('date').reset_index(drop=True)
-        
-        # Colonnes à exclure
-        exclude_cols = [
-            target_col, 'date', 'stay_id', 'patient_id', 
-            'scenario', 'service_nom', 'periode_conges_label',
-            'dq_is_anomaly', 'dq_anomaly_type', 'dq_anomaly_detail',
-            'jour_semaine_nom', 'mois_nom', 'saison', 
-            'pathologie_nom', 'service_code', 'materiel_code'
-        ]
+    def prepare_data(self, target_col='nb_admissions', test_days=60): # 60 jours pour bien voir la comparaison
+        """Split Temporel pour validation"""
+        df = self.df.sort_values('date').reset_index(drop=True)
         
-        # Sélection des features
-        feature_cols = [col for col in df.columns if col not in exclude_cols]
+        exclude_cols = [target_col, 'date', 'stay_id', 'patient_id']
+        feature_cols = [c for c in df.columns if c not in exclude_cols and np.issubdtype(df[c].dtype, np.number)]
         
-        # Gestion des variables catégorielles
-        categorical_cols = df[feature_cols].select_dtypes(include=['object', 'category']).columns.tolist()
+        split_idx = len(df) - test_days
         
-        for col in categorical_cols:
-            if col in df.columns:
-                le = LabelEncoder()
-                df[col] = le.fit_transform(df[col].astype(str))
-                self.label_encoders[col] = le
-        
-        # Suppression des NaN (après feature engineering, certaines features peuvent être NaN)
-        df = df.dropna(subset=feature_cols + [target_col])
-        
-        # Extraction X et y
-        X = df[feature_cols].select_dtypes(include=[np.number])
+        X = df[feature_cols]
         y = df[target_col]
-        dates = df['date']
-        
-        # Split temporel (respecte l'ordre chronologique)
-        n = len(X)
-        train_end = int(n * (1 - test_size - val_size))
-        val_end = int(n * (1 - test_size))
-        
-        X_train = X.iloc[:train_end]
-        X_val = X.iloc[train_end:val_end]
-        X_test = X.iloc[val_end:]
-        
-        y_train = y.iloc[:train_end]
-        y_val = y.iloc[train_end:val_end]
-        y_test = y.iloc[val_end:]
-        
-        dates_train = dates.iloc[:train_end]
-        dates_val = dates.iloc[train_end:val_end]
-        dates_test = dates.iloc[val_end:]
-        
-        # Stockage pour visualisations
-        self.X_train = X_train
-        self.X_val = X_val
-        self.X_test = X_test
-        self.y_train = y_train
-        self.y_val = y_val
-        self.y_test = y_test
-        self.dates_train = dates_train
-        self.dates_val = dates_val
-        self.dates_test = dates_test
-        self.feature_names = X_train.columns.tolist()
-        
-        return X_train, X_val, X_test, y_train, y_val, y_test, self.feature_names
-    
-    def train_xgboost(self, X_train, X_val, y_train, y_val):
-        """
-        Entraînement XGBoost avec early stopping.
-        XGBoost est le champion des compétitions Kaggle pour données tabulaires.
-        """
-        model = xgb.XGBRegressor(
-            n_estimators=500,
-            learning_rate=0.05,
-            max_depth=6,
-            min_child_weight=3,
-            subsample=0.8,
-            colsample_bytree=0.8,
-            gamma=0.1,
-            random_state=42,
-            n_jobs=-1,
-            early_stopping_rounds=50,
-            eval_metric='rmse'
-        )
-        
-        model.fit(
-            X_train, y_train,
-            eval_set=[(X_val, y_val)],
-            verbose=False
-        )
         
-        self.models['XGBoost'] = model
-        return model
-    
-    def train_lightgbm(self, X_train, X_val, y_train, y_val):
-        """
-        Entraînement LightGBM.
-        Plus rapide que XGBoost, souvent meilleur sur grandes données.
-        """
-        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,
-            n_jobs=-1,
-            force_col_wise=True,
-            verbose=-1
-        )
-        
-        model.fit(
-            X_train, y_train,
-            eval_set=[(X_val, y_val)],
-            eval_metric='rmse',
-            callbacks=[lgb.early_stopping(stopping_rounds=50, verbose=False)]
-        )
-        
-        self.models['LightGBM'] = model
-        return model
-    
-    def train_random_forest(self, X_train, y_train):
-        """
-        Entraînement Random Forest.
-        Baseline robuste, très interprétable, résistant au surapprentissage.
-        """
-        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
-        )
-        
-        model.fit(X_train, y_train)
-        
-        self.models['Random Forest'] = model
-        return model
-    
-    def evaluate_model(self, model_name, model, X_test, y_test):
-        """
-        Évaluation complète d'un modèle avec toutes les métriques.
-        """
-        y_pred = model.predict(X_test)
-        
-        # Métriques de régression
-        rmse = np.sqrt(mean_squared_error(y_test, y_pred))
-        mae = mean_absolute_error(y_test, y_pred)
-        r2 = r2_score(y_test, y_pred)
-        
-        # MAPE (Mean Absolute Percentage Error)
-        # Gestion du cas où y_test contient des 0
-        mask = y_test != 0
-        if mask.sum() > 0:
-            mape = np.mean(np.abs((y_test[mask] - y_pred[mask]) / y_test[mask])) * 100
-        else:
-            mape = np.nan
-        
-        # Stockage des prédictions
-        self.predictions[model_name] = y_pred
+        self.X_train = X.iloc[:split_idx]
+        self.X_test = X.iloc[split_idx:]
+        self.y_train = y.iloc[:split_idx]
+        self.y_test = y.iloc[split_idx:]
+        self.dates_test = df['date'].iloc[split_idx:]
+        self.feature_names = feature_cols
         
-        # Stockage des métriques
-        self.metrics[model_name] = {
-            'RMSE': rmse,
-            'MAE': mae,
-            'R²': r2,
-            'MAPE': mape
-        }
-        
-        return rmse, mae, r2, mape
-    
-    def train_all_models(self):
-        """Pipeline complet d'entraînement des 3 modèles"""
-        
-        st.info("🚀 **Préparation des données avec split temporel...**")
-        X_train, X_val, X_test, y_train, y_val, y_test, feature_names = self.prepare_data()
-        
-        progress_bar = st.progress(0)
-        status_text = st.empty()
+        return self.X_train, self.X_test, self.y_train, self.y_test
+
+    def train_models(self):
+        """Entraîne les 3 champions et stocke leurs prédictions pour comparaison"""
         
-        # 1. XGBoost
-        status_text.text("⚡ Entraînement XGBoost (Gradient Boosting Optimisé)...")
-        progress_bar.progress(10)
-        self.train_xgboost(X_train, X_val, y_train, y_val)
-        self.evaluate_model('XGBoost', self.models['XGBoost'], X_test, y_test)
-        progress_bar.progress(40)
+        # 1. LightGBM
+        lgb_model = lgb.LGBMRegressor(n_estimators=300, learning_rate=0.05, verbose=-1, random_state=42)
+        lgb_model.fit(self.X_train, self.y_train)
+        self.models['LightGBM'] = lgb_model
         
-        # 2. LightGBM
-        status_text.text("🌟 Entraînement LightGBM (Gradient Boosting Rapide)...")
-        self.train_lightgbm(X_train, X_val, y_train, y_val)
-        self.evaluate_model('LightGBM', self.models['LightGBM'], X_test, y_test)
-        progress_bar.progress(70)
+        # 2. XGBoost
+        xgb_model = xgb.XGBRegressor(n_estimators=300, learning_rate=0.05, n_jobs=-1, random_state=42)
+        xgb_model.fit(self.X_train, self.y_train)
+        self.models['XGBoost'] = xgb_model
         
         # 3. Random Forest
-        status_text.text("🌲 Entraînement Random Forest (Baseline Robuste)...")
-        self.train_random_forest(X_train, y_train)
-        self.evaluate_model('Random Forest', self.models['Random Forest'], X_test, y_test)
-        progress_bar.progress(100)
-        
-        status_text.text("✅ Entraînement terminé!")
-        
-        # Détermination du meilleur modèle
-        self._select_best_model()
-        
-        return self.metrics
-    
-    def _select_best_model(self):
-        """
-        Sélection automatique du meilleur modèle basée sur un score composite.
+        rf_model = RandomForestRegressor(n_estimators=100, max_depth=10, n_jobs=-1, random_state=42)
+        rf_model.fit(self.X_train, self.y_train)
+        self.models['Random Forest'] = rf_model
         
-        Logique de scoring :
-        - RMSE : poids 40% (critique pour éviter grandes erreurs en santé)
-        - MAE : poids 30% (robustesse)
-        - R² : poids 20% (variance expliquée)
-        - MAPE : poids 10% (compréhension business)
-        
-        Plus le score est BAS, mieux c'est.
-        """
+        # Évaluation Comparative
         scores = {}
-        
-        for model_name, metrics in self.metrics.items():
-            # Normalisation des métriques (min-max scaling)
-            # Pour RMSE, MAE, MAPE : plus bas = mieux
-            # Pour R² : plus haut = mieux
-            
-            rmse_norm = metrics['RMSE']
-            mae_norm = metrics['MAE']
-            r2_norm = 1 - metrics['R²']  # Inversé car on veut minimiser
-            mape_norm = metrics['MAPE'] if not np.isnan(metrics['MAPE']) else 100
+        for name, model in self.models.items():
+            # On stocke la prédiction sur le test set pour le graphique
+            pred = model.predict(self.X_test)
+            self.test_predictions[name] = pred
             
-            # Score composite
-            composite_score = (
-                0.40 * rmse_norm +
-                0.30 * mae_norm +
-                0.20 * r2_norm +
-                0.10 * mape_norm
-            )
+            # Métriques
+            rmse = np.sqrt(mean_squared_error(self.y_test, pred))
+            mae = mean_absolute_error(self.y_test, pred)
+            r2 = r2_score(self.y_test, pred)
             
-            scores[model_name] = composite_score
-        
-        # Sélection du modèle avec le score le plus bas
-        self.best_model_name = min(scores, key=scores.get)
-        self.composite_scores = scores
-    
-    def get_best_model_recommendation(self):
-        """
-        Génère une recommandation détaillée du meilleur modèle avec justification.
-        """
-        if not self.best_model_name:
-            return "Aucun modèle entraîné."
-        
-        best_metrics = self.metrics[self.best_model_name]
-        
-        recommendation = f"""
-### 🏆 MODÈLE RECOMMANDÉ : **{self.best_model_name}**
-
-#### 📊 Performances sur Test Set :
-- **RMSE** : {best_metrics['RMSE']:.2f} (Erreur quadratique moyenne)
-- **MAE** : {best_metrics['MAE']:.2f} (Erreur absolue moyenne)
-- **R²** : {best_metrics['R²']:.4f} ({best_metrics['R²']*100:.2f}% de variance expliquée)
-- **MAPE** : {best_metrics['MAPE']:.2f}% (Erreur en pourcentage)
-
-#### 🎯 Pourquoi ce modèle ?
+            self.metrics[name] = {'RMSE': rmse, 'MAE': mae, 'R2': r2}
+            scores[name] = rmse 
 
-"""
-        
-        # Justification spécifique selon le modèle
-        if self.best_model_name == 'XGBoost':
-            recommendation += """
-**Avantages de XGBoost :**
-- 🥇 **Champion des compétitions Kaggle** sur données tabulaires
-- 🎯 **Excellente précision** grâce au gradient boosting optimisé
-- 🛡️ **Robuste au surapprentissage** avec régularisation L1/L2
-- 🔍 **Gère bien les interactions complexes** entre features (hospitalières)
-- ⚡ **Early stopping** : arrêt automatique dès que validation cesse de s'améliorer
-
-**Idéal pour :** Prédictions critiques nécessitant la meilleure précision possible.
-"""
-        
-        elif self.best_model_name == 'LightGBM':
-            recommendation += """
-**Avantages de LightGBM :**
-- ⚡ **Rapidité exceptionnelle** : 10-20x plus rapide que XGBoost
-- 📈 **Excellent sur grandes données** grâce à l'algorithme leaf-wise
-- 💾 **Faible consommation mémoire** : idéal pour production
-- 🎯 **Précision comparable à XGBoost** avec moins de ressources
-- 🌳 **Moins de surapprentissage** naturellement
-
-**Idéal pour :** Déploiement en production avec contraintes de ressources.
-"""
-        
-        elif self.best_model_name == 'Random Forest':
-            recommendation += """
-**Avantages de Random Forest :**
-- 🌲 **Très robuste** : résiste bien au surapprentissage
-- 📖 **Facilement interprétable** : importance des features claire
-- 🛡️ **Stable** : moins sensible aux hyperparamètres que boosting
-- 🎲 **Gère bien les outliers** grâce au vote d'ensemble
-- 🔧 **Facile à maintenir** : peu de tuning nécessaire
+        self.best_model_name = min(scores, key=scores.get)
+        return self.metrics
 
-**Idéal pour :** Baseline solide et modèle de référence stable.
-"""
-        
-        # Comparaison avec les autres modèles
-        recommendation += "\n#### 📉 Comparaison avec les autres modèles :\n\n"
-        
-        for model_name, metrics in self.metrics.items():
-            if model_name != self.best_model_name:
-                rmse_diff = ((metrics['RMSE'] - best_metrics['RMSE']) / best_metrics['RMSE']) * 100
-                mae_diff = ((metrics['MAE'] - best_metrics['MAE']) / best_metrics['MAE']) * 100
-                
-                recommendation += f"- **{model_name}** : RMSE {rmse_diff:+.1f}%, MAE {mae_diff:+.1f}% vs {self.best_model_name}\n"
-        
-        # Niveau de confiance
-        best_r2 = best_metrics['R²']
-        if best_r2 > 0.85:
-            confidence = "🟢 EXCELLENTE"
-        elif best_r2 > 0.70:
-            confidence = "🟡 BONNE"
-        else:
-            confidence = "🔴 MODÉRÉE"
-        
-        recommendation += f"\n#### 🎖️ Niveau de Confiance : {confidence}\n"
-        recommendation += f"Le modèle explique **{best_r2*100:.1f}%** de la variance des admissions.\n"
-        
-        return recommendation
-    
-    def plot_predictions_comparison(self):
-        """Visualisation des prédictions des 3 modèles sur le test set"""
-        
-        fig = go.Figure()
-        
-        # Valeurs réelles
-        fig.add_trace(go.Scatter(
-            x=self.dates_test,
-            y=self.y_test,
-            mode='lines+markers',
-            name='Réel',
-            line=dict(color='black', width=3),
-            marker=dict(size=6)
-        ))
-        
-        # Prédictions de chaque modèle
-        colors = {'XGBoost': '#1f77b4', 'LightGBM': '#ff7f0e', 'Random Forest': '#2ca02c'}
-        
-        for model_name, y_pred in self.predictions.items():
-            is_best = (model_name == self.best_model_name)
-            
-            fig.add_trace(go.Scatter(
-                x=self.dates_test,
-                y=y_pred,
-                mode='lines',
-                name=f'{model_name}{"  🏆" if is_best else ""}',
-                line=dict(
-                    color=colors.get(model_name, 'gray'),
-                    width=3 if is_best else 1.5,
-                    dash='solid' if is_best else 'dash'
-                ),
-                opacity=1.0 if is_best else 0.6
-            ))
-        
-        fig.update_layout(
-            title="📈 Comparaison des Prédictions sur Test Set",
-            xaxis_title="Date",
-            yaxis_title="Nombre d'Admissions",
-            hovermode='x unified',
-            template='plotly_white',
-            height=500,
-            legend=dict(
-                yanchor="top",
-                y=0.99,
-                xanchor="left",
-                x=0.01
-            )
-        )
-        
-        return fig
-    
-    def plot_metrics_comparison(self):
-        """Graphique radar comparant les métriques des 3 modèles"""
-        
-        # Normalisation des métriques pour le radar (0-100 scale)
-        metrics_normalized = {}
-        
-        all_rmse = [m['RMSE'] for m in self.metrics.values()]
-        all_mae = [m['MAE'] for m in self.metrics.values()]
-        all_r2 = [m['R²'] for m in self.metrics.values()]
-        all_mape = [m['MAPE'] for m in self.metrics.values() if not np.isnan(m['MAPE'])]
+    def compute_shap(self):
+        """Calcule l'importance des features via SHAP (sur le meilleur modèle)"""
+        if not SHAP_AVAILABLE: return None, None
         
-        max_rmse = max(all_rmse)
-        max_mae = max(all_mae)
-        max_mape = max(all_mape) if all_mape else 100
+        model = self.models[self.best_model_name]
         
-        for model_name, metrics in self.metrics.items():
-            # Pour RMSE, MAE, MAPE : inverser car plus bas = mieux
-            rmse_score = (1 - metrics['RMSE'] / max_rmse) * 100
-            mae_score = (1 - metrics['MAE'] / max_mae) * 100
-            mape_score = (1 - metrics['MAPE'] / max_mape) * 100 if not np.isnan(metrics['MAPE']) else 0
-            r2_score = metrics['R²'] * 100  # Déjà entre 0-1
-            
-            metrics_normalized[model_name] = {
-                'RMSE': rmse_score,
-                'MAE': mae_score,
-                'R²': r2_score,
-                'MAPE': mape_score
-            }
-        
-        # Création du radar chart
-        categories = ['RMSE', 'MAE', 'R²', 'MAPE']
-        
-        fig = go.Figure()
-        
-        colors = {'XGBoost': '#1f77b4', 'LightGBM': '#ff7f0e', 'Random Forest': '#2ca02c'}
-        
-        for model_name, norm_metrics in metrics_normalized.items():
-            values = [norm_metrics[cat] for cat in categories]
-            values.append(values[0])  # Fermeture du radar
-            
-            is_best = (model_name == self.best_model_name)
-            
-            fig.add_trace(go.Scatterpolar(
-                r=values,
-                theta=categories + [categories[0]],
-                name=f'{model_name}{"  🏆" if is_best else ""}',
-                fill='toself',
-                line=dict(
-                    color=colors.get(model_name, 'gray'),
-                    width=3 if is_best else 2
-                ),
-                opacity=0.8 if is_best else 0.4
-            ))
-        
-        fig.update_layout(
-            polar=dict(
-                radialaxis=dict(
-                    visible=True,
-                    range=[0, 100]
-                )
-            ),
-            showlegend=True,
-            title="🎯 Radar de Performance des Modèles (Score sur 100)",
-            height=500
-        )
-        
-        return fig
-    
-    def plot_feature_importance(self, top_n=15):
-        """Importance des features pour le meilleur modèle"""
-        
-        best_model = self.models[self.best_model_name]
-        
-        if hasattr(best_model, 'feature_importances_'):
-            importances = best_model.feature_importances_
-            
-            # Création du DataFrame d'importance
-            importance_df = pd.DataFrame({
-                'Feature': self.feature_names,
-                'Importance': importances
-            }).sort_values('Importance', ascending=False).head(top_n)
-            
-            fig = px.bar(
-                importance_df,
-                x='Importance',
-                y='Feature',
-                orientation='h',
-                title=f"🔍 Top {top_n} Features Importantes - {self.best_model_name}",
-                color='Importance',
-                color_continuous_scale='Blues'
-            )
-            
-            fig.update_layout(
-                height=500,
-                yaxis={'categoryorder': 'total ascending'},
-                template='plotly_white'
-            )
-            
-            return fig
-        else:
-            return None
-    
-    def plot_shap_summary(self, max_display=15):
-        """SHAP summary plot pour le meilleur modèle"""
-        
-        if not SHAP_AVAILABLE:
-            st.warning("⚠️ SHAP n'est pas installé. Installer avec : `pip install shap`")
-            return None
+        # On échantillonne pour la vitesse (max 200 points)
+        X_sample = self.X_test.sample(n=min(200, len(self.X_test)), random_state=42)
         
         try:
-            best_model = self.models[self.best_model_name]
-            
-            # Sélection d'un échantillon pour SHAP (trop lent sur gros datasets)
-            sample_size = min(500, len(self.X_test))
-            X_sample = self.X_test.sample(n=sample_size, random_state=42)
-            
-            # Calcul des SHAP values
-            if self.best_model_name in ['XGBoost', 'LightGBM']:
-                explainer = shap.TreeExplainer(best_model)
-            else:
-                explainer = shap.Explainer(best_model.predict, X_sample)
-            
-            shap_values = explainer(X_sample)
-            
-            # Création du summary plot (version matplotlib)
-            import matplotlib.pyplot as plt
-            
-            fig, ax = plt.subplots(figsize=(10, 8))
-            shap.summary_plot(
-                shap_values.values if hasattr(shap_values, 'values') else shap_values,
-                X_sample,
-                max_display=max_display,
-                show=False
-            )
-            
-            st.pyplot(fig)
-            plt.close()
-            
-            return True
-            
-        except Exception as e:
-            st.error(f"Erreur SHAP : {str(e)}")
-            return None
-    
-    def plot_residuals(self):
-        """Analyse des résidus pour le meilleur modèle"""
-        
-        best_pred = self.predictions[self.best_model_name]
-        residuals = self.y_test - best_pred
-        
-        # Création de subplots
-        fig = make_subplots(
-            rows=1, cols=2,
-            subplot_titles=('Distribution des Résidus', 'Résidus vs Prédictions')
-        )
-        
-        # Histogramme des résidus
-        fig.add_trace(
-            go.Histogram(
-                x=residuals,
-                name='Résidus',
-                marker_color='steelblue',
-                nbinsx=30
-            ),
-            row=1, col=1
-        )
-        
-        # Scatter résidus vs prédictions
-        fig.add_trace(
-            go.Scatter(
-                x=best_pred,
-                y=residuals,
-                mode='markers',
-                name='Résidus',
-                marker=dict(color='coral', size=5, opacity=0.6)
-            ),
-            row=1, col=2
-        )
-        
-        # Ligne horizontale à 0
-        fig.add_hline(y=0, line_dash="dash", line_color="red", row=1, col=2)
-        
-        fig.update_xaxes(title_text="Résidus", row=1, col=1)
-        fig.update_xaxes(title_text="Prédictions", row=1, col=2)
-        fig.update_yaxes(title_text="Fréquence", row=1, col=1)
-        fig.update_yaxes(title_text="Résidus", row=1, col=2)
-        
-        fig.update_layout(
-            title_text=f"📊 Analyse des Résidus - {self.best_model_name}",
-            height=400,
-            showlegend=False,
-            template='plotly_white'
-        )
-        
-        return fig
+            # TreeExplainer est optimisé pour XGB/LGBM/RF
+            explainer = shap.TreeExplainer(model)
+            shap_values = explainer.shap_values(X_sample)
+            return explainer, shap_values, X_sample
+        except:
+            return None, None, None
+
+    def generate_future_forecast(self, months=3):
+        """Prédiction Récursive vers le Futur"""
+        days = months * 30
+        future_dates = [self.last_train_date + timedelta(days=i) for i in range(1, days + 1)]
+        model = self.models[self.best_model_name]
+        
+        # Reconstruction simplifiée des vecteurs futurs (Vectorisée pour vitesse)
+        future_df = pd.DataFrame({'date': future_dates})
+        future_df['jour_semaine'] = future_df['date'].dt.dayofweek
+        future_df['mois'] = future_df['date'].dt.month
+        future_df['mois_sin'] = np.sin(2 * np.pi * future_df['mois']/12)
+        future_df['mois_cos'] = np.cos(2 * np.pi * future_df['mois']/12)
+        
+        # Moyenne des autres features (Hypothèse de stabilité)
+        mean_values = self.df[self.feature_names].mean()
+        X_future = pd.DataFrame([mean_values] * len(future_df), columns=self.feature_names)
+        
+        # Update temporel
+        for col in ['jour_semaine', 'mois_sin', 'mois_cos']:
+            if col in X_future.columns:
+                X_future[col] = future_df[col].values
 
+        y_future = model.predict(X_future)
+        return future_dates, y_future
 
 # ============================================================================
-# INTERFACE STREAMLIT (GOTHAM UI)
+# INTERFACE STREAMLIT (UPDATE : NON-TECH FRIENDLY)
 # ============================================================================
 
-def show_forecasting_module():
-    """
-    Interface Streamlit pour le module de forecasting.
-    Affiche l'entraînement, la comparaison et la recommandation des modèles.
-    """
-    
-    st.markdown("## 🎯 FORECASTING ENGINE")
-    st.caption("Entraînement, comparaison et sélection automatique du meilleur modèle ML.")
-    st.divider()
-    
-    # Vérification des features dans session_state
+def show_forecasting_module(client, sheet_name):
+    st.markdown("## 🔮 ORACLE : FORECASTING & AUDIT")
+    st.caption("Intelligence Artificielle de prédiction des flux hospitaliers.")
+
     if 'ml_features' not in st.session_state:
-        st.error("❌ **Aucun dataset ML détecté.**")
-        st.info("💡 Veuillez d'abord exécuter le module **Feature Engineering** pour générer les features.")
-        
-        if st.button("🔄 Aller au Feature Engineering"):
-            st.switch_page("pages/03_Features.py")  # Adapter selon votre structure
+        st.error("❌ Données ML absentes. Allez dans 'Features Eng.' d'abord.")
         return
     
-    # Récupération du dataset
-    ml_dataset = st.session_state['ml_features']
-    
-    # Informations sur le dataset
-    st.success(f"✅ Dataset ML chargé : **{len(ml_dataset):,}** échantillons")
-    
-    col1, col2, col3 = st.columns(3)
-    col1.metric("Features Disponibles", len(ml_dataset.columns))
-    col2.metric("Période", f"{ml_dataset['date'].min().strftime('%Y-%m-%d')} → {ml_dataset['date'].max().strftime('%Y-%m-%d')}")
-    col3.metric("Services", ml_dataset['service_code'].nunique() if 'service_code' in ml_dataset.columns else "N/A")
-    
-    st.divider()
-    
-    # Configuration
-    with st.expander("⚙️ Configuration de l'Entraînement"):
+    df = st.session_state['ml_features']
+
+    # --- 1. CONFIGURATION RAPIDE ---
+    with st.expander("⚙️ Paramètres", expanded=False):
         col1, col2 = st.columns(2)
+        target = col1.selectbox("Cible à Prédire", ['nb_admissions', 'taux_occupation'], index=0)
+        test_days = col2.slider("Période de Test (Jours)", 30, 90, 60)
+
+    # --- 2. ENTRAÎNEMENT (AUTO) ---
+    if 'forecaster' not in st.session_state:
+        forecaster = HospitalForecaster(df)
+        with st.spinner("🧠 Le système compare 3 intelligences (XGBoost, LightGBM, RF)..."):
+            forecaster.prepare_data(target_col=target, test_days=test_days)
+            metrics = forecaster.train_models()
+            st.session_state['forecaster'] = forecaster
+            st.session_state['metrics'] = metrics
+            st.rerun()
+            
+    forecaster = st.session_state['forecaster']
+    metrics = st.session_state['metrics']
+    best = forecaster.best_model_name
+    best_mae = metrics[best]['MAE']
+
+    # --- 3. AFFICHAGE PAR ONGLETS ---
+    tab_future, tab_audit = st.tabs(["🔮 Le Futur (Décision)", "⚖️ Le Verdict (Preuve)"])
+
+    # === ONGLET 1 : LE FUTUR ===
+    with tab_future:
+        st.markdown(f"### 🚀 Projections : {target}")
         
-        with col1:
-            target_var = st.selectbox(
-                "Variable Cible",
-                options=['nb_admissions', 'taux_occupation', 'tension_personnel', 'lits_occupes'],
-                index=0,
-                help="Variable à prédire"
-            )
-        
-        with col2:
-            test_size = st.slider(
-                "Taille Test Set (%)",
-                min_value=10,
-                max_value=30,
-                value=15,
-                step=5,
-                help="Proportion des données pour le test final"
-            )
-    
-    # Bouton d'entraînement
-    if st.button("🚀 **LANCER L'ENTRAÎNEMENT DES 3 MODÈLES**", type="primary", use_container_width=True):
-        
-        # Initialisation du forecaster
-        forecaster = HospitalForecaster(ml_dataset)
-        
-        # Entraînement
-        with st.spinner("🔥 Entraînement en cours..."):
-            metrics = forecaster.train_all_models()
-        
-        # Stockage dans session_state
-        st.session_state['forecaster'] = forecaster
-        st.session_state['metrics'] = metrics
-        
-        st.success("✅ **Entraînement terminé avec succès !**")
-        st.balloons()
-    
-    # Affichage des résultats si déjà entraîné
-    if 'forecaster' in st.session_state:
-        forecaster = st.session_state['forecaster']
-        metrics = st.session_state['metrics']
-        
-        st.divider()
-        
-        # ========== RECOMMANDATION DU MEILLEUR MODÈLE ==========
-        st.markdown("---")
-        recommendation = forecaster.get_best_model_recommendation()
-        st.markdown(recommendation)
-        st.markdown("---")
-        
-        # ========== TABLEAU COMPARATIF ==========
-        st.subheader("📊 Tableau Comparatif des Performances")
-        
-        metrics_df = pd.DataFrame(metrics).T
-        metrics_df = metrics_df.round(4)
-        
-        # Mise en évidence du meilleur modèle
-        def highlight_best(s):
-            if s.name == forecaster.best_model_name:
-                return ['background-color: #90EE90'] * len(s)
-            else:
-                return [''] * len(s)
-        
-        styled_metrics = metrics_df.style.apply(highlight_best, axis=1)
-        st.dataframe(styled_metrics, use_container_width=True)
-        
-        # KPIs du meilleur modèle
-        st.subheader(f"🏆 KPIs - {forecaster.best_model_name}")
-        kpi1, kpi2, kpi3, kpi4 = st.columns(4)
-        
-        best_metrics = metrics[forecaster.best_model_name]
-        kpi1.metric("RMSE", f"{best_metrics['RMSE']:.2f}", help="Root Mean Squared Error")
-        kpi2.metric("MAE", f"{best_metrics['MAE']:.2f}", help="Mean Absolute Error")
-        kpi3.metric("R²", f"{best_metrics['R²']:.4f}", help="Coefficient de détermination")
-        kpi4.metric("MAPE", f"{best_metrics['MAPE']:.2f}%", help="Mean Absolute Percentage Error")
-        
-        st.divider()
+        # Sélecteur d'horizon
+        horizon_label = st.radio("Voir dans...", ["3 Mois", "6 Mois", "9 Mois", "12 Mois"], horizontal=True)
+        months_map = {"3 Mois": 3, "6 Mois": 6, "9 Mois": 9, "12 Mois": 12}
         
-        # ========== VISUALISATIONS ==========
+        with st.spinner("Calcul de la trajectoire optimale..."):
+            f_dates, f_values = forecaster.generate_future_forecast(months_map[horizon_label])
+
+        # Graphique Futur
+        fig = go.Figure()
+        hist = df.iloc[-90:] # 3 derniers mois historiques
         
-        # 1. Comparaison des prédictions
-        st.subheader("📈 Visualisation des Prédictions")
-        fig_pred = forecaster.plot_predictions_comparison()
-        st.plotly_chart(fig_pred, use_container_width=True)
+        # Zone Historique
+        fig.add_trace(go.Scatter(x=hist['date'], y=hist[target], name="Passé Réel", line=dict(color='gray'), opacity=0.5))
         
-        # 2. Radar de performance
-        col1, col2 = st.columns(2)
+        # Zone Futur
+        fig.add_trace(go.Scatter(x=f_dates, y=f_values, name="Projection IA", line=dict(color='#00E676', width=3)))
         
-        with col1:
-            st.subheader("🎯 Radar de Performance")
-            fig_radar = forecaster.plot_metrics_comparison()
-            st.plotly_chart(fig_radar, use_container_width=True)
+        # Ligne verticale "Aujourd'hui"
+        fig.add_vline(x=hist['date'].max(), line_width=1, line_dash="dash", line_color="white")
+        fig.add_annotation(x=hist['date'].max(), y=hist[target].mean(), text="Aujourd'hui", showarrow=True, arrowhead=1)
+
+        fig.update_layout(title=f"Horizon {horizon_label}", template="plotly_dark", height=450, hovermode="x unified")
+        st.plotly_chart(fig, use_container_width=True)
         
-        with col2:
-            st.subheader("📊 Analyse des Résidus")
-            fig_residuals = forecaster.plot_residuals()
-            st.plotly_chart(fig_residuals, use_container_width=True)
+        st.caption(f"Prédiction générée par le modèle **{best}** (Fiabilité : {metrics[best]['R2']*100:.0f}%)")
+
+    # === ONGLET 2 : LE VERDICT (Pour les non-techs) ===
+    with tab_audit:
+        st.markdown("### 🏆 Qui est le meilleur prédicteur ?")
         
-        # 3. Feature Importance
-        st.subheader("🔍 Importance des Features")
-        fig_importance = forecaster.plot_feature_importance(top_n=15)
-        if fig_importance:
-            st.plotly_chart(fig_importance, use_container_width=True)
+        # --- A. LE VERDICT EN FRANÇAIS ---
+        st.info(f"""
+        **Résultat du match :** L'intelligence artificielle **{best}** a battu les autres modèles.
         
-        # 4. SHAP Analysis
-        if SHAP_AVAILABLE:
-            st.subheader("🧠 SHAP Analysis - Interprétabilité des Prédictions")
-            st.caption("Les SHAP values montrent l'impact de chaque feature sur les prédictions du modèle.")
-            
-            with st.spinner("Calcul des SHAP values... (peut prendre quelques secondes)"):
-                forecaster.plot_shap_summary(max_display=15)
+        🔎 **Pourquoi ?** Sur les {test_days} derniers jours, elle a suivi la courbe réelle avec le plus de précision.
+        En moyenne, elle se trompe de seulement **{best_mae:.1f}** unités par jour (contre {metrics['Random Forest']['MAE']:.1f} pour le moins bon).
+        """)
+
+        # --- B. PREUVE VISUELLE ---
+        st.markdown("#### 👁️ Preuve Visuelle : Modèles vs Réalité")
+        st.caption("Regardez quelle ligne colorée suit le mieux la ligne blanche pointillée (La Réalité).")
         
-        # ========== TÉLÉCHARGEMENT DES RÉSULTATS ==========
-        st.divider()
-        st.subheader("💾 Téléchargement des Résultats")
+        fig_comp = go.Figure()
         
-        col1, col2 = st.columns(2)
+        # 1. La Réalité (Blanche, très visible)
+        fig_comp.add_trace(go.Scatter(
+            x=forecaster.dates_test, y=forecaster.y_test, 
+            name="🔴 LA RÉALITÉ", line=dict(color='white', width=4, dash='dot')
+        ))
         
-        with col1:
-            # Export des métriques
-            metrics_csv = pd.DataFrame(metrics).T.to_csv(index=True).encode('utf-8')
-            st.download_button(
-                label="📥 Télécharger les Métriques (CSV)",
-                data=metrics_csv,
-                file_name='model_metrics_comparison.csv',
-                mime='text/csv'
-            )
+        # 2. Le Vainqueur (Vert fluo)
+        best_pred = forecaster.test_predictions[best]
+        fig_comp.add_trace(go.Scatter(
+            x=forecaster.dates_test, y=best_pred, 
+            name=f"🏆 {best} (Gagnant)",
+            line=dict(color='#00E676', width=3),
+            opacity=0.9
+        ))
         
-        with col2:
-            # Export des prédictions
-            predictions_df = pd.DataFrame({
-                'date': forecaster.dates_test,
-                'reel': forecaster.y_test,
-                'XGBoost': forecaster.predictions.get('XGBoost', []),
-                'LightGBM': forecaster.predictions.get('LightGBM', []),
-                'Random_Forest': forecaster.predictions.get('Random Forest', [])
-            })
+        # 3. Les Perdants (Grisés pour ne pas polluer)
+        for name, pred in forecaster.test_predictions.items():
+            if name != best:
+                fig_comp.add_trace(go.Scatter(
+                    x=forecaster.dates_test, y=pred, 
+                    name=name,
+                    line=dict(color='gray', width=1),
+                    opacity=0.4
+                ))
             
-            predictions_csv = predictions_df.to_csv(index=False).encode('utf-8')
-            st.download_button(
-                label="📥 Télécharger les Prédictions (CSV)",
-                data=predictions_csv,
-                file_name='model_predictions_test_set.csv',
-                mime='text/csv'
-            )
-        
-        st.success("✅ Module Forecasting complet !")
-
-
-# Point d'entrée si appelé directement
-if __name__ == "__main__":
-    show_forecasting_module()
+        fig_comp.update_layout(template="plotly_dark", height=450)
+        st.plotly_chart(fig_comp, use_container_width=True)
+        
+        # --- C. SHAP (Bonus Explicatif) ---
+        col_why, col_reset = st.columns([3, 1])
+        with col_why:
+            if SHAP_AVAILABLE:
+                with st.expander("🧠 Comprendre le cerveau de l'IA (Pourquoi ces chiffres ?)"):
+                    st.write("Ce graphique montre ce qui influence le plus la hausse ou la baisse des admissions :")
+                    if st.button("Calculer les Facteurs d'Influence"):
+                        with st.spinner("Analyse..."):
+                            explainer, shap_vals, X_samp = forecaster.compute_shap()
+                            if shap_vals is not None:
+                                fig_shap, ax = plt.subplots(figsize=(8, 5))
+                                fig_shap.patch.set_facecolor('#0e1117')
+                                ax.set_facecolor('#0e1117')
+                                shap.summary_plot(shap_vals, X_samp, max_display=8, plot_type="bar", show=False)
+                                ax.tick_params(colors='white', labelsize=10)
+                                ax.xaxis.label.set_color('white')
+                                st.pyplot(fig_shap)
+        
+        with col_reset:
+             if st.button("♻️ Reset"):
+                del st.session_state['forecaster']
+                st.rerun()