app.py

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, plot_tree
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

data = pd.read_csv('exported_named_train_good.csv')
X_test = pd.read_csv('exported_named_test.csv').values
X_train = data.drop("Target", axis=1).values
y_train = data['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))
    
    print('- Precision: {:.4f}'.format(model_train_precision))
    print('- Recall: {:.4f}'.format(model_train_recall))
    print('- Roc Auc Score: {:.4f}'.format(model_train_rocauc_score))

    
    
    print('----------------------------------')
    
    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))

    
    print('='*35)
    print('\n')

def load_model_and_data():
    # Ici vous chargeriez votre modèle et données
    # Pour l'exemple, on suppose qu'ils sont disponibles comme:
    # model = loaded_model
    # X = loaded_X
    # y = loaded_y
    # feature_names = X.columns
    model = models['Decision Tree']
    data = pd.read_csv('exported_named_train.csv')
    X = data.drop("Target", axis=1)
    y = data['Target']

    return model, X, y
    
   

def app():
    st.title("Interpréteur d'Arbre de Décision")
    
    # Sidebar pour les contrôles
    st.sidebar.header("Paramètres d'analyse")
    
    # Section 1: Vue globale du modèle
    st.header("Vue globale du modèle")
    col1, col2 = st.columns(2)
    
    with col1:
        model, X, y = load_model_and_data()
        feature_names = X.columns
        st.subheader("Importance des caractéristiques")
        importance_plot = plt.figure(figsize=(10, 6))
        # Remplacer par vos features et leurs importances
        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)
    
    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()}")
    
    # Section 2: Explorateur de règles
    st.header("2. Explorateur de règles de décision")
    max_depth = st.slider("Profondeur maximale à afficher", 1, model.get_depth(), 3)
    
    tree_text = export_text(model, feature_names=list(feature_names), max_depth=max_depth)
    st.text(tree_text)
    
    # Section 3: Analyse de cohortes
    st.header("3. Analyse de cohortes")
    
    # Sélection des caractéristiques pour définir les cohortes
    selected_features = st.multiselect(
        "Sélectionnez les caractéristiques pour définir les cohortes",
        feature_names,
        max_selections=2
    )
    
    if len(selected_features) > 0:
        # Création des cohortes basées sur les caractéristiques sélectionnées
        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)
        
        # Analyse des prédictions par cohorte
        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)
        
        # Visualisation des cohortes
        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)
    
    # Section 4: Simulateur de prédictions
    st.header("4. Simulateur de prédictions")
    
    # Interface pour entrer des valeurs
    input_values = {}
    for feature in feature_names:
        if X[feature].dtype == 'object':
            input_values[feature] = st.selectbox(
                f"Sélectionnez {feature}",
                options=X[feature].unique()
            )
        else:
            input_values[feature] = st.slider(
                f"Valeur pour {feature}",
                float(X[feature].min()),
                float(X[feature].max()),
                float(X[feature].mean())
            )
    
    if st.button("Prédire"):
        # Création du DataFrame pour la prédiction
        input_df = pd.DataFrame([input_values])
        
        # Prédiction
        prediction = model.predict_proba(input_df)
        
        # Affichage du résultat
        st.write("Probabilités prédites:")
        st.write({f"Classe {i}": f"{prob:.2%}" for i, prob in enumerate(prediction[0])})
        
        # Chemin de décision pour cette prédiction
        st.subheader("Chemin de décision")
        node_indicator = model.decision_path(input_df)
        leaf_id = model.apply(input_df)
        
        feature_names = list(feature_names)
        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 __name__ == "__main__":
    app()