Update app.py

app.py

@@ -3,40 +3,93 @@ import seaborn as sns
 import pandas as pd
 import numpy as np
 
-from sklearn.preprocessing import StandardScaler, OneHotEncoder
-from sklearn.compose import ColumnTransformer
-from sklearn.linear_model import LinearRegression, LogisticRegression
-from sklearn.feature_selection import mutual_info_regression, mutual_info_classif
-from sklearn.metrics import r2_score, accuracy_score
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LinearRegression
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.svm import SVR
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.metrics import r2_score
 from sklearn.model_selection import train_test_split
-#from scipy.stats import pearsonr
 from scipy.stats import spearmanr
+import plotly.graph_objects as go
+from xgboost import XGBRegressor
 
-# ------------------------------------------------------------
-# Configuration Globale
-# ------------------------------------------------------------
-TEST_SIZE = 0.3
+# Configuration globale
 RANDOM_STATE = 42
 
-st.set_page_config(page_title="Analyse d'importance", layout="wide")
+st.set_page_config(page_title="Analyse d'imputation", layout="wide")
 
-st.title("🔍 Analyse de l'importance des caractéristiques")
+# CSS personnalisé pour un rendu plus professionnel
+st.markdown("""
+<style>
+    .main {
+        background-color: #f8f9fa;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 8px;
+        background-color: white;
+        padding: 10px;
+        border-radius: 8px;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    .stTabs [data-baseweb="tab"] {
+        background-color: #f8f9fa;
+        border-radius: 6px;
+        padding: 10px 20px;
+        font-weight: 500;
+    }
+    .stTabs [aria-selected="true"] {
+        background-color: #0066cc;
+        color: white;
+    }
+    div[data-testid="stExpander"] {
+        background-color: white;
+        border: 1px solid #e0e0e0;
+        border-radius: 8px;
+        margin-bottom: 12px;
+        box-shadow: 0 1px 2px rgba(0,0,0,0.05);
+    }
+    div[data-testid="stExpander"] summary {
+        font-weight: 600;
+        color: #1a1a1a;
+        padding: 12px;
+    }
+    .stButton>button {
+        border-radius: 6px;
+        font-weight: 600;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    h1 {
+        color: #1a1a1a;
+        font-weight: 700;
+    }
+    h2, h3 {
+        color: #333333;
+        font-weight: 600;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+st.title("🔍 Analyse de fiabilité de l'imputation")
+# st.markdown(
+#     """
+# Cette application évalue la capacité à imputer chaque variable d'un dataset en utilisant les autres variables.
+
+# **Méthodologie :** Standardisation des données • Suppression des variables jumelles (corrélation Spearman) • Modélisation au choix • Évaluation de la qualité d'imputation (R²)
+# """
+# )
 st.markdown(
     """
-Cette application illustre la différence entre la pertinence marginale et la pertinence conditionnelle d'une caractéristique.
-
-- Pertinence marginale : corrélation ou information mutuelle avec la cible.
-- Pertinence conditionnelle : valeur ajoutée d'une variable excluant les redondances après contrôle.
+Cette application évalue la capacité à imputer chaque variable d'un dataset en utilisant les autres variables.
 """
 )
 
-# ------------------------------------------------------------
-# Sidebar: Dataset et Importation
-# ------------------------------------------------------------
+# Sidebar: Configuration
 with st.sidebar:
+    run_analysis = st.button("🚀 Lancer l'analyse", type="primary", use_container_width=True)
     st.header("⚙️ Configuration")
     
-    # Choix de la source de données
+    # Source de données
     data_source = st.radio(
         "Source des données",
         ["Jeu de données Seaborn", "Importer un fichier"],
@@ -49,41 +102,24 @@ with st.sidebar:
         uploaded_file = st.file_uploader("Importer un fichier CSV", type=["csv"])
         
         if uploaded_file is not None:
+            dataset_name = uploaded_file.name
             try:
                 df = pd.read_csv(uploaded_file, sep=None, engine='python')
-                
-                # Seuil de valeurs manquantes (configurable)
-                missing_threshold = st.slider(
-                    "Seuil max de valeurs manquantes (%)", 
-                    min_value=0, 
-                    max_value=100, 
-                    value=50,
-                    help="Les colonnes avec plus de X% de valeurs manquantes seront supprimées"
-                )
-                
-                # Calcul du pourcentage de valeurs manquantes par colonne
-                missing_pct = (df.isnull().sum() / len(df)) * 100
-                cols_to_drop = missing_pct[missing_pct > missing_threshold].index.tolist()
-                
-                if cols_to_drop:
-                    st.info(f"ℹ️ {len(cols_to_drop)} colonne(s) supprimée(s) (>{missing_threshold}% manquantes) : {', '.join(cols_to_drop)}")
-                    df = df.drop(columns=cols_to_drop)
-                
-                # Suppression des lignes avec valeurs manquantes restantes
+                df = df.select_dtypes(include=[np.number])
                 df = df.dropna()
                 
                 if len(df) == 0:
-                    st.error("❌ Aucune donnée après nettoyage. Essayez d'augmenter le seuil de valeurs manquantes.")
+                    st.error("❌ Aucune donnée numérique après nettoyage.")
                     df = None
-                else:
-                    st.success(f"✅ Fichier CSV chargé ! ({len(df)} lignes, {len(df.columns)} colonnes)")
+                #else:
+                #    st.success(f"✅ Fichier chargé ! ({len(df)} lignes, {len(df.columns)} colonnes)")
             except Exception as e:
                 st.error(f"Erreur : {e}")
                 df = None
     else:
         excluded_datasets = ['anagrams', 'anscombe', 'attention', 'brain_networks',
-                             'car_crashes', 'dowjones','diamonds','flights','geyser',
-                             'planets','seaice']
+                             'car_crashes', 'dowjones', 'exercise', 'fmri','flights', 'geyser',
+                             'planets', 'seaice']
         available_datasets = [d for d in sorted(sns.get_dataset_names()) if d not in excluded_datasets]
         default_dataset = "iris"
         default_index = available_datasets.index(default_dataset) if default_dataset in available_datasets else 0
@@ -92,227 +128,336 @@ with st.sidebar:
             available_datasets,
             index=default_index
         )
