Update app.py

app.py

@@ -5,95 +5,267 @@ import seaborn as sns
 import matplotlib.pyplot as plt
 from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
 
+# Configuration de la page
+st.set_page_config(page_title="CSI Activity Recognition",  layout="wide")
+
+st.markdown("""
+<style>
+    .sidebar-title {
+        
+        font-size: 24px;
+        font-weight: bold;
+        margin-bottom: 20px;
+    }
+    .sidebar-subheader {
+        color: #de2e03;
+        font-size: 18px;
+        font-weight: bold;
+        margin-top: 20px;
+        margin-bottom: 10px;
+    }
+    .sidebar-footer {
+      
+        font-weight: bold;
+    }
+</style>
+""", unsafe_allow_html=True)
+
 # ----------- Fonctions utiles -----------
 @st.cache_data
 def load_csv_file(file_path):
     return pd.read_csv(file_path)
-
+# Fonction pour créer une matrice de confusion de taille réduite
+def plot_confusion_matrix(cm, title="Matrice de Confusion"):
+    # Réduire la taille de la figure
+    fig, ax = plt.subplots(figsize=(5, 4))  # Taille réduite (était 8, 6)
+    
+    # Créer le heatmap avec des paramètres ajustés
+    sns.heatmap(
+        cm, 
+        annot=True,           # Afficher les valeurs
+        fmt="d",              # Format entier
+        cmap="Purples",       # Palette de couleurs
+        ax=ax,
+        cbar=False,           # Supprimer la barre de couleur pour gagner de l'espace
+        annot_kws={"size": 8} # Réduire la taille des annotations
+    )
+    
+    # Configurer les titres et labels
+    ax.set_title(title, fontsize=10)
+    ax.set_xlabel("Prédit", fontsize=8)
+    ax.set_ylabel("Réel", fontsize=8)
+    
+    # Réduire la taille des ticks
+    ax.tick_params(axis='both', which='major', labelsize=7)
+    
+    # Ajuster l'espacement
+    plt.tight_layout()
+    
+    return fig
 # ----------- Sidebar -----------
-st.sidebar.header("🛠️ Paramètres")
-room_path_dataSet = st.sidebar.text_input("📁 Chemin Dataset (.csv)", "data/Dataset/dataset.csv")
-y_true_path = st.sidebar.text_input("📂 y_true.npy", "data/Dataset/y_true.npy")
-y_pred_path = st.sidebar.text_input("📂 y_pred.npy", "data/Dataset/y_pred.npy")
-gwo_results_path = st.sidebar.text_input("📂 Résultats GWO.csv", "data/Dataset/gwo_results.csv")
-
-load_data_btn = st.sidebar.button("📥 Charger les fichiers")
-evaluate_btn = st.sidebar.button("🚀 Lancer l'Évaluation")
-
-st.title("📊 Dashboard - Évaluation CSI & Deep Learning")
-
-# ----------- Tabs -----------
-tabs = st.tabs(["📊 Données CSI", "⚙️ Résultats GWO", "📈 Évaluation du Modèle", "📤 Upload Utilisateur"])
-
-if load_data_btn or evaluate_btn:
-    try:
-        dataset = load_csv_file(room_path_dataSet)
-        y_true = np.load(y_true_path, allow_pickle=True)
-        y_pred = np.load(y_pred_path, allow_pickle=True)
-        results_df = pd.read_csv(gwo_results_path)
-
-        with tabs[0]:
-            st.subheader("📊 Aperçu du Dataset CSI")
-            st.dataframe(dataset)
+with st.sidebar:
+    
 
-        with tabs[1]:
-            st.subheader("⚙️ Résultats GWO")
-            st.dataframe(results_df)
+    
+    # Image petite et centrée
+    col1, col2, col3 = st.sidebar.columns([1, 2, 1])
+    with col2:
+        st.image("cerveau.png", width=100)
+        # Custom colored title instead of st.title
+    st.markdown('<p class="sidebar-title">Paramètres</p>', unsafe_allow_html=True)
+    
+    # Custom colored subheader instead of st.subheader
+    st.markdown('<p class="sidebar-subheader">Chemins des fichiers</p>', unsafe_allow_html=True)
+    room_path_dataSet = st.text_input("Dataset (.csv)", "data/Dataset/dataset.csv")
+    y_true_path = "data/Dataset/y_true.npy"
+    y_pred_path = "data/Dataset/y_pred.npy"
+    gwo_results_path = "data/Dataset/gwo_results.csv"
+    
+    # Custom colored subheader
+    st.markdown('<p class="sidebar-subheader">Téléchargement personnalisé</p>', unsafe_allow_html=True)
+    uploaded_fileX = st.file_uploader("y_pred.npy", type=["npy"])
+    uploaded_fileY = st.file_uploader("y_true.npy", type=["npy"])
+    
+    st.markdown("---")
+   
 
-            best_config = results_df.sort_values(by="val_loss").iloc[0]
-            st.success("🏆 Meilleurs hyperparamètres (GWO)")
-            st.write(best_config)
 
-            st.subheader("📈 Courbe d'Accuracy par itération")
-            fig1, ax1 = plt.subplots()
-            ax1.plot(results_df["val_accuracy"], marker="o")
-            ax1.set_xlabel("Itération")
-            ax1.set_ylabel("Accuracy")
-            ax1.grid(True)
-            st.pyplot(fig1)
+# ----------- Main Content -----------
+st.title(" Évaluation complète du Modèle")
+st.markdown("Analyse des performances du modèle de reconnaissance d'activités CSI")
 
-        with tabs[2]:
-            st.subheader("📄 Rapport de Classification")
-            report = classification_report(y_true, y_pred, output_dict=True)
-            st.dataframe(pd.DataFrame(report).transpose())
-
-            acc = accuracy_score(y_true, y_pred)
-            st.metric("🎯 Accuracy Globale", f"{acc:.4f}")
-
-            cm = confusion_matrix(y_true, y_pred)
-            fig2, ax2 = plt.subplots()
-            sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", ax=ax2)
-            ax2.set_title("Matrice de Confusion")
-            ax2.set_xlabel("Prédit")
-            ax2.set_ylabel("Réel")
-            st.pyplot(fig2)
-
-        with tabs[3]:
-            st.subheader("📤 Upload de vos propres résultats")
-
-            uploaded_fileX = st.file_uploader("📁 y_pred.npy", type=["npy"])
-            uploaded_fileY = st.file_uploader("📁 y_true.npy", type=["npy"])
+# Bouton principal de lancement
+if st.button("🚀 Lancer l'Évaluation Complète", type="primary"):
+    with st.spinner("Analyse en cours..."):
+        try:
+            # Chargement des données
+            y_true = np.load(y_true_path, allow_pickle=True)
+            y_pred = np.load(y_pred_path, allow_pickle=True)
+            results_df = pd.read_csv(gwo_results_path)
+            dataset = load_csv_file(room_path_dataSet)
+            
+            # Création des onglets
+            tab1, tab2, tab3, tab4, tab5 = st.tabs([
+                "📂 Décomposition des Données", 
+                "🧬 Résultats GWO", 
+                "📈 Évolution Accuracy",
+                "📊 Rapport de Classification",
+                "🔢 Matrice de Confusion"
+            ])
+            
+            # Onglet 1: Décomposition des données
+            with tab1:
+                st.header("Aperçu du Dataset")
+                st.dataframe(dataset.head())
+                st.markdown("---")
+                st.header("Statistiques descriptives")
+                st.dataframe(dataset.describe())
+                # Dans l'onglet 2: Résultats GWO 
+            with tab2:
+                st.header("Résultats d'optimisation GWO")
+                st.dataframe(results_df)
+                st.markdown("---")
+                st.header("Meilleurs hyperparamètres")
+                best_config = results_df.sort_values(by="val_loss").iloc[0]
+                # Création d'un dataframe pour une meilleure présentation
+                best_params_df = pd.DataFrame({
+                    'Paramètre': best_config.index,
+                    'Valeur': best_config.values
+                }).reset_index(drop=True)
+                # Style du tableau
+                st.dataframe(
+                    best_params_df.style
+                    .set_properties(**{
+                         'border': '1px solid #dee2e6'})
+                    .highlight_max(subset=['Valeur'],color='#de2e03')
+                    .highlight_min(subset=['Valeur'],color='#de2e03'),
+                    height=(len(best_params_df) + 1) * 35 + 3,
+                    use_container_width=True
+                )# Métriques en dessous
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.metric("Meilleure accuracy", f"{best_config['val_accuracy']:.4f}")
+                with col2:
+                    st.metric("Plus faible loss", f"{best_config['val_loss']:.4f}")
+           
+            
+            
+       
+            
+            # Onglet 3: Évolution Accuracy
+            with tab3:
+                st.header("Progression de l'accuracy")
+                fig, ax = plt.subplots(figsize=(10, 5))
+                ax.plot(results_df["val_accuracy"], marker="o", linestyle="-", color="#6366F1")
+                ax.set_xlabel("Itérations")
+                ax.set_ylabel("Accuracy")
+                ax.grid(True, alpha=0.3)
+                st.pyplot(fig)
+                
+           
+            
+            # Onglet 4: Rapport de classification
+            with tab4:
+                st.header("Rapport de classification détaillé")
+                report = classification_report(y_true, y_pred, output_dict=True)
+                st.dataframe(pd.DataFrame(report).transpose())
+                
+                st.markdown("---")
+                st.header("Metrics globales")
+                acc = accuracy_score(y_true, y_pred)
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("Accuracy", f"{acc:.2%}")
+                with col2:
+                    st.metric("Précision moyenne", f"{report['weighted avg']['precision']:.2%}")
+                with col3:
+                    st.metric("Rappel moyen", f"{report['weighted avg']['recall']:.2%}")
+            
+            # Onglet 5: Matrice de confusion
+            with tab5:
+                st.header("Matrice de confusion")
+                cm = confusion_matrix(y_true, y_pred)
+                
+                # Utiliser des colonnes pour contraindre la largeur
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    # Utiliser notre fonction personnalisée pour créer une matrice plus petite
+                    fig = plot_confusion_matrix(cm)
+                    st.pyplot(fig)
+        
+       
+                
+  
 
