Update app.py

app.py

@@ -100,6 +100,175 @@ def plot_feature_importance(model, feature_names, model_type):
     plt.title(f"Feature Importance - {model_type}")
     return plt.gcf()
 
+def prepare_clustering_data(data, numeric_columns):
+    scaler = StandardScaler()
+    scaled_features = scaler.fit_transform(data[numeric_columns])
+    return scaled_features, scaler
+
+def perform_clustering(scaled_features, n_clusters):
+    kmeans = KMeans(n_clusters=n_clusters, random_state=42)
+    cluster_labels = kmeans.fit_predict(scaled_features)
+    return kmeans, cluster_labels
+
+def plot_clusters_3d(data, labels, features, product_category):
+    pca = PCA(n_components=3)
+    components = pca.fit_transform(data)
+    
+    df_plot = pd.DataFrame({
+        'PC1': components[:, 0],
+        'PC2': components[:, 1],
+        'PC3': components[:, 2],
+        'Cluster': [f"Groupe {i}" for i in labels]
+    })
+    
+    fig = px.scatter_3d(
+        df_plot,
+        x='PC1',
+        y='PC2',
+        z='PC3',
+        color='Cluster',
+        title=f'Analyse des sous-groupes pour {product_category}',
+        labels={
+            'PC1': 'Composante 1',
+            'PC2': 'Composante 2',
+            'PC3': 'Composante 3'
+        }
+    )
+    
+    fig.update_layout(
+        scene=dict(
+            xaxis_title='Composante 1',
+            yaxis_title='Composante 2',
+            zaxis_title='Composante 3'
+        ),
+        legend_title_text='Sous-groupes'
+    )
+    
+    return fig
+
+def analyze_clusters(data, cluster_labels, numeric_columns, product_category):
+    data_with_clusters = data.copy()
+    data_with_clusters['Cluster'] = cluster_labels
+    
+    cluster_stats = []
+    for cluster in range(len(np.unique(cluster_labels))):
+        cluster_data = data_with_clusters[data_with_clusters['Cluster'] == cluster]
+        stats = {
+            'Cluster': cluster,
+            'Taille': len(cluster_data),
+            'Product': product_category,
+            'Caractéristiques principales': {}
+        }
+        
+        for col in numeric_columns:
+            stats['Caractéristiques principales'][col] = cluster_data[col].mean()
+        
+        cluster_stats.append(stats)
+    
+    return cluster_stats
+
+def add_clustering_analysis(data):
+    st.header("Analyse par Clustering des Produits Acceptés")
+    
+    if data is None:
+        st.error("Veuillez charger des données pour l'analyse")
+        return
+        
+    # Filtrer uniquement les clients ayant accepté un produit
+    accepted_data = data[data['ProdTaken'] == 1]
+    
+    if len(accepted_data) == 0:
+        st.error("Aucune donnée trouvée pour les produits acceptés")
+        return
+        
+    st.write(f"Nombre total de produits acceptés: {len(accepted_data)}")
+    
+    # Obtenir les différents types de produits proposés
+    product_types = accepted_data['ProductPitched'].unique()
+    st.write(f"Types de produits disponibles: {', '.join(product_types)}")
+    
+    # Sélection des caractéristiques pour le clustering
+    numeric_columns = st.multiselect(
+        "Sélectionner les caractéristiques pour l'analyse",
+        data.select_dtypes(include=['float64', 'int64']).columns,
+        help="Choisissez les caractéristiques numériques pertinentes pour l'analyse"
+    )
+    
+    if numeric_columns:
+        for product in product_types:
+            st.subheader(f"\nAnalyse du produit: {product}")
+            
+            product_data = accepted_data[accepted_data['ProductPitched'] == product]
+            st.write(f"Nombre de clients ayant accepté ce produit: {len(product_data)}")
+            
+            max_clusters = min(len(product_data) - 1, 10)
+            if max_clusters < 2:
+                st.warning(f"Pas assez de données pour le clustering du produit {product}")
+                continue
+            
+            n_clusters = st.slider(
+                f"Nombre de sous-groupes pour {product}", 
+                2, max_clusters, 
+                min(3, max_clusters),
+                key=f"slider_{product}"
+            )
+            
+            scaled_features, _ = prepare_clustering_data(product_data, numeric_columns)
+            kmeans, cluster_labels = perform_clustering(scaled_features, n_clusters)
+            
+            silhouette_avg = silhouette_score(scaled_features, cluster_labels)
+            st.write(f"Score de silhouette: {silhouette_avg:.3f}")
+            
+            fig = plot_clusters_3d(scaled_features, cluster_labels, numeric_columns, product)
+            st.plotly_chart(fig)
+            
+            st.write("### Caractéristiques des sous-groupes")
+            cluster_stats = analyze_clusters(product_data, cluster_labels, numeric_columns, product)
+            
+            global_means = product_data[numeric_columns].mean()
+            
+            for stats in cluster_stats:
+                st.write(f"\n**Sous-groupe {stats['Cluster']} ({stats['Taille']} clients)**")
+                
+                comparison_data = []
+                for feat, value in stats['Caractéristiques principales'].items():
+                    global_mean = global_means[feat]
+                    diff_percent = ((value - global_mean) / global_mean * 100)
+                    comparison_data.append({
+                        'Caractéristique': feat,
+                        'Valeur moyenne du groupe': f"{value:.2f}",
+                        'Moyenne globale': f"{global_mean:.2f}",
+                        'Différence (%)': f"{diff_percent:+.1f}%"
+                    })
+                
+                comparison_df = pd.DataFrame(comparison_data)
+                st.table(comparison_df)
+                
+                st.write("### Recommandations marketing")
+                distinctive_features = []
+                for col in numeric_columns:
+                    cluster_mean = product_data[cluster_labels == stats['Cluster']][col].mean()
+                    global_mean = product_data[col].mean()
+                    diff_percent = ((cluster_mean - global_mean) / global_mean * 100)
+                    
+                    if abs(diff_percent) > 10:
+                        distinctive_features.append({
+                            'feature': col,
+                            'diff': diff_percent,
+                            'value': cluster_mean
+                        })
+                
+                if distinctive_features:
+                    recommendations = [
+                        f"- Groupe avec {feat['feature']} {'supérieur' if feat['diff'] > 0 else 'inférieur'} " \
+                        f"à la moyenne ({feat['diff']:+.1f}%)"
+                        for feat in distinctive_features
+                    ]
+                    st.write("\n".join(recommendations))
+                else:
+                    st.write("- Pas de caractéristiques fortement distinctives identifiées")
+
+
 def app():
     st.title("Interpréteur de Modèles ML")
     
@@ -123,7 +292,8 @@ def app():
         ["Performance des modèles", 
          "Interprétation du modèle", 
          "Analyse des caractéristiques",
-         "Simulateur de prédictions"]
+         "Simulateur de prédictions",
+        "Analyse par Clustering"]
     )
     
     current_model = st.session_state.model_results[selected_model]['model']
@@ -195,6 +365,16 @@ def app():
         fig, ax = plt.subplots(figsize=(10, 8))
         sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0)
         st.pyplot(fig)
+        
+    elif page == "Analyse par Clustering":
+        # Charger les données pour le clustering
+        uploaded_file = st.file_uploader("Charger les données pour le clustering (CSV)", type="csv")
+        if uploaded_file is not None:
+            data = pd.read_csv(uploaded_file)
+            add_clustering_analysis(data)
+        else:
+            st.warning("Veuillez charger un fichier CSV pour l'analyse par clustering")
+
     
     # Simulateur de prédictions
     else: