""" MODULE: FEATURE ENGINEERING (ML PREP) - VERSION OPTIMISÉE ========================================================== Responsabilité : Transformation des données CLEAN (de l'ETL) en vecteurs mathématiques pour le Machine Learning. Style : Gotham UI Pipeline : 1. Récupération des données CLEAN depuis DataExplorer (ETL) 2. Génération de features temporelles 3. Création de lags et rolling statistics 4. Features d'interaction 5. Stockage du dataset ML final CHANGEMENTS vs Version Précédente : - ✅ Utilise DataExplorer.dataframes_clean (données déjà nettoyées) - ✅ Suppression de _clean_for_ml() (redondant avec ETL) - ✅ Pas de dropna() agressif (déjà fait par ETL) - ✅ Fusion correcte avec admissions_jour - ✅ Gestion robuste des colonnes manquantes """ import pandas as pd import numpy as np from datetime import datetime, timedelta import streamlit as st import plotly.express as px import plotly.graph_objects as go # Intégration de l'ETL Engine from module.Validation_Contract import ETL_Engine # ===================================================== # ============= FEATURE ENGINEERING =================== # ===================================================== class FeatureEngineer: """ Moteur de génération de features ML à partir de données CLEAN. Prend en entrée les données déjà nettoyées par l'ETL. """ def __init__(self, data_explorer): """ Initialisation avec DataExplorer (contient RAW et CLEAN) Args: data_explorer: Instance de DataExplorer avec dataframes_clean """ # IMPORTANT : On utilise les données CLEAN, pas RAW self.clean_data = data_explorer.dataframes_clean self.ml_dataset = None def create_temporal_features(self, df, date_col='date'): """ Génération des cycles temporels et périodes hospitalières. Args: df: DataFrame avec colonne date date_col: Nom de la colonne date Returns: DataFrame enrichi avec features temporelles """ df = df.copy() df[date_col] = pd.to_datetime(df[date_col], errors='coerce') # Cycles Humains df['jour_semaine'] = df[date_col].dt.dayofweek # 0=Lundi, 6=Dimanche df['est_weekend'] = (df['jour_semaine'] >= 5).astype(int) df['mois'] = df[date_col].dt.month df['trimestre'] = df[date_col].dt.quarter df['jour_annee'] = df[date_col].dt.dayofyear # Cycles Saisonniers (Encodage cyclique pour le ML) # Permet au modèle de comprendre que Décembre (12) est proche de Janvier (1) df['mois_sin'] = np.sin(2 * np.pi * df['mois'] / 12) df['mois_cos'] = np.cos(2 * np.pi * df['mois'] / 12) # Encodage cyclique du jour de la semaine df['jour_semaine_sin'] = np.sin(2 * np.pi * df['jour_semaine'] / 7) df['jour_semaine_cos'] = np.cos(2 * np.pi * df['jour_semaine'] / 7) # Périodes Hospitalières Critiques (basées sur épidémiologie française) df['periode_grippe'] = ((df['mois'] >= 11) | (df['mois'] <= 3)).astype(int) df['periode_canicule'] = ((df['mois'] >= 6) & (df['mois'] <= 8)).astype(int) df['periode_gastro'] = ((df['mois'] >= 11) | (df['mois'] <= 2)).astype(int) df['periode_bronchiolite'] = ((df['mois'] >= 10) & (df['mois'] <= 2)).astype(int) # Jours fériés approximatifs (1er janvier, 1er mai, 14 juillet, 25 décembre) df['jour_ferie_approx'] = ( ((df['mois'] == 1) & (df[date_col].dt.day == 1)) | ((df['mois'] == 5) & (df[date_col].dt.day == 1)) | ((df['mois'] == 7) & (df[date_col].dt.day == 14)) | ((df['mois'] == 12) & (df[date_col].dt.day == 25)) ).astype(int) return df def create_lags_and_rolling(self, df, value_col, group_col='service_code', lags=[1, 7, 14], windows=[7, 14, 30]): """ Création de features de mémoire (lags) et statistiques mobiles (rolling). Args: df: DataFrame trié par date value_col: Colonne pour laquelle créer les lags group_col: Colonne de groupement (ex: service_code) lags: Liste des périodes de lag en jours windows: Liste des fenêtres pour rolling stats Returns: DataFrame enrichi avec lags et rolling """ df = df.copy() # Tri par date et groupe (ESSENTIEL pour séries temporelles) if group_col in df.columns: df = df.sort_values(['date', group_col]) else: df = df.sort_values('date') # Vérification que la colonne existe if value_col not in df.columns: st.warning(f"⚠️ Colonne '{value_col}' non trouvée, lags ignorés") return df # ===== LAGS (J-1, J-7, J-14, etc.) ===== for lag in lags: col_name = f'{value_col}_lag_{lag}' if group_col in df.columns: df[col_name] = df.groupby(group_col)[value_col].shift(lag) else: df[col_name] = df[value_col].shift(lag) # ===== ROLLING STATISTICS ===== for window in windows: # Moyenne mobile col_mean = f'{value_col}_mean_{window}j' if group_col in df.columns: df[col_mean] = df.groupby(group_col)[value_col].transform( lambda x: x.rolling(window=window, min_periods=1).mean() ) else: df[col_mean] = df[value_col].rolling(window=window, min_periods=1).mean() # Écart-type mobile (Volatilité) col_std = f'{value_col}_std_{window}j' if group_col in df.columns: df[col_std] = df.groupby(group_col)[value_col].transform( lambda x: x.rolling(window=window, min_periods=1).std() ).fillna(0) else: df[col_std] = df[value_col].rolling(window=window, min_periods=1).std().fillna(0) # Min mobile col_min = f'{value_col}_min_{window}j' if group_col in df.columns: df[col_min] = df.groupby(group_col)[value_col].transform( lambda x: x.rolling(window=window, min_periods=1).min() ) else: df[col_min] = df[value_col].rolling(window=window, min_periods=1).min() # Max mobile col_max = f'{value_col}_max_{window}j' if group_col in df.columns: df[col_max] = df.groupby(group_col)[value_col].transform( lambda x: x.rolling(window=window, min_periods=1).max() ) else: df[col_max] = df[value_col].rolling(window=window, min_periods=1).max() return df def create_interaction_features(self, df): """ Création de features d'interaction entre variables. """ df = df.copy() # Interaction tension/occupation (Indice de stress hospitalier) if 'taux_occupation' in df.columns and 'tension_personnel' in df.columns: df['indice_stress'] = df['taux_occupation'] * df['tension_personnel'] df['stress_eleve'] = (df['indice_stress'] > 1.0).astype(int) # Interaction scénario/weekend if 'scenario_intensity' in df.columns and 'est_weekend' in df.columns: df['intensity_x_weekend'] = df['scenario_intensity'] * df['est_weekend'] # Interaction période critique/occupation if 'periode_grippe' in df.columns and 'taux_occupation' in df.columns: df['grippe_x_occupation'] = df['periode_grippe'] * df['taux_occupation'] # Ratio personnel disponible / requis if 'personnel_disponible' in df.columns and 'personnel_requis' in df.columns: # On ajoute +1e-6 pour éviter la division par zéro df['ratio_personnel'] = df['personnel_disponible'] / (df['personnel_requis'] + 1e-6) df['deficit_personnel'] = (df['ratio_personnel'] < 1.0).astype(int) # --- CORRECTION OPTIMISÉE ICI --- # Capacité restante (Calcul direct car l'ETL a déjà typé les données) if 'lits_total' in df.columns and 'lits_occupes' in df.columns: df['capacite_restante'] = df['lits_total'] - df['lits_occupes'] df['saturation'] = (df['capacite_restante'] <= 5).astype(int) # -------------------------------- return df def build_full_dataset(self): """ Assemblage complet du Dataset ML Final. Pipeline : 1. Récupération données CLEAN (ressources + admissions + scénarios) 2. Fusion intelligente 3. Enrichissement temporel 4. Lags & Rolling 5. Features d'interaction 6. Nettoyage final léger (seulement NaN des lags) Returns: Tuple (DataFrame ML, message) """ # ===== 1. RÉCUPÉRATION DONNÉES CLEAN ===== df_res = self.clean_data.get('ressources_jour') df_adm = self.clean_data.get('admissions_jour') df_scenarios = self.clean_data.get('scenarios_calendrier') # Vérification données essentielles if df_res is None or df_res.empty: return None, "❌ Données 'ressources_jour' manquantes ou vides" # ===== 2. BASE : RESSOURCES JOURNALIÈRES ===== master = df_res.copy() # Conversion date si nécessaire if 'date' in master.columns: master['date'] = pd.to_datetime(master['date'], errors='coerce') else: return None, "❌ Colonne 'date' manquante dans ressources_jour" # ===== 3. FUSION AVEC ADMISSIONS ===== if df_adm is not None and not df_adm.empty: # Conversion date admissions if 'date' in df_adm.columns: df_adm['date'] = pd.to_datetime(df_adm['date'], errors='coerce') # Sélection colonnes clés (éviter doublons) cols_adm = ['date', 'service_code', 'nb_admissions'] cols_adm = [c for c in cols_adm if c in df_adm.columns] # Détermination clés de fusion if 'service_code' in df_adm.columns and 'service_code' in master.columns: merge_keys = ['date', 'service_code'] else: merge_keys = ['date'] # Fusion master = master.merge(df_adm[cols_adm], on=merge_keys, how='left') # Remplacement NaN par 0 (pas d'admission = 0) if 'nb_admissions' in master.columns: master['nb_admissions'] = master['nb_admissions'].fillna(0) else: st.warning("⚠️ Données 'admissions_jour' non disponibles, nb_admissions manquera") # ===== 4. ENRICHISSEMENT TEMPOREL ===== master = self.create_temporal_features(master) # ===== 5. FUSION AVEC SCÉNARIOS ===== if df_scenarios is not None and not df_scenarios.empty: # Conversion date scénarios if 'date' in df_scenarios.columns: df_scenarios['date'] = pd.to_datetime(df_scenarios['date'], errors='coerce') # Sélection colonnes cols_to_take = ['date', 'intensity'] # Ajout scénario si pas déjà présent if 'scenario' not in master.columns and 'scenario' in df_scenarios.columns: cols_to_take.append('scenario') # Filtrage colonnes existantes cols_to_take = [c for c in cols_to_take if c in df_scenarios.columns] # Rename intensity pour éviter conflit scen_clean = df_scenarios[cols_to_take].copy() if 'intensity' in scen_clean.columns: scen_clean = scen_clean.rename(columns={'intensity': 'scenario_intensity'}) # Fusion master = master.merge(scen_clean, on='date', how='left') # Remplissage NaN intensity par 0 (scénario normal) if 'scenario_intensity' in master.columns: master['scenario_intensity'] = master['scenario_intensity'].fillna(0) # Feature binaire : scénario actif ou non if 'scenario' in master.columns: master['scenario_is_normal'] = (master['scenario'] == 'Normal').astype(int) else: st.warning("⚠️ Données 'scenarios_calendrier' non disponibles") # ===== 6. LAGS & ROLLING STATISTICS ===== # Tri chronologique AVANT lags if 'service_code' in master.columns: master = master.sort_values(['date', 'service_code']).reset_index(drop=True) group_col = 'service_code' else: master = master.sort_values('date').reset_index(drop=True) group_col = None # Lags sur taux_occupation if 'taux_occupation' in master.columns: master = self.create_lags_and_rolling( master, 'taux_occupation', group_col=group_col, lags=[1, 7, 14], windows=[7, 14, 30] ) # Lags sur nb_admissions if 'nb_admissions' in master.columns: master = self.create_lags_and_rolling( master, 'nb_admissions', group_col=group_col, lags=[1, 7, 14], windows=[7, 14] ) # Lags sur tension_personnel if 'tension_personnel' in master.columns: master = self.create_lags_and_rolling( master, 'tension_personnel', group_col=group_col, lags=[1, 7], windows=[7] ) # ===== 7. FEATURES D'INTERACTION ===== master = self.create_interaction_features(master) # ===== 8. NETTOYAGE FINAL LÉGER ===== # On supprime SEULEMENT les lignes où les lags sont NaN (premières lignes de chaque groupe) rows_before = len(master) master = master.dropna() rows_after = len(master) rows_removed = rows_before - rows_after if rows_removed > 0: st.info(f"ℹ️ {rows_removed} lignes supprimées (NaN des lags sur premières dates)") # ========================================================= # 🔥 AJOUT CRITIQUE : ENCODAGE POUR COMPATIBILITÉ ML 🔥 # ========================================================= # Les modèles (XGBoost, Random Forest) ne savent pas lire le texte (ex: "CHIRURGIE"). # On convertit toutes les colonnes TEXTE (sauf la date) en CHIFFRES. # On détecte les colonnes de type 'object' (texte) ou 'category' categorical_cols = master.select_dtypes(include=['object', 'category']).columns count_encoded = 0 for col in categorical_cols: if col != 'date': # On ne touche SURTOUT PAS à la date (utile pour le split temporel) # Transformation : "CHIRURGIE" -> 0, "REANIMATION" -> 1 master[col] = master[col].astype('category').cat.codes count_encoded += 1 if count_encoded > 0: st.caption(f"🔧 {count_encoded} colonnes texte converties en codes numériques pour l'IA.") # ========================================================= # Stockage du dataset final self.ml_dataset = master return master, f"✅ Dataset ML créé : {len(master):,} échantillons, {len(master.columns)} features" # ===================================================== # ============= INTERFACE STREAMLIT =================== # ===================================================== def show_feature_engine(client, sheet_name): """ Interface Streamlit pour le Feature Engineering. Args: client: Client Google Sheets sheet_name: Nom de la feuille Google Sheets """ st.markdown("## FEATURE ENGINEERING CORE") st.caption("Transformation des données CLEAN (ETL) en vecteurs ML avec lags, rolling stats et interactions.") # ===== 1. CHARGEMENT VIA ETL ===== etl = ETL_Engine(client, sheet_name) # Vérification cache ETL if 'data_explorer' in st.session_state and hasattr(st.session_state.data_explorer, 'dataframes_clean'): data_explorer = st.session_state.data_explorer st.success("✅ Données CLEAN récupérées du Cache ETL") else: with st.spinner(" Exécution ETL requis..."): success, result = etl.run_etl() if not success: st.error(f"❌ Erreur ETL : {result}") return data_explorer = result # Affichage info sur les données source summary = data_explorer.get_summary() col1, col2, col3 = st.columns(3) col1.metric("Tables CLEAN disponibles", summary['tables_loaded']) col2.metric("Lignes CLEAN totales", f"{summary['total_rows_clean']:,}") col3.metric("Lignes supprimées par ETL", f"{summary['total_rows_removed']:,}") st.divider() # ===== 2. GÉNÉRATION AUTOMATIQUE DES FEATURES ===== if 'ml_features' not in st.session_state: engine = FeatureEngineer(data_explorer) with st.spinner(" Génération des features (Lags, Rolling, Saisons, Interactions)..."): df_final, msg = engine.build_full_dataset() if df_final is not None and not df_final.empty: st.session_state['ml_features'] = df_final st.success(msg) else: st.error(f"❌ Échec génération features : {msg}") return # ===== 3. AFFICHAGE DU RÉSULTAT ===== if 'ml_features' in st.session_state: df = st.session_state['ml_features'] # En-tête avec bouton de rafraîchissement col_titre, col_btn = st.columns([4, 1]) with col_titre: st.success(f"✅ Dataset ML Prêt ({len(df):,} échantillons)") with col_btn: if st.button(" Recalculer", key="recalc_features"): del st.session_state['ml_features'] st.rerun() # ===== KPI BAR ===== k1, k2, k3, k4 = st.columns(4) k1.metric("Lignes ML", f"{len(df):,}", delta="Clean Data", help="Données prêtes pour entraînement") k2.metric("Features Totales", len(df.columns), delta="+Lags & Rolling", help="Nombre total de colonnes") k3.metric("Période", f"{df['date'].min().strftime('%Y-%m-%d')} → {df['date'].max().strftime('%Y-%m-%d')}") k4.metric("Services", df['service_code'].nunique() if 'service_code' in df.columns else "N/A") st.divider() # ===== ANALYSE DES FEATURES ===== st.subheader(" Analyse des Features Générées") # Catégorisation des features feature_categories = { 'Temporelles': [c for c in df.columns if any(x in c for x in ['mois', 'jour', 'semaine', 'weekend', 'periode', 'trimestre', 'ferie'])], 'Lags': [c for c in df.columns if '_lag_' in c], 'Rolling': [c for c in df.columns if any(x in c for x in ['_mean_', '_std_', '_min_', '_max_'])], 'Interaction': [c for c in df.columns if any(x in c for x in ['indice_', '_x_', 'ratio_', 'deficit_', 'saturation', 'capacite_'])], 'Scénarios': [c for c in df.columns if 'scenario' in c.lower() or 'intensity' in c], 'Ressources': [c for c in df.columns if any(x in c for x in ['lits', 'personnel', 'taux', 'tension'])], } # Affichage par catégorie col1, col2 = st.columns(2) with col1: for category in ['Temporelles', 'Lags', 'Rolling']: features = feature_categories[category] with st.expander(f"{category} ({len(features)} features)"): if features: st.write(features) else: st.info("Aucune feature dans cette catégorie") with col2: for category in ['Interaction', 'Scénarios', 'Ressources']: features = feature_categories[category] with st.expander(f"{category} ({len(features)} features)"): if features: st.write(features) else: st.info("Aucune feature dans cette catégorie") st.divider() # ===== MATRICE DE CORRÉLATION ===== st.subheader(" Matrice de Corrélation") numerics = df.select_dtypes(include=[np.number]) # Sélection intelligente des colonnes à afficher priority_cols = [] # Target si disponible if 'nb_admissions' in numerics.columns: priority_cols.append('nb_admissions') # Features importantes priority_cols.extend([c for c in numerics.columns if any(x in c for x in ['lag_', 'mean_', 'std_', 'taux', 'tension', 'indice', 'intensity'])]) # Limitation à 20 pour lisibilité cols_to_plot = list(dict.fromkeys(priority_cols))[:20] if cols_to_plot and len(cols_to_plot) > 1: corr = numerics[cols_to_plot].corr() fig_corr = px.imshow( corr, text_auto=".2f", color_continuous_scale="RdBu_r", aspect="auto", title="Corrélation : Features Clés" ) fig_corr.update_layout(height=600) st.plotly_chart(fig_corr, use_container_width=True) else: st.info("Pas assez de features numériques pour la matrice de corrélation") # ===== STATISTIQUES DESCRIPTIVES ===== with st.expander(" Statistiques Descriptives"): st.dataframe(df.describe(), use_container_width=True) # ===== PREVIEW DATA ===== with st.expander(" Inspecter le Dataset ML Final"): # Options de filtrage col_f1, col_f2 = st.columns(2) with col_f1: if 'service_code' in df.columns: services = ['Tous'] + sorted(df['service_code'].unique().tolist()) selected_service = st.selectbox("Filtrer par service", services) if selected_service != 'Tous': df_display = df[df['service_code'] == selected_service] else: df_display = df else: df_display = df with col_f2: n_rows = st.slider("Nombre de lignes à afficher", 10, 500, 100) st.dataframe(df_display.head(n_rows), use_container_width=True) # ===== TÉLÉCHARGEMENT ===== st.divider() st.subheader("💾 Export du Dataset ML") col1, col2 = st.columns(2) with col1: csv = df.to_csv(index=False).encode('utf-8') st.download_button( label="📥 Télécharger Dataset ML (.csv)", data=csv, file_name=f'hospital_ml_features_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv', mime='text/csv', help="Dataset complet avec toutes les features pour entraînement ML" ) with col2: # Export des métadonnées metadata = { 'nombre_lignes': len(df), 'nombre_features': len(df.columns), 'date_min': df['date'].min().strftime('%Y-%m-%d'), 'date_max': df['date'].max().strftime('%Y-%m-%d'), 'features_temporelles': len(feature_categories['Temporelles']), 'features_lags': len(feature_categories['Lags']), 'features_rolling': len(feature_categories['Rolling']), 'features_interaction': len(feature_categories['Interaction']), 'timestamp_creation': datetime.now().strftime('%Y-%m-%d %H:%M:%S') } metadata_df = pd.DataFrame([metadata]) metadata_csv = metadata_df.to_csv(index=False).encode('utf-8') st.download_button( label="📋 Télécharger Métadonnées (.csv)", data=metadata_csv, file_name=f'ml_metadata_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv', mime='text/csv', help="Informations sur le dataset généré" ) st.success("✅ Feature Engineering terminé ! Vous pouvez maintenant passer au module Forecasting.")