-        #dataset_name = st.selectbox("Dataset d'exemple", available_datasets)
         try:
             df = sns.load_dataset(dataset_name)
+            df = df.select_dtypes(include=[np.number])
             df = df.dropna()
-            st.success(f"✅ Jeu '{dataset_name}' chargé")
+            #st.success(f"✅ Jeu '{dataset_name}' chargé")
         except Exception as e:
             st.error(f"Erreur : {e}")
             df = None
 
-    if df is not None:
-        target = st.selectbox("Sélection cible (Y)", df.columns)
-        y = df[target]
-        X = df.drop(columns=[target])
+    if df is not None and len(df.columns) > 1:
+        st.subheader("Paramètres")
         
-        # Vérification que X n'est pas vide après suppression de la cible
-        if len(X.columns) == 0:
-            st.warning("⚠️ Aucune variable disponible après sélection de la cible.")
-            X = None
-            y = None
-            task = None
-        else:
-            task = "Regression" if (y.dtype.kind in "ifu" and y.nunique() > 10) else "Classification"
-            excluded_features = st.multiselect("Variables à exclure :", X.columns.tolist(), default=[])
+        # Expander Modélisation
+        with st.expander("▶ Modélisation", expanded=True):
+            algo = st.selectbox(
+                "Algorithme de régression",
+                ["Régression Linéaire", "Random Forest", "SVR", "KNN", "XGBoost"],
+                help="Algorithme utilisé pour prédire chaque variable"
+            )
             
-            if excluded_features:
-                X = X.drop(columns=excluded_features)
-                
-            # Vérification après exclusion
-            if len(X.columns) == 0:
-                st.error("❌ Vous avez exclu toutes les variables ! Veuillez en garder au moins une.")
-                X = None
-                y = None
-                task = None
+            test_size = st.slider(
+                "Taille de l'ensemble test (%)",
+                min_value=10,
+                max_value=50,
+                value=30,
+                step=5,
+                help="Pourcentage des données pour le test"
+            )
+        
+        # Expander Nettoyage & Filtres
+        with st.expander("▶ Réglages", expanded=False):
+            corr_threshold = st.slider(
+                "Seuil de corrélation (Spearman)",
+                min_value=0.5,
+                max_value=0.99,
+                value=0.92,
+                step=0.01,
+                help="Variables avec corrélation > seuil seront considérées comme jumelles"
+            )
+            
+            outlier_threshold = st.slider(
+                "Seuil de suppression des outliers (écart-types)",
+                min_value=1.0,
+                max_value=6.0,
+                value=6.0,
+                step=0.5,
+                help="Supprime les valeurs à plus de X écart-types de la moyenne"
+            )
+            
+            sample_size = st.slider(
+                "Échantillon du dataset (%)",
+                min_value=10,
+                max_value=100,
+                value=100,
+                step=10,
+                help="Pourcentage du dataset à utiliser pour l'analyse"
+            )
+        
+        #st.divider()
+        #run_analysis = st.button("🚀 Lancer l'analyse", type="primary", use_container_width=True)
     else:
-        st.info("👈 Veuillez sélectionner ou importer un jeu de données.")
-        X = None
-        y = None
-        task = None
+        if df is not None:
+            st.warning("⚠️ Le dataset doit contenir au moins 2 variables numériques.")
+        else:
+            st.info("👈 Veuillez sélectionner ou importer un jeu de données.")
 
-# ------------------------------------------------------------
-# Onglets
-# ------------------------------------------------------------
-if df is not None and X is not None and len(X.columns) > 0:
-    tab1, tab2, tab3 = st.tabs(["📊 Analyse d'Importance", "📋 Données Brutes", "🔧 Types"])
+# Fonctions utilitaires
+def get_model(algo_name):
+    """Retourne le modèle selon l'algorithme sélectionné"""
+    if algo_name == "Régression Linéaire":
+        return LinearRegression()
+    elif algo_name == "Random Forest":
+        return RandomForestRegressor(n_estimators=100, random_state=RANDOM_STATE, n_jobs=-1)
+    elif algo_name == "SVR":
+        return SVR(kernel='rbf')
+    elif algo_name == "XGBoost":
+        return XGBRegressor(n_estimators=100, random_state=RANDOM_STATE, n_jobs=-1, verbosity=0)
+    else:  # KNN
+        return KNeighborsRegressor(n_neighbors=5)
 
-    with tab2:
-        st.dataframe(df.head(20), use_container_width=True)
+def remove_outliers(df, threshold):
+    """Supprime les outliers à plus de X écart-types"""
+    df_clean = df.copy()
+    for col in df_clean.columns:
+        mean = df_clean[col].mean()
+        std = df_clean[col].std()
+        df_clean = df_clean[np.abs(df_clean[col] - mean) <= threshold * std]
+    return df_clean
 
-    with tab3:
-        st.header("Types des variables")
-        
-        num_cols = X.select_dtypes(include=[np.number]).columns.tolist()
-        cat_cols = X.select_dtypes(exclude=[np.number]).columns.tolist()
+def remove_twin_variables(X, threshold):
+    """Supprime les variables jumelles basé sur corrélation Spearman"""
+    corr_matrix = X.corr(method='spearman').abs()
+    upper_tri = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
+    
+    to_drop = set()
+    for column in upper_tri.columns:
+        correlated = upper_tri.index[upper_tri[column] > threshold].tolist()
+        if correlated:
+            to_drop.update(correlated)
+    
+    return X.drop(columns=list(to_drop)), list(to_drop)
+
+def backward_elimination(X, y, p_threshold=0.05):
+    """Backward elimination basé sur les p-values"""
+    import statsmodels.api as sm
+    
+    X_with_const = sm.add_constant(X)
+    selected_features = list(X.columns)
+    
+    while len(selected_features) > 0:
+        model = sm.OLS(y, X_with_const[['const'] + selected_features]).fit()
+        p_values = model.pvalues[1:]
         
-        col1, col2 = st.columns(2)
+        max_p_value = p_values.max()
+        if max_p_value > p_threshold:
+            exclude_feature = p_values.idxmax()
+            selected_features.remove(exclude_feature)
+        else:
+            break
+    
+    return selected_features
+
+def evaluate_imputation(df, target_col, corr_threshold, test_size, algo):
+    """Évalue la faisabilité d'imputation pour une variable"""
+    X = df.drop(columns=[target_col])
+    y = df[target_col]
+    
+    # Vérification minimale de données
+    if len(X) < 10 or len(X.columns) == 0:
+        return None, [], []
+    
+    # Standardisation
+    scaler = StandardScaler()
+    X_scaled = pd.DataFrame(scaler.fit_transform(X), columns=X.columns, index=X.index)
+    
+    # Suppression des jumelles
+    X_filtered, dropped_twins = remove_twin_variables(X_scaled, corr_threshold)
+    
+    if len(X_filtered.columns) == 0:
+        return 0.0, [], dropped_twins
+    
+    # Split train/test
+    try:
+        X_train, X_test, y_train, y_test = train_test_split(
+            X_filtered, y, test_size=test_size/100, random_state=RANDOM_STATE
+        )
+    except:
+        return None, [], dropped_twins
+    
+    # Backward elimination (seulement pour régression linéaire avec seuil fixe de 0.05)
+    selected_features = list(X_train.columns)
+    if algo == "Régression Linéaire" and len(X_train.columns) > 1:
+        try:
+            selected_features = backward_elimination(X_train, y_train, p_threshold=0.05)
+        except:
+            pass
+    
+    if len(selected_features) == 0:
+        return 0.0, [], dropped_twins
+    
+    # Entraînement du modèle
+    model = get_model(algo)
+    X_train_selected = X_train[selected_features]
+    X_test_selected = X_test[selected_features]
+    
+    try:
+        model.fit(X_train_selected, y_train)
+        y_pred = model.predict(X_test_selected)
+        r2 = r2_score(y_test, y_pred)
+        return max(0, r2), selected_features, dropped_twins
+    except:
+        return 0.0, selected_features, dropped_twins
+
+# Interface principale
+if df is not None and len(df.columns) > 1:
+    tab1, tab2, tab3, tab4, tab5 = st.tabs(["📊 Analyse", "📋 Détails par variable", "📈 Statistiques", "💾 Données brutes", "ℹ️ Information"])
+
+    with tab4:
+        st.dataframe(df.head(20), use_container_width=True)
+
+    with tab5:
+        st.header("À propos de l'analyse")
+        st.markdown(f"""
+        **Nom du dataset :** {dataset_name}
+
+        **Dataset :** {len(df)} lignes × {len(df.columns)} colonnes
         
-        with col1:
-            st.subheader("Numériques")
-            for col in num_cols or ["None"]:
-                st.write(f"- {col}")
+        **Interprétation du R² :**
+        - **R² > 0.7** : Imputation très fiable ✅
+        - **0.5 < R² < 0.7** : Imputation acceptable ⚠️
+        - **R² < 0.5** : Imputation difficile ❌
         
-        with col2:
-            st.subheader("Catégorielles")
-            for col in cat_cols or ["None"]:
-                st.write(f"- {col}")
-    
-    # ------------------------------------------------------------
-    # Analyse Principale (Tab 1)
-    # ------------------------------------------------------------
+        **Méthodologie :**
+        1. Chaque variable est tour à tour considérée comme cible
+        2. Les autres variables servent de prédicteurs
+        3. Suppression des variables jumelles (corrélation > {corr_threshold})
+        4. Évaluation avec {algo}
+        """)
+
     with tab1:
