Update app.py

app.py

@@ -6,200 +6,191 @@ 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, plot_tree
+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
 
-data = pd.read_csv('exported_named_train_good.csv')
-data_test = pd.read_csv('exported_named_test_good.csv')
-X_train = data.drop("Target", axis=1).values
-y_train = data['Target'].values
-
-X_test = data_test.drop('Target', axis=1).values
-y_test = data_test['Target'].values
-
-models={
-    "Logisitic Regression":LogisticRegression(),
-    "Decision Tree":DecisionTreeClassifier(),
-    "Random Forest":RandomForestClassifier(),
-    "Gradient Boost":GradientBoostingClassifier()
-}
-
-for name, model in models.items():
-
-    model.fit(X_train, y_train)
-
-    # Make predictions
-    y_train_pred = model.predict(X_train)
-    y_test_pred = model.predict(X_test)
-
-    # Training set performance
-    model_train_accuracy = accuracy_score(y_train, y_train_pred) # Calculate Accuracy
-    model_train_f1 = f1_score(y_train, y_train_pred, average='weighted') # Calculate F1-score
-    model_train_precision = precision_score(y_train, y_train_pred) # Calculate Precision
-    model_train_recall = recall_score(y_train, y_train_pred) # Calculate Recall
-    model_train_rocauc_score = roc_auc_score(y_train, y_train_pred)
-
-    # Test set performance
-    model_test_accuracy = accuracy_score(y_test, y_test_pred) # Calculate Accuracy
-    model_test_f1 = f1_score(y_test, y_test_pred, average='weighted') # Calculate F1-score
-    model_test_precision = precision_score(y_test, y_test_pred) # Calculate Precision
-    model_test_recall = recall_score(y_test, y_test_pred) # Calculate Recall
-    model_test_rocauc_score = roc_auc_score(y_test, y_test_pred) #Calculate Roc
-
-    print(name)
-
-    print('Model performance for Training set')
-    print("- Accuracy: {:.4f}".format(model_train_accuracy))
-    print('- F1 score: {:.4f}'.format(model_train_f1))
+def load_data():
+    data = pd.read_csv('exported_named_train_good.csv')
+    data_test = pd.read_csv('exported_named_test_good.csv')
+    X_train = data.drop("Target", axis=1)
+    y_train = data['Target']
+    X_test = data_test.drop('Target', axis=1)
+    y_test = data_test['Target']
+    return X_train, y_train, X_test, y_test, X_train.columns
+
+def train_models(X_train, y_train, X_test, y_test):
+    models = {
+        "Logistic Regression": LogisticRegression(random_state=42),
+        "Decision Tree": DecisionTreeClassifier(random_state=42),
+        "Random Forest": RandomForestClassifier(random_state=42),
+        "Gradient Boost": GradientBoostingClassifier(random_state=42)
+    }
     
-    print('- Precision: {:.4f}'.format(model_train_precision))
-    print('- Recall: {:.4f}'.format(model_train_recall))
-    print('- Roc Auc Score: {:.4f}'.format(model_train_rocauc_score))
+    results = {}
+    for name, model in models.items():
+        model.fit(X_train, y_train)
+        
+        # Predictions
+        y_train_pred = model.predict(X_train)
+        y_test_pred = model.predict(X_test)
+        
+        # Metrics
+        results[name] = {
+            'model': model,
+            'train_metrics': {
+                'accuracy': accuracy_score(y_train, y_train_pred),
+                'f1': f1_score(y_train, y_train_pred, average='weighted'),
+                'precision': precision_score(y_train, y_train_pred),
+                'recall': recall_score(y_train, y_train_pred),
+                'roc_auc': roc_auc_score(y_train, y_train_pred)
+            },
+            'test_metrics': {
+                'accuracy': accuracy_score(y_test, y_test_pred),
+                'f1': f1_score(y_test, y_test_pred, average='weighted'),
+                'precision': precision_score(y_test, y_test_pred),
+                'recall': recall_score(y_test, y_test_pred),
+                'roc_auc': roc_auc_score(y_test, y_test_pred)
+            }
+        }
+    
+    return results
 
