Update app.py

app.py

@@ -100,212 +100,167 @@ import streamlit as st
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
-from sklearn.tree import plot_tree, export_text
-import seaborn as sns
-from sklearn.preprocessing import LabelEncoder
-from sklearn.ensemble import RandomForestClassifier
 from sklearn.tree import DecisionTreeClassifier
-from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
 from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, roc_curve
-import shap
+from sklearn.metrics import accuracy_score, recall_score, f1_score, roc_auc_score
+import seaborn as sns
 
 # Configuration de la page
-st.set_page_config(
-    page_title="ML Model Interpreter",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
+st.set_page_config(layout="wide", page_title="ML Dashboard")
 
-# CSS personnalisé
+# Style personnalisé
 st.markdown("""
 <style>
-    .main-header {
-        color: #0D47A1;
-        text-align: center;
-        padding: 1rem;
-        background: linear-gradient(90deg, #FFFFFF 0%, #90CAF9 50%, #FFFFFF 100%);
-        border-radius: 10px;
-        margin-bottom: 2rem;
-    }
-    
-    .metric-card {
-        background-color: white;
+    /* Cartes stylisées */
+    div.css-1r6slb0.e1tzin5v2 {
+        background-color: #FFFFFF;
+        border: 1px solid #EEEEEE;
         padding: 1.5rem;
         border-radius: 10px;
-        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-        margin-bottom: 1rem;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
     }
-    
-    .sub-header {
+
+    /* Headers */
+    .main-header {
+        font-size: 2rem;
+        font-weight: 700;
         color: #1E88E5;
-        border-bottom: 2px solid #90CAF9;
-        padding-bottom: 0.5rem;
-        margin-bottom: 1rem;
+        text-align: center;
+        margin-bottom: 2rem;
     }
     
-    .metric-value {
-        font-size: 1.5rem;
-        font-weight: bold;
-        color: #1E88E5;
+    /* Metric containers */
+    div.css-12w0qpk.e1tzin5v2 {
+        background-color: #F8F9FA;
+        padding: 1rem;
+        border-radius: 8px;
+        text-align: center;
     }
     
-    div[data-testid="stMetricValue"] {
+    /* Metric values */
+    div.css-1xarl3l.e16fv1kl1 {
+        font-size: 1.8rem;
+        font-weight: 700;
         color: #1E88E5;
     }
 </style>
 """, unsafe_allow_html=True)
 
-def custom_metric_card(title, value, prefix=""):
-    return f"""
-    <div class="metric-card">
-        <h3 style="color: #1E88E5; margin-bottom: 0.5rem;">{title}</h3>
-        <p class="metric-value">{prefix}{value:.4f}</p>
-    </div>
-    """
-
-def set_plot_style(fig):
-    """Configure le style des graphiques"""
-    colors = ['#1E88E5', '#90CAF9', '#0D47A1', '#42A5F5']
-    for ax in fig.axes:
-        ax.set_facecolor('#F8F9FA')
-        ax.grid(True, linestyle='--', alpha=0.3, color='#666666')
-        ax.spines['top'].set_visible(False)
-        ax.spines['right'].set_visible(False)
-        ax.tick_params(axis='both', colors='#666666')
-        ax.set_axisbelow(True)
-    return fig, colors
-
-def plot_model_performance(results):
-    metrics = ['accuracy', 'f1', 'precision', 'recall', 'roc_auc']
-    fig, axes = plt.subplots(1, 2, figsize=(15, 6))
-    fig, colors = set_plot_style(fig)
-    
-    # Training metrics
-    train_data = {model: [results[model]['train_metrics'][metric] for metric in metrics] 
-                 for model in results.keys()}
-    train_df = pd.DataFrame(train_data, index=metrics)
-    train_df.plot(kind='bar', ax=axes[0], color=colors)
-    axes[0].set_title('Performance d\'Entraînement', color='#0D47A1', pad=20)
-    axes[0].set_ylim(0, 1)
+def plot_performance_comparison(results, metric='test_metrics'):
+    """Crée un graphique de comparaison des performances avec des couleurs distinctes"""
+    metrics = ['accuracy', 'f1', 'recall', 'roc_auc']
+    model_names = list(results.keys())
     
-    # Test metrics
-    test_data = {model: [results[model]['test_metrics'][metric] for metric in metrics] 
-                for model in results.keys()}
-    test_df = pd.DataFrame(test_data, index=metrics)
-    test_df.plot(kind='bar', ax=axes[1], color=colors)
-    axes[1].set_title('Performance de Test', color='#0D47A1', pad=20)
-    axes[1].set_ylim(0, 1)
+    # Définir des couleurs distinctes pour chaque modèle
+    colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4']
     
-    # Style des graphiques
-    for ax in axes:
-        plt.setp(ax.get_xticklabels(), rotation=45, ha='right')
-        ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+    data = {model: [results[model][metric][m] for m in metrics] 
+            for model in model_names}
     
-    plt.tight_layout()
-    return fig
-
-def plot_feature_importance(model, feature_names, model_type):
     fig, ax = plt.subplots(figsize=(10, 6))
-    fig, colors = set_plot_style(fig)
-    
-    if model_type in ["Decision Tree", "Random Forest", "Gradient Boost"]:
-        importance = model.feature_importances_
-    elif model_type == "Logistic Regression":
-        importance = np.abs(model.coef_[0])
+    x = np.arange(len(metrics))
+    width = 0.2
     
-    importance_df = pd.DataFrame({
-        'feature': feature_names,
-        'importance': importance
-    }).sort_values('importance', ascending=True)
+    for i, (model, values) in enumerate(data.items()):
+        ax.bar(x + i*width, values, width, label=model, color=colors[i])
     
-    ax.barh(importance_df['feature'], importance_df['importance'], 
-            color='#1E88E5', alpha=0.8)
-    ax.set_title("Importance des Caractéristiques", color='#0D47A1', pad=20)
+    ax.set_ylabel('Score')
+    ax.set_title(f'Comparaison des performances ({metric.split("_")[0].title()})')
+    ax.set_xticks(x + width * (len(model_names)-1)/2)
+    ax.set_xticklabels(metrics)
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    plt.ylim(0, 1)
     
     return fig
 
-def plot_correlation_matrix(data):
-    fig, ax = plt.subplots(figsize=(10, 8))
-    fig, _ = set_plot_style(fig)
-    
-    sns.heatmap(data.corr(), annot=True, cmap='coolwarm', center=0,
-                ax=ax, fmt='.2f', square=True)
-    ax.set_title("Matrice de Corrélation", color='#0D47A1', pad=20)
-    
-    return fig
+def create_metric_card(title, value):
+    """Crée une carte de métrique stylisée"""
+    st.markdown(f"""
+        <div style="
+            background-color: white;
+            padding: 1rem;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            text-align: center;
+            margin-bottom: 1rem;
+        ">
+            <h3 style="color: #666; font-size: 1rem; margin-bottom: 0.5rem;">{title}</h3>
+            <p style="color: #1E88E5; font-size: 1.8rem; font-weight: bold; margin: 0;">{value:.3f}</p>
+        </div>
+    """, unsafe_allow_html=True)
 
 def app():
-    st.markdown('<h1 class="main-header">Interpréteur de Modèles ML</h1>', 
-                unsafe_allow_html=True)
+    # Header
+    st.markdown('<h1 class="main-header">Tableau de Bord ML</h1>', unsafe_allow_html=True)
     
-    # Load data
+    # Charger et préparer les données
     X_train, y_train, X_test, y_test, feature_names = load_data()
     
-    # Train models if not in session state
-    if 'model_results' not in st.session_state:
-        with st.spinner("🔄 Entraînement des modèles en cours..."):
-            st.session_state.model_results = train_models(X_train, y_train, X_test, y_test)
-    
-    # Sidebar
+    # Sidebar pour la sélection du modèle
     with st.sidebar:
-        st.markdown('<h2 style="color: #1E88E5;">Navigation</h2>', 
-                   unsafe_allow_html=True)
-        
+        st.markdown('<h2 style="color: #1E88E5;">Configuration</h2>', unsafe_allow_html=True)
         selected_model = st.selectbox(
-            "📊 Sélectionnez un modèle",
-            list(st.session_state.model_results.keys())
-        )
-        
-        st.markdown('<hr style="margin: 1rem 0;">', unsafe_allow_html=True)
-        
-        page = st.radio(
-            "📑 Sélectionnez une section",
-            ["Performance des modèles", 
-             "Interprétation du modèle", 
-             "Analyse des caractéristiques",
-             "Simulateur de prédictions"]
+            "Sélectionner un modèle",
+            ["Logistic Regression", "Decision Tree", "Random Forest", "Gradient Boost"]
         )
     
-    current_model = st.session_state.model_results[selected_model]['model']
+    # Entraînement des modèles si pas déjà fait
+    if 'model_results' not in st.session_state:
+        with st.spinner("⏳ Entraînement des modèles..."):
+            st.session_state.model_results = train_models(X_train, y_train, X_test, y_test)
     
-    # Main content
-    if page == "Performance des modèles":
-        st.markdown('<h2 class="sub-header">Performance des modèles</h2>', 
-                   unsafe_allow_html=True)
-        
-        performance_fig = plot_model_performance(st.session_state.model_results)
-        st.pyplot(performance_fig)
+    # Layout principal
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        # Graphiques de performance
+        st.markdown("### 📊 Comparaison des Performances")
         
-        st.markdown('<h3 class="sub-header">Métriques détaillées</h3>', 
-                   unsafe_allow_html=True)
+        tab1, tab2 = st.tabs(["🎯 Test", "📈 Entraînement"])
         
-        col1, col2 = st.columns(2)
-        with col1:
-            st.markdown('<h4 style="color: #1E88E5;">Entraînement</h4>', 
-                       unsafe_allow_html=True)
-            for metric, value in st.session_state.model_results[selected_model]['train_metrics'].items():
-                st.markdown(custom_metric_card(metric.capitalize(), value), 
-                          unsafe_allow_html=True)
+        with tab1:
+            fig_test = plot_performance_comparison(st.session_state.model_results, 'test_metrics')
+            st.pyplot(fig_test)
         
-        with col2:
-            st.markdown('<h4 style="color: #1E88E5;">Test</h4>', 
-                       unsafe_allow_html=True)
-            for metric, value in st.session_state.model_results[selected_model]['test_metrics'].items():
-                st.markdown(custom_metric_card(metric.capitalize(), value), 
-                          unsafe_allow_html=True)
+        with tab2:
+            fig_train = plot_performance_comparison(st.session_state.model_results, 'train_metrics')
+            st.pyplot(fig_train)
     
-    elif page == "Analyse des caractéristiques":
-        st.markdown('<h2 class="sub-header">Analyse des caractéristiques</h2>', 
-                   unsafe_allow_html=True)
+    with col2:
+        # Métriques détaillées du modèle sélectionné
+        st.markdown(f"### 📌 Métriques - {selected_model}")
         
-        importance_fig = plot_feature_importance(current_model, feature_names, selected_model)
-        st.pyplot(importance_fig)
-        
-        st.markdown('<h3 class="sub-header">Corrélations</h3>', 
-                   unsafe_allow_html=True)
-        corr_fig = plot_correlation_matrix(X_train)
-        st.pyplot(corr_fig)
+        metrics = st.session_state.model_results[selected_model]['test_metrics']
+        for metric, value in metrics.items():
+            if metric != 'precision':  # On exclut la précision
+                create_metric_card(metric.upper(), value)
+    
+    # Section inférieure
+    st.markdown("### 🔍 Analyse Détaillée")
+    col3, col4 = st.columns(2)
+    
+    with col3:
+        # Feature Importance
+        current_model = st.session_state.model_results[selected_model]['model']
+        if hasattr(current_model, 'feature_importances_') or hasattr(current_model, 'coef_'):
+            fig_importance = plt.figure(figsize=(10, 6))
+            if hasattr(current_model, 'feature_importances_'):
+                importances = current_model.feature_importances_
+            else:
+                importances = np.abs(current_model.coef_[0])
+            
+            plt.barh(feature_names, importances)
+            plt.title("Importance des Caractéristiques")
+            st.pyplot(fig_importance)
+    
+    with col4:
+        # Matrice de corrélation
+        fig_corr = plt.figure(figsize=(10, 8))
+        sns.heatmap(X_train.corr(), annot=True, cmap='coolwarm', center=0)
+        plt.title("Matrice de Corrélation")
+        st.pyplot(fig_corr)
 
 if __name__ == "__main__":
     app()