-        if len(X.columns) > 0:
-            try:
-                num_cols = X.select_dtypes(include=[np.number]).columns.tolist()
-                cat_cols = X.select_dtypes(exclude=[np.number]).columns.tolist()
-                
-                # Vérification qu'il y a au moins une variable
-                if len(num_cols) == 0 and len(cat_cols) == 0:
-                    st.warning("⚠️ Aucune variable disponible pour l'analyse. Veuillez ne pas tout exclure.")
-                    st.stop()
-                
-                # Construction du préprocesseur seulement avec les colonnes qui existent
-                transformers = []
-                if num_cols:
-                    transformers.append(("num", StandardScaler(), num_cols))
-                if cat_cols:
-                    transformers.append(("cat", OneHotEncoder(drop="first", handle_unknown="ignore", sparse_output=False), cat_cols))
+        if 'run_analysis' in locals() and run_analysis:
+            # Préparation du dataset avec outliers et échantillonnage
+            df_processed = df.copy()
+            
+            # Suppression des outliers
+            if outlier_threshold < 6.0:
+                df_before = len(df_processed)
+                df_processed = remove_outliers(df_processed, outlier_threshold)
+                df_after = len(df_processed)
+                st.info(f"🧹 Outliers supprimés : {df_before - df_after} lignes ({(df_before - df_after)/df_before*100:.1f}%)")
+            
+            # Échantillonnage
+            if sample_size < 100:
+                df_processed = df_processed.sample(frac=sample_size/100, random_state=RANDOM_STATE)
+                st.info(f"📊 Échantillon utilisé : {len(df_processed)} lignes ({sample_size}% du dataset)")
+            
+            results = []
+            
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            for idx, col in enumerate(df_processed.columns):
+                status_text.text(f"Analyse de '{col}' ({idx+1}/{len(df_processed.columns)})...")
                 
-                if not transformers:
-                    st.warning("⚠️ Aucune colonne à traiter.")
-                    st.stop()
+                r2, selected_vars, dropped_twins = evaluate_imputation(
+                    df_processed, col, corr_threshold, test_size, algo
+                )
                 
-                preprocess = ColumnTransformer(transformers=transformers)
+                if r2 is not None:
+                    results.append({
+                        'Variable': col,
+                        'R²': r2,
+                        'Prédicteurs': len(selected_vars),
+                        'Jumelles': len(dropped_twins),
+                        'Statut': '✅ Excellent' if r2 > 0.7 else ('⚠️ Moyen' if r2 > 0.5 else '❌ Difficile')
+                    })
                 
-                X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=TEST_SIZE, random_state=RANDOM_STATE)
+                progress_bar.progress((idx + 1) / len(df_processed.columns))
+            
+            status_text.empty()
+            progress_bar.empty()
+            
+            if results:
+                results_df = pd.DataFrame(results).sort_values('R²', ascending=False)
                 
-                # Vérification qu'il y a assez de données pour le split
-                if len(X_train) == 0 or len(X_test) == 0:
-                    st.error("❌ Pas assez de données pour créer les ensembles d'entraînement et de test.")
-                    st.info(f"Données disponibles : {len(X)} lignes. Minimum requis : 2 lignes.")
-                    st.stop()
+                # Stocker dans session_state
+                st.session_state['results_df'] = results_df
                 
-                X_train_proc = preprocess.fit_transform(X_train)
+                # Graphique interactif
+                st.subheader("📈 Résultats de l'analyse")
                 
-                # Vérification que les données transformées ne sont pas vides
-                if X_train_proc.shape[0] == 0 or X_train_proc.shape[1] == 0:
-                    st.error("❌ Erreur : Les données transformées sont vides.")
-                    st.info(f"Shape après transformation : {X_train_proc.shape}")
-                    st.info(f"Variables numériques : {num_cols}")
-                    st.info(f"Variables catégorielles : {cat_cols}")
-                    st.stop()
+                fig = go.Figure()
                 
-                feature_names = preprocess.get_feature_names_out()
+                colors = ['#28a745' if r >= 0.7 else '#ffc107' if r >= 0.5 else '#dc3545' 
+                         for r in results_df['R²']]
                 
-                model = LinearRegression() if task == "Regression" else LogisticRegression(max_iter=1000)
-                model.fit(X_train_proc, y_train)
+                fig.add_trace(go.Bar(
+                    x=results_df['Variable'],
+                    y=results_df['R²'],
+                    marker_color=colors,
+                    text=results_df['R²'].round(3),
+                    textposition='outside',
+                    hovertemplate='<b>%{x}</b><br>R²: %{y:.3f}<extra></extra>'
+                ))
                 