-            if uploaded_fileX is not None and uploaded_fileY is not None:
-                y_pred_user = np.load(uploaded_fileX, allow_pickle=True)
-                y_true_user = np.load(uploaded_fileY, allow_pickle=True)
+        except FileNotFoundError as e:
+            st.error(f"❌ Fichier non trouvé : {e}")
+        except Exception as e:
+            st.error(f"❌ Erreur : {e}")
 
-                st.success("✅ Fichiers utilisateurs chargés")
+# Section pour l'upload personnalisé
+st.divider()
+st.header("📤 Évaluation avec vos propres fichiers")
 
-                st.subheader("📄 Rapport personnalisé")
+if uploaded_fileX is not None and uploaded_fileY is not None:
+    with st.spinner("Analyse en cours..."):
+        try:
+            y_pred_user = np.load(uploaded_fileX, allow_pickle=True)
+            y_true_user = np.load(uploaded_fileY, allow_pickle=True)
+            
+            tab_user1, tab_user2 = st.tabs(["Rapport de Classification", "Matrice de Confusion"])
+            
+            with tab_user1:
+                st.header("Rapport de classification")
                 report = classification_report(y_true_user, y_pred_user, output_dict=True)
                 st.dataframe(pd.DataFrame(report).transpose())
-
+                
                 acc = accuracy_score(y_true_user, y_pred_user)
-                st.metric("🎯 Accuracy Upload", f"{acc:.4f}")
-
+                st.metric("Accuracy Globale", f"{acc:.2%}")
+            
+            with tab_user2:
+                st.header("Matrice de confusion")
                 cm = confusion_matrix(y_true_user, y_pred_user)
-                fig3, ax3 = plt.subplots()
-                sns.heatmap(cm, annot=True, fmt="d", cmap="Purples", ax=ax3)
-                ax3.set_title("Matrice de Confusion (Upload)")
-                ax3.set_xlabel("Prédit")
-                ax3.set_ylabel("Réel")
-                st.pyplot(fig3)
+                
+                # Utiliser des colonnes pour contraindre la largeur
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    # Utiliser notre fonction personnalisée pour créer une matrice plus petite
+                    fig = plot_confusion_matrix(cm, "Matrice de Confusion (Upload)")
+                    st.pyplot(fig)
+             
+        
+        except Exception as e:
+            st.error(f"❌ Erreur : {e}")
+else:
+    st.info("ℹ️ Veuillez télécharger vos fichiers dans la sidebar")
 
-    except Exception as e:
-        st.error(f"❌ Une erreur est survenue : {e}")
+        # Style CSS pour la sidebar
+    st.markdown("""
+        <style>
+        /* Titre principal */
+        .sidebar .title {
+            color: #FF4B4B !important;  /* Rouge-orange Streamlit */
+            font-size: 1.5em !important;
+        }
+        
+        /* Sous-titres */
+        .sidebar .stSubheader {
+            color: #FF6B6B !important;  /* Orange plus clair */
+            font-size: 1.2em !important;
+            border-bottom: 1px solid #FF4B4B;
+            padding-bottom: 5px;
+        }
+        
+        /* Textes des widgets */
+        .sidebar .stTextInput label, 
+        .sidebar .stFileUploader label {
+            color: #555555 !important;  /* Gris foncé */
+            font-weight: 500 !important;
+        }
+        
+        /* Texte des informations */
+        .sidebar .stMarkdown {
+            color: #777777 !important;  /* Gris moyen */
+        }
+    </style>
+    """, unsafe_allow_html=True)