Update app.py

app.py

@@ -2,265 +2,199 @@ 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
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix
+import plotly.express as px
+import plotly.graph_objects as go
 
-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
+# Configuration de la page
+st.set_page_config(layout="wide", page_title="ML Dashboard")
 
-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)
-    }
-    
-    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
+# Fonction pour charger les données
+@st.cache_data
+def load_data(file):
+	data = pd.read_csv(file)
+	return data
 
-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)
-    
-    # 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)
-    
-    plt.tight_layout()
-    return fig
+# Fonction pour entraîner les modèles
+def train_model(X_train, y_train, model_name):
+	models = {
+    	"Logistic Regression": LogisticRegression(),
+    	"Decision Tree": DecisionTreeClassifier(),
+    	"Random Forest": RandomForestClassifier(),
+    	"Gradient Boost": GradientBoostingClassifier()
+	}
+	model = models[model_name]
+	model.fit(X_train, y_train)
+	return model
 
-def plot_feature_importance(model, feature_names, model_type):
-    plt.figure(figsize=(10, 6))
-    
-    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)
-    
-    plt.barh(importance_df['feature'], importance_df['importance'])
-    plt.title(f"Feature Importance - {model_type}")
-    return plt.gcf()
+# Sidebar pour la navigation
+st.sidebar.title("Navigation")
+page = st.sidebar.radio("", ["📊 Vue d'ensemble", "🎯 Prédiction", "🔍 Interprétation", "⚙️ Entraînement"])
 
-import streamlit as st
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import accuracy_score, recall_score, f1_score, roc_auc_score
-import seaborn as sns
+# Charger les données par défaut
+if 'data' not in st.session_state:
+	try:
+    	st.session_state.data = load_data('exported_named_train_good.csv')
+    	st.session_state.test_data = load_data('exported_named_test_good.csv')
+	except:
+    	st.session_state.data = None
+    	st.session_state.test_data = None
 
-# Configuration de la page
-st.set_page_config(layout="wide", page_title="ML Dashboard")
+# Vue d'ensemble
+if page == "📊 Vue d'ensemble":
+	st.title("Tableau de bord ML")
+    
+	# Layout en colonnes
+	col1, col2 = st.columns([2, 1])
+    
+	with col1:
+    	# Upload de données
+    	uploaded_file = st.file_uploader("Charger de nouvelles données", type=['csv'])
+    	if uploaded_file is not None:
+        	st.session_state.data = load_data(uploaded_file)
+    
+	with col2:
+    	# Sélection du modèle
+    	model_name = st.selectbox(
+        	"Sélectionner un modèle",
+        	["Logistic Regression", "Decision Tree", "Random Forest", "Gradient Boost"]
+    	)
+    
+	if st.session_state.data is not None:
+    	# Métriques principales
+    	col1, col2, col3, col4, col5 = st.columns(5)
+   	 
+    	# Supposons que nous avons déjà un modèle entraîné
+    	X = st.session_state.data.drop("Target", axis=1)
+    	y = st.session_state.data["Target"]
+    	model = train_model(X, y, model_name)
+    	y_pred = model.predict(X)
+   	 
+    	with col1:
+        	st.metric("Accuracy", f"{accuracy_score(y, y_pred):.2%}")
+    	with col2:
+        	st.metric("Precision", f"{precision_score(y, y_pred):.2%}")
+    	with col3:
+        	st.metric("Recall", f"{recall_score(y, y_pred):.2%}")
+    	with col4:
+        	st.metric("F1-Score", f"{f1_score(y, y_pred):.2%}")
+    	with col5:
+        	st.metric("ROC AUC", f"{roc_auc_score(y, y_pred):.2%}")
+   	 
+    	# Graphiques
+    	col1, col2 = st.columns(2)
+   	 
+    	with col1:
+        	st.subheader("Importance des features")
+        	if hasattr(model, 'feature_importances_'):
+            	importances = pd.DataFrame({
+                	'feature': X.columns,
+                	'importance': model.feature_importances_
+            	}).sort_values('importance', ascending=True)
+            	fig = px.bar(importances, x='importance', y='feature', orientation='h')
+            	st.plotly_chart(fig, use_container_width=True)
+   	 
+    	with col2:
+        	st.subheader("Matrice de confusion")
+        	cm = confusion_matrix(y, y_pred)
+        	fig = px.imshow(cm,
+                      	labels=dict(x="Prédit", y="Réel"),
+                      	text=cm)
+        	st.plotly_chart(fig, use_container_width=True)
 