-                y_pred = model.predict(preprocess.transform(X_test))
-                perf = r2_score(y_test, y_pred) if task == "Regression" else accuracy_score(y_test, y_pred)
+                fig.add_hline(y=0.7, line_dash="dash", line_color="#28a745", 
+                             annotation_text="Excellent (0.7)", annotation_position="right")
+                fig.add_hline(y=0.5, line_dash="dash", line_color="#ffc107", 
+                             annotation_text="Acceptable (0.5)", annotation_position="right")
                 
-                st.subheader("📊 Pertinence marginale vs conditionnelle")
-                st.markdown(f"**🎯 Performance globale : {perf:.2f} ({'R²' if task == 'Regression' else 'Précision'})**")
-
-                # Métriques
-                mi = mutual_info_regression(X_train_proc, y_train, random_state=0) if task == "Regression" else mutual_info_classif(X_train_proc, y_train, random_state=0)
-                coefs = model.coef_.ravel() if task == "Regression" else model.coef_[0]
+                fig.update_layout(
+                    title=f"Fiabilité de l'imputation par variable ({algo})",
+                    xaxis_title="Variable",
+                    yaxis_title="R² Score",
+                    height=470,
+                    showlegend=False,
+                    hovermode='x',
+                    plot_bgcolor='white',
+                    paper_bgcolor='white',
+                    font=dict(family="Arial, sans-serif", size=12, color="#333333")
+                )
                 
-                res = pd.DataFrame({
-                    "Variable": feature_names,
-                    "Importance seule (MI)": mi,
-                    "Poids dans le modèle": np.abs(coefs),
-                    "Sens": np.where(coefs > 0, "+", "-")
-                })
+                fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
+                fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='#f0f0f0')
                 
-                #if task == "Regression":
-                #    res["Lien direct (Corr)"] = [pearsonr(X_train_proc[:, i], y_train)[0] for i in range(len(feature_names))]
-
-                if task == "Regression":
-                    res["Lien direct (Corr)"] = [spearmanr(X_train_proc[:, i], y_train)[0] for i in range(len(feature_names))]
+                st.plotly_chart(fig, use_container_width=True)
                 
-                # Normalisation pour Score Synthétique
-                def normalize(s): return (s - s.min()) / (s.max() - s.min() + 1e-10)
-                mi_n = normalize(res["Importance seule (MI)"])
-                poids_n = normalize(res["Poids dans le modèle"])
-
-
-
-                if task == "Regression":
-                    corr_n = normalize(res["Lien direct (Corr)"].abs())
-                    res["Score synthétique"] = ((mi_n + corr_n) / 2 + poids_n) / 2
-                else:
-                    res["Score synthétique"] = (mi_n + poids_n) / 2
-
-                res = res.sort_values("Score synthétique", ascending=False)
-
-                # Réorganisation des colonnes
-                cols = ["Variable", "Score synthétique", "Importance seule (MI)", "Poids dans le modèle", "Sens"]
-                if task == "Regression":
-                    cols = ["Variable", "Score synthétique", "Importance seule (MI)", "Lien direct (Corr)", "Poids dans le modèle", "Sens"]
-                
-                final_df = res[cols].copy()
-
-                # --- STYLISATION ET AFFICHAGE ---
-                # 1. Préparation du style pour la colonne Sens (couleurs)
-                def style_sign(val):
-                    color = 'color: #2ecc71;' if val == '+' else 'color: #e74c3c;'
-                    return f'{color} font-weight: bold; font-size: 20px;'
-
-                # 2. Application du formatage (2 décimales) et des gradients
-                num_cols_to_style = [c for c in cols if c not in ["Variable", "Sens", "Score synthétique"]]
-                
-                styled_res = (final_df.style
-                    .format({c: "{:.2f}" for c in cols if c not in ["Variable", "Sens"]})
-                    .background_gradient(subset=num_cols_to_style, cmap="RdYlGn")
-                    .map(style_sign, subset=['Sens'])
-                )
-
-                # 3. Affichage avec st.data_editor pour fixer la hauteur (6 lignes env = 250px)
-                st.data_editor(
-                    styled_res,
-                    use_container_width=True,
-                    height=250, # Limite la hauteur avec scrollbar
-                    hide_index=True,
-                    disabled=True, # Empêche l'édition, agit comme un dataframe
-                    column_config={
-                        "Sens": st.column_config.Column(
-                            "Sens",
-                            help="Direction de l'influence",
-                            width="small"
-                        )
-                    }
-                )
-
-                st.subheader("📖 Guide de lecture")
-                st.markdown(
-                            """
-                - **Score synthétique** : Note globale d'importance.
-                - **Importance seule (MI)** : Mesure la dépendance globale entre la variable et la cible. Contrairement à la corrélation qui ne voit que les lignes droites, l'Information Mutuelle détecte toutes les formes de relations (courbes, motifs complexes, etc.). Elle indique quelle quantité d'information "pure" cette variable partage avec la cible, sans tenir compte des autres variables.
-                - **Poids dans le modèle** : Contribution finale au modèle.
-                - **Sens (+) / (-)** : Direction de l'impact sur la cible.
-                            """
-                        )
+            else:
+                st.error("❌ Aucun résultat. Vérifiez vos données.")
+        elif 'run_analysis' not in locals():
+            st.info("👈 Cliquez sur le bouton 'Lancer l'analyse' dans la sidebar")
+        else:
+            st.info("👈 Cliquez sur le bouton 'Lancer l'analyse' dans la sidebar")
+    
+    with tab2:
+        if 'results_df' in st.session_state:
+            st.subheader("📋 Détails par variable")
             
