Update app.py

app.py

@@ -96,216 +96,148 @@ def plot_feature_importance(model, feature_names, model_type):
     plt.title(f"Feature Importance - {model_type}")
     return plt.gcf()
 
-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.linear_model import LogisticRegression
-from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, roc_curve
-import shap
-
-# Configuration de la page
-st.set_page_config(
-    page_title="ML Model Interpreter",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# CSS 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;
-        padding: 1.5rem;
-        border-radius: 10px;
-        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-        margin-bottom: 1rem;
-    }
-    
-    .sub-header {
-        color: #1E88E5;
-        border-bottom: 2px solid #90CAF9;
-        padding-bottom: 0.5rem;
-        margin-bottom: 1rem;
-    }
-    
-    .metric-value {
-        font-size: 1.5rem;
-        font-weight: bold;
-        color: #1E88E5;
-    }
-    
-    div[data-testid="stMetricValue"] {
-        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)
-    
-    # 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)
-    
-    # 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')
-    
-    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])
-    
-    importance_df = pd.DataFrame({
-        'feature': feature_names,
-        'importance': importance
-    }).sort_values('importance', ascending=True)
-    
-    ax.barh(importance_df['feature'], importance_df['importance'], 
-            color='#1E88E5', alpha=0.8)
-    ax.set_title("Importance des Caractéristiques", color='#0D47A1', pad=20)
-    
-    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 app():
-    st.markdown('<h1 class="main-header">Interpréteur de Modèles ML</h1>', 
-                unsafe_allow_html=True)
+    st.title("Interpréteur de Modèles ML")
     
     # Load data
     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..."):
+        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
-    with st.sidebar:
-        st.markdown('<h2 style="color: #1E88E5;">Navigation</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"]
-        )
+    st.sidebar.title("Navigation")
+    selected_model = st.sidebar.selectbox(
+        "Sélectionnez un modèle",
+        list(st.session_state.model_results.keys())
+    )
+    
+    page = st.sidebar.radio(
+        "Sélectionnez une section",
+        ["Performance des modèles", 
+         "Interprétation du modèle", 
+         "Analyse des caractéristiques",
+         "Simulateur de prédictions"]
+    )
     
     current_model = st.session_state.model_results[selected_model]['model']
     
-    # Main content
+    # Performance des modèles
     if page == "Performance des modèles":
-        st.markdown('<h2 class="sub-header">Performance des modèles</h2>', 
-                   unsafe_allow_html=True)
+        st.header("Performance des modèles")
         
+        # Plot global performance comparison
+        st.subheader("Comparaison des performances")
         performance_fig = plot_model_performance(st.session_state.model_results)
         st.pyplot(performance_fig)
         
-        st.markdown('<h3 class="sub-header">Métriques détaillées</h3>', 
-                   unsafe_allow_html=True)
-        
+        # Detailed metrics for selected model
+        st.subheader(f"Métriques détaillées - {selected_model}")
         col1, col2 = st.columns(2)
+        
         with col1:
-            st.markdown('<h4 style="color: #1E88E5;">Entraînement</h4>', 
-                       unsafe_allow_html=True)
+            st.write("Métriques d'entraînement:")
             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)
+                st.write(f"{metric}: {value:.4f}")
         
         with col2:
-            st.markdown('<h4 style="color: #1E88E5;">Test</h4>', 
-                       unsafe_allow_html=True)
+            st.write("Métriques de test:")
             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)
+                st.write(f"{metric}: {value:.4f}")
     
+    # Interprétation du modèle
+    elif page == "Interprétation du modèle":
+        st.header(f"Interprétation du modèle - {selected_model}")
+        
+        if selected_model in ["Decision Tree", "Random Forest"]:
+            if selected_model == "Decision Tree":
+                st.subheader("Visualisation de l'arbre")
+                max_depth = st.slider("Profondeur maximale à afficher", 1, 5, 3)
+                fig, ax = plt.subplots(figsize=(20, 10))
+                plot_tree(current_model, feature_names=list(feature_names), 
+                         max_depth=max_depth, filled=True, rounded=True)
+                st.pyplot(fig)
+            
+            st.subheader("Règles de décision importantes")
+            if selected_model == "Decision Tree":
+                st.text(export_text(current_model, feature_names=list(feature_names)))
+        
+        # SHAP values for all models
+        st.subheader("SHAP Values")
+        with st.spinner("Calcul des valeurs SHAP en cours..."):
+            explainer = shap.TreeExplainer(current_model) if selected_model != "Logistic Regression" \
+                       else shap.LinearExplainer(current_model, X_train)
+            shap_values = explainer.shap_values(X_train[:100])  # Using first 100 samples for speed
+            
+            fig, ax = plt.subplots(figsize=(10, 6))
+            shap.summary_plot(shap_values, X_train[:100], feature_names=list(feature_names),
+                            show=False)
+            st.pyplot(fig)
+    
+    # Analyse des caractéristiques
     elif page == "Analyse des caractéristiques":
-        st.markdown('<h2 class="sub-header">Analyse des caractéristiques</h2>', 
-                   unsafe_allow_html=True)
+        st.header("Analyse des caractéristiques")
         
+        # Feature importance
+        st.subheader("Importance des caractéristiques")
         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)
+        # Feature correlation
+        st.subheader("Matrice de corrélation")
+        corr_matrix = X_train.corr()
+        fig, ax = plt.subplots(figsize=(10, 8))
+        sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0)
+        st.pyplot(fig)
+    
+    # Simulateur de prédictions
+    else:
+        st.header("Simulateur de prédictions")
+        
+        input_values = {}
+        for feature in feature_names:
+            if X_train[feature].dtype == 'object':
+                input_values[feature] = st.selectbox(
+                    f"Sélectionnez {feature}",
+                    options=X_train[feature].unique()
+                )
+            else:
+                input_values[feature] = st.slider(
+                    f"Valeur pour {feature}",
+                    float(X_train[feature].min()),
+                    float(X_train[feature].max()),
+                    float(X_train[feature].mean())
+                )
+        
+        if st.button("Prédire"):
+            input_df = pd.DataFrame([input_values])
+            
+            prediction = current_model.predict_proba(input_df)
+            
+            st.write("Probabilités prédites:")
+            st.write({f"Classe {i}": f"{prob:.2%}" for i, prob in enumerate(prediction[0])})
+            
+            if selected_model == "Decision Tree":
+                st.subheader("Chemin de décision")
+                node_indicator = current_model.decision_path(input_df)
+                leaf_id = current_model.apply(input_df)
+                
+                node_index = node_indicator.indices[node_indicator.indptr[0]:node_indicator.indptr[1]]
+                
+                rules = []
+                for node_id in node_index:
+                    if node_id != leaf_id[0]:
+                        threshold = current_model.tree_.threshold[node_id]
+                        feature = feature_names[current_model.tree_.feature[node_id]]
+                        if input_df.iloc[0][feature] <= threshold:
+                            rules.append(f"{feature} ≤ {threshold:.2f}")
+                        else:
+                            rules.append(f"{feature} > {threshold:.2f}")
+                
+                for rule in rules:
+                    st.write(rule)
 
 if __name__ == "__main__":
     app()