+def plot_model_performance(results):
+    metrics = ['accuracy', 'f1', 'precision', 'recall', 'roc_auc']
+    fig, axes = plt.subplots(1, 2, figsize=(15, 6))
     
+    # 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], title='Training Performance')
+    axes[0].set_ylim(0, 1)
     
-    print('----------------------------------')
+    # 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], title='Test Performance')
+    axes[1].set_ylim(0, 1)
     
-    print('Model performance for Test set')
-    print('- Accuracy: {:.4f}'.format(model_test_accuracy))
-    print('- F1 score: {:.4f}'.format(model_test_f1))
-    print('- Precision: {:.4f}'.format(model_test_precision))
-    print('- Recall: {:.4f}'.format(model_test_recall))
-    print('- Roc Auc Score: {:.4f}'.format(model_test_rocauc_score))
+    plt.tight_layout()
+    return fig
 
+def plot_feature_importance(model, feature_names, model_type):
+    plt.figure(figsize=(10, 6))
     
-    print('='*35)
-    print('\n')
-
-def load_model_and_data():
-
-    model = models['Decision Tree']
-    data = pd.read_csv('exported_named_train_good.csv')
-    X = data.drop("Target", axis=1)
-    y = data['Target']
-
-    return model, X, y, X.columns
+    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])
     
-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 dtreeviz import trees
-
+    importance_df = pd.DataFrame({
+        'feature': feature_names,
+        'importance': importance
+    }).sort_values('importance', ascending=True)
+    
+    plt.barh(importance_df['feature'], importance_df['importance'])
+    plt.title(f"Feature Importance - {model_type}")
+    return plt.gcf()
 
 def app():
-    st.title("Interpréteur d'Arbre de Décision")
+    st.title("Interpréteur de Modèles ML")
     
-    # Chargement du modèle et des données
-    model, X, y, feature_names = load_model_and_data()
+    # Load data
+    X_train, y_train, X_test, y_test, feature_names = load_data()
     
-    if model is None:
-        st.warning("Veuillez charger un modèle pour commencer.")
-        return
+    # 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 avec les sections
+    # Sidebar
     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",
-        ["Vue globale du modèle", 
-         "Explorateur de règles", 
-         "Analyse de cohortes",
+        ["Performance des modèles", 
+         "Interprétation du modèle", 
+         "Analyse des caractéristiques",
          "Simulateur de prédictions"]
     )
     
-    # Vue globale du modèle
-    if page == "Vue globale du modèle":
-        st.header("Vue globale du modèle")
+    current_model = st.session_state.model_results[selected_model]['model']
+    
+    # Performance des modèles
+    if page == "Performance des modèles":
+        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)
+        
+        # Detailed metrics for selected model
+        st.subheader(f"Métriques détaillées - {selected_model}")
         col1, col2 = st.columns(2)
         
         with col1:
-            st.subheader("Importance des caractéristiques")
-            importance_plot = plt.figure(figsize=(10, 6))
-            feature_importance = pd.DataFrame({
-                'feature': feature_names,
-                'importance': model.feature_importances_
-            }).sort_values('importance', ascending=True)
-            plt.barh(feature_importance['feature'], feature_importance['importance'])
-            st.pyplot(importance_plot)
+            st.write("Métriques d'entraînement:")
+            for metric, value in st.session_state.model_results[selected_model]['train_metrics'].items():
+                st.write(f"{metric}: {value:.4f}")
         
         with col2:
-            st.subheader("Statistiques du modèle")
-            st.write(f"Profondeur de l'arbre: {model.get_depth()}")
-            st.write(f"Nombre de feuilles: {model.get_n_leaves()}")
+            st.write("Métriques de test:")
+            for metric, value in st.session_state.model_results[selected_model]['test_metrics'].items():
+                st.write(f"{metric}: {value:.4f}")
     
-    # Explorateur de règles
-    elif page == "Explorateur de règles":
-        st.header("Explorateur de règles de décision")
+    # Interprétation du modèle
+    elif page == "Interprétation du modèle":
+        st.header(f"Interprétation du modèle - {selected_model}")
         
-        viz_type = st.radio(
-            "Type de visualisation",
-            ["Texte", "Graphique interactif"]
-        )
-        
-        max_depth = st.slider("Profondeur maximale à afficher", 1, model.get_depth(), 3)
+        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)))
         
-        if viz_type == "Texte":
-            tree_text = export_text(model, feature_names=list(feature_names), max_depth=max_depth)
-            st.text(tree_text)
-        else:
-            # Création de la visualisation dtreeviz
-            viz = dtreeviz(
-                model,
-                X,
-                y,
-                target_name="target",
-                feature_names=list(feature_names),
-                class_names=list(map(str, model.classes_)),
-                max_depth=max_depth
-            )
+        # 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
             
-            # Sauvegarde temporaire et affichage
-            st.set_option('deprecation.showPyplotGlobalUse', False)
-            fig = viz.view()
+            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 de cohortes
-    elif page == "Analyse de cohortes":
-        st.header("Analyse de cohortes")
+    # Analyse des caractéristiques
+    elif page == "Analyse des caractéristiques":
+        st.header("Analyse des caractéristiques")
         
-        selected_features = st.multiselect(
-            "Sélectionnez les caractéristiques pour définir les cohortes",
-            feature_names,
-            max_selections=2
-        )
+        # Feature importance
+        st.subheader("Importance des caractéristiques")
+        importance_fig = plot_feature_importance(current_model, feature_names, selected_model)
+        st.pyplot(importance_fig)
         
-        if len(selected_features) > 0:
-            def create_cohorts(X, features):
-                cohort_def = X[features].copy()
-                for feat in features:
-                    if X[feat].dtype == 'object' or len(X[feat].unique()) < 10:
-                        cohort_def[feat] = X[feat]
-                    else:
-                        cohort_def[feat] = pd.qcut(X[feat], q=4, labels=['Q1', 'Q2', 'Q3', 'Q4'])
-                return cohort_def.apply(lambda x: ' & '.join(x.astype(str)), axis=1)
-            
-            cohorts = create_cohorts(X, selected_features)
-            
-            cohort_analysis = pd.DataFrame({
-                'Cohorte': cohorts,
-                'Prédiction': model.predict(X)
-            })
-            
-            cohort_stats = cohort_analysis.groupby('Cohorte')['Prédiction'].agg(['count', 'mean'])
-            cohort_stats.columns = ['Nombre d\'observations', 'Taux de prédiction positive']
-            
-            st.write("Statistiques par cohorte:")
-            st.dataframe(cohort_stats)
-            
-            cohort_viz = plt.figure(figsize=(10, 6))
-            sns.barplot(data=cohort_analysis, x='Cohorte', y='Prédiction')
-            plt.xticks(rotation=45)
-            st.pyplot(cohort_viz)
+        # 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:
@@ -207,45 +198,46 @@ def app():
         
         input_values = {}
         for feature in feature_names:
-            if X[feature].dtype == 'object':
+            if X_train[feature].dtype == 'object':
                 input_values[feature] = st.selectbox(
                     f"Sélectionnez {feature}",
-                    options=X[feature].unique()
+                    options=X_train[feature].unique()
                 )
             else:
                 input_values[feature] = st.slider(
                     f"Valeur pour {feature}",
-                    float(X[feature].min()),
-                    float(X[feature].max()),
-                    float(X[feature].mean())
+                    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 = model.predict_proba(input_df)
+            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])})
             
-            st.subheader("Chemin de décision")
-            node_indicator = model.decision_path(input_df)
-            leaf_id = 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 = model.tree_.threshold[node_id]
-                    feature = feature_names[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 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()
+    app()