-            except ValueError as e:
-                if "Found array with 0 sample(s)" in str(e) or "shape=(0," in str(e):
-                    st.error("❌ Erreur d'analyse : données insuffisantes ou incompatibles")
-                    st.warning("⚠️ Vérifiez que :")
-                    st.markdown("""
-                    - Vous n'avez pas exclu toutes les variables
-                    - La variable cible choisie est appropriée (elle ne doit pas être identique à une variable prédictive)
-                    - Il reste suffisamment de données après nettoyage
-                    - Les variables ont suffisamment de variance
-                    """)
-                else:
-                    st.error(f"❌ Erreur : {str(e)}")
+            # Tableau avec style personnalisé
+            results_display = st.session_state['results_df'].copy()
             
-            except Exception as e:
-                st.error(f"❌ Une erreur s'est produite lors de l'analyse")
-                st.warning(f"Détails : {str(e)}")
-                st.info("💡 Essayez de changer de variable cible ou de variables prédictives.")
-                
+            styled_df = results_display.style.format({
+                'R²': '{:.3f}'
+            }).background_gradient(subset=['R²'], cmap='RdYlGn', vmin=0, vmax=1)
+            
+            st.dataframe(styled_df, use_container_width=True, hide_index=True, height=400)
+        else:
+            st.info("👈 Lancez d'abord une analyse pour voir les détails par variable")
+    
+    with tab3:
+        if 'results_df' in st.session_state:
+            st.subheader("📈 Statistiques récapitulatives")
+            
+            results_df = st.session_state['results_df']
+            
+            # Statistiques récapitulatives
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                excellent = len(results_df[results_df['R²'] > 0.7])
+                st.metric("Nombre d'imputations fiables", excellent, 
+                         delta=f"{excellent/len(results_df)*100:.1f}%")
+            with col2:
+                acceptable = len(results_df[(results_df['R²'] > 0.5) & (results_df['R²'] <= 0.7)])
+                st.metric("Nombre d'imputations acceptables", acceptable,
+                         delta=f"{acceptable/len(results_df)*100:.1f}%")
+            with col3:
+                difficult = len(results_df[results_df['R²'] <= 0.5])
+                st.metric("Nombre d'imputations déconseillées", difficult,
+                         delta=f"{difficult/len(results_df)*100:.1f}%")
         else:
-            st.info("ℹ️ Veuillez sélectionner au moins une variable.")
+            st.info("👈 Lancez d'abord une analyse pour voir les statistiques")
 else:
-    st.info("👈 Veuillez sélectionner ou importer un jeu de données pour commencer l'analyse.")
+    st.info("👈 Veuillez sélectionner un jeu de données avec au moins 2 variables numériques.")