Hugging Face's logo

Spaces:
analist
/
Travel.Com
Sleeping

App Files Community
Travel.Com
File size: 5,286 Bytes 
3a61454
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
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

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
    pass

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("1. Vue globale du modèle")
    col1, col2 = st.columns(2)
    
    with col1:
        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()