-# Style personnalisé
-st.markdown("""
-<style>
-    /* Cartes stylisées */
-    div.css-1r6slb0.e1tzin5v2 {
-        background-color: #FFFFFF;
-        border: 1px solid #EEEEEE;
-        padding: 1.5rem;
-        border-radius: 10px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-    }
+elif page == "🎯 Prédiction":
+	st.title("Prédiction")
+    
+	if st.session_state.data is not None:
+    	X = st.session_state.data.drop("Target", axis=1)
+   	 
+    	# Interface de prédiction
+    	st.subheader("Entrer les valeurs pour la prédiction")
+   	 
+    	input_values = {}
+    	cols = st.columns(3)
+    	for idx, feature in enumerate(X.columns):
+        	with cols[idx % 3]:
+            	if X[feature].dtype == 'object':
+                	input_values[feature] = st.selectbox(
+                    	f"{feature}",
+                    	options=X[feature].unique()
+                	)
+            	else:
+                	input_values[feature] = st.number_input(
+                    	f"{feature}",
+                    	value=float(X[feature].mean())
+                	)
+   	 
+    	if st.button("Prédire"):
+        	model = train_model(X, st.session_state.data["Target"], "Random Forest")
+        	pred = model.predict_proba(pd.DataFrame([input_values]))
+       	 
+        	st.subheader("Résultat de la prédiction")
+        	proba_df = pd.DataFrame({
+            	'Classe': ['0', '1'],
+            	'Probabilité': pred[0]
+        	})
+        	fig = px.bar(proba_df, x='Classe', y='Probabilité')
+        	st.plotly_chart(fig)
 
-    /* Headers */
-    .main-header {
-        font-size: 2rem;
-        font-weight: 700;
-        color: #1E88E5;
-        text-align: center;
-        margin-bottom: 2rem;
-    }
-    
-    /* Metric containers */
-    div.css-12w0qpk.e1tzin5v2 {
-        background-color: #F8F9FA;
-        padding: 1rem;
-        border-radius: 8px;
-        text-align: center;
-    }
-    
-    /* Metric values */
-    div.css-1xarl3l.e16fv1kl1 {
-        font-size: 1.8rem;
-        font-weight: 700;
-        color: #1E88E5;
-    }
-</style>
-""", unsafe_allow_html=True)
+elif page == "🔍 Interprétation":
+	st.title("Interprétation du modèle")
+    
+	if st.session_state.data is not None:
+    	# SHAP values ou autres méthodes d'interprétation
+    	st.subheader("Analyse des features")
+    	X = st.session_state.data.drop("Target", axis=1)
+    	y = st.session_state.data["Target"]
+   	 
+    	feature_1 = st.selectbox("Sélectionner la première feature", X.columns)
+    	feature_2 = st.selectbox("Sélectionner la deuxième feature", X.columns)
+   	 
+    	fig = px.scatter(st.session_state.data,
+                    	x=feature_1,
+                    	y=feature_2,
+                    	color='Target',
+                    	title=f"Relation entre {feature_1} et {feature_2}")
+    	st.plotly_chart(fig)
 
-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())
-    
-    # Définir des couleurs distinctes pour chaque modèle
-    colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4']
-    
-    data = {model: [results[model][metric][m] for m in metrics] 
-            for model in model_names}
-    
-    fig, ax = plt.subplots(figsize=(10, 6))
-    x = np.arange(len(metrics))
-    width = 0.2
-    
-    for i, (model, values) in enumerate(data.items()):
-        ax.bar(x + i*width, values, width, label=model, color=colors[i])
-    
-    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
+elif page == "⚙️ Entraînement":
+	st.title("Entraînement du modèle")
+    
+	if st.session_state.data is not None:
+    	# Options d'entraînement
+    	model_name = st.selectbox(
+        	"Sélectionner le modèle à entraîner",
+        	["Logistic Regression", "Decision Tree", "Random Forest", "Gradient Boost"]
+    	)
+   	 
+    	# Paramètres du modèle
+    	st.subheader("Paramètres du modèle")
+    	if model_name == "Random Forest":
+        	n_estimators = st.slider("Nombre d'arbres", 10, 200, 100)
+        	max_depth = st.slider("Profondeur maximale", 1, 20, 10)
+   	 
+    	if st.button("Entraîner le modèle"):
+        	with st.spinner("Entraînement en cours..."):
+            	X = st.session_state.data.drop("Target", axis=1)
+            	y = st.session_state.data["Target"]
+            	model = train_model(X, y, model_name)
+            	st.success("Modèle entraîné avec succès!")
+           	 
+            	# Afficher les métriques
+            	y_pred = model.predict(X)
+            	col1, col2, col3 = st.columns(3)
+            	with col1:
+                	st.metric("Accuracy", f"{accuracy_score(y, y_pred):.2%}")
+            	with col2:
+                	st.metric("Precision", f"{precision_score(y, y_pred):.2%}")
+            	with col3:
+                	st.metric("Recall", f"{recall_score(y, y_pred):.2%}")
 
-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():
-    # Header
-    st.markdown('<h1 class="main-header">Tableau de Bord ML</h1>', unsafe_allow_html=True)
-    
-    # Charger et préparer les données
-    X_train, y_train, X_test, y_test, feature_names = load_data()
-    
-    # Sidebar pour la sélection du modèle
-    with st.sidebar:
-        st.markdown('<h2 style="color: #1E88E5;">Configuration</h2>', unsafe_allow_html=True)
-        selected_model = st.selectbox(
-            "Sélectionner un modèle",
-            ["Logistic Regression", "Decision Tree", "Random Forest", "Gradient Boost"]
-        )
-    
-    # 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)
-    
-    # Layout principal
-    col1, col2 = st.columns([2, 1])
-    
-    with col1:
-        # Graphiques de performance
-        st.markdown("### 📊 Comparaison des Performances")
-        
-        tab1, tab2 = st.tabs(["🎯 Test", "📈 Entraînement"])
-        
-        with tab1:
-            fig_test = plot_performance_comparison(st.session_state.model_results, 'test_metrics')
-            st.pyplot(fig_test)
-        
-        with tab2:
-            fig_train = plot_performance_comparison(st.session_state.model_results, 'train_metrics')
-            st.pyplot(fig_train)
-    
-    with col2:
-        # Métriques détaillées du modèle sélectionné
-        st.markdown(f"### 📌 Métriques - {selected_model}")
-        
-        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()