Natuurlijk! Hier is een voorbeeld van hoe je de drie clustering algoritmen (KMeans, DBSCAN, AgglomerativeClustering) kunt implementeren en vergelijken in Python met Scikit-learn. Ik zal ook kort aangeven hoe je de resultaten kunt analyseren om de meest geschikte methode te kiezen. Stap 1: Voorbereiden van de data ```python import numpy as np import pandas as pd from sklearn.preprocessing import StandardScaler # Stel je data voor als een DataFrame # data = pd.read_csv('jouw_dataset.csv') # voorbeeld # Voorbeelddata (vervang dit door je eigen data) # data = pd.DataFrame({ # 'Leeftijd': [...], # 'Inkomen': [...], # 'AantalAankopen': [...], # ... # }) # Normaliseer de data scaler = StandardScaler() X_scaled = scaler.fit_transform(data) ``` Stap 2: KMeans clustering ```python from sklearn.cluster import KMeans kmeans = KMeans(n_clusters=3, random_state=42) kmeans_labels = kmeans.fit_predict(X_scaled) # Resultaten toevoegen aan je data data['KMeans_Cluster'] = kmeans_labels ``` Stap 3: DBSCAN clustering ```python from sklearn.cluster import DBSCAN # Parameters instellen; epsilon en min_samples kunnen worden geoptimaliseerd dbscan = DBSCAN(eps=0.5, min_samples=5) dbscan_labels = dbscan.fit_predict(X_scaled) # Resultaten toevoegen data['DBSCAN_Cluster'] = dbscan_labels ``` Stap 4: Agglomerative Clustering ```python from sklearn.cluster import AgglomerativeClustering agg = AgglomerativeClustering(n_clusters=3) agg_labels = agg.fit_predict(X_scaled) # Resultaten toevoegen data['Agglomerative_Cluster'] = agg_labels ``` Stap 5: Analyse van de clusteringresultaten - **Visualisatie**: gebruik bijvoorbeeld een PCA of t-SNE om de clusters te visualiseren. ```python from sklearn.decomposition import PCA import matplotlib.pyplot as plt pca = PCA(n_components=2) X_pca = pca.fit_transform(X_scaled) plt.figure(figsize=(12, 4)) # KMeans visueel plt.subplot(1, 3, 1) plt.scatter(X_pca[:,0], X_pca[:,1], c=kmeans_labels) plt.title('KMeans Clusters') # DBSCAN visueel plt.subplot(1, 3, 2) plt.scatter(X_pca[:,0], X_pca[:,1], c=dbscan_labels) plt.title('DBSCAN Clusters') # Agglomerative visueel plt.subplot(1, 3, 3) plt.scatter(X_pca[:,0], X_pca[:,1], c=agg_labels) plt.title('Agglomerative Clusters') plt.show() ``` - **Clustercijfers en interpretatie**: - Kijk naar de cohesie binnen clusters en de scheiding tussen clusters. - Voor KMeans en Agglomerative: controleer of de clusters logisch zijn en vergelijkbaar met je domeinkennis. - Voor DBSCAN: controleer of er veel noisepunten (-1 labels) zijn, wat kan duiden op dat de data niet goed in clusters te verdelen is. - **Metrics**: - Silhouette Score kan je helpen om de kwaliteit te meten (hoe hoger, hoe beter). ```python from sklearn.metrics import silhouette_score print('KMeans Silhouette:', silhouette_score(X_scaled, kmeans_labels)) print('DBSCAN Silhouette:', silhouette_score(X_scaled, dbscan_labels)) print('Agglomerative Silhouette:', silhouette_score(X_scaled, agg_labels)) ``` **Conclusie:** - Kies de clustering die de hoogste Silhouette Score heeft en waarvan de clusters het beste interpreteerbaar zijn binnen je domein. - Let op de aard van de data: DBSCAN is goed voor het ontdekken van niet-sferische clusters en het identificeren van ruis, terwijl KMeans en Agglomerative beter werken bij sferische clusters. Als je meer specifieke data of resultaten hebt, kan ik je verder helpen met een meer gerichte analyse!

Ik help je graag met het toepassen en vergelijken van clustering algoritmen in Scikit-learn. Hier is een complete implementatie en analyse: ## 1. Data Voorbereiding ```python import pandas as pd import numpy as np from sklearn.preprocessing import StandardScaler from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering from sklearn.metrics import silhouette_score, calinski_harabasz_score import matplotlib.pyplot as plt import seaborn as sns # Laad je dataset (voorbeeld) # df = pd.read_csv('marketing_data.csv') # Voorbeeld: aanmaken van demo-data np.random.seed(42) n_samples = 300 data = { 'leeftijd': np.random.normal(45, 15, n_samples), 'inkomen': np.random.normal(50000, 15000, n_samples), 'aankoop_frequentie': np.random.poisson(3, n_samples), 'totaal_besteding': np.random.normal(200, 50, n_samples) } df = pd.DataFrame(data) # Normaliseer de data scaler = StandardScaler() scaled_data = scaler.fit_transform(df) ``` ## 2. KMeans Implementatie ```python # KMeans clustering kmeans = KMeans(n_clusters=3, random_state=42, n_init=10) kmeans_labels = kmeans.fit_predict(scaled_data) # Evaluatie kmeans_silhouette = silhouette_score(scaled_data, kmeans_labels) kmeans_ch_score = calinski_harabasz_score(scaled_data, kmeans_labels) print(f"KMeans Silhouette Score: {kmeans_silhouette:.3f}") print(f"KMeans Calinski-Harabasz Score: {kmeans_ch_score:.3f}") ``` ## 3. DBSCAN Implementatie ```python # DBSCAN clustering dbscan = DBSCAN(eps=0.5, min_samples=5) dbscan_labels = dbscan.fit_predict(scaled_data) # Aantal clusters (exclusief noise points -1) n_clusters_dbscan = len(set(dbscan_labels)) - (1 if -1 in dbscan_labels else 0) # Alleen evalueren als er clusters zijn gevonden if n_clusters_dbscan > 1: # Filter noise points voor evaluatie non_noise_mask = dbscan_labels != -1 if sum(non_noise_mask) > 0: dbscan_silhouette = silhouette_score(scaled_data[non_noise_mask], dbscan_labels[non_noise_mask]) dbscan_ch_score = calinski_harabasz_score(scaled_data[non_noise_mask], dbscan_labels[non_noise_mask]) else: dbscan_silhouette = dbscan_ch_score = np.nan else: dbscan_silhouette = dbscan_ch_score = np.nan print(f"DBSCAN clusters: {n_clusters_dbscan}") print(f"DBSCAN Silhouette Score: {dbscan_silhouette if not np.isnan(dbscan_silhouette) else 'N/A'}") ``` ## 4. Agglomerative Clustering Implementatie ```python # Agglomerative Clustering agg_clustering = AgglomerativeClustering(n_clusters=3) agg_labels = agg_clustering.fit_predict(scaled_data) # Evaluatie agg_silhouette = silhouette_score(scaled_data, agg_labels) agg_ch_score = calinski_harabasz_score(scaled_data, agg_labels) print(f"Agglomerative Silhouette Score: {agg_silhouette:.3f}") print(f"Agglomerative Calinski-Harabasz Score: {agg_ch_score:.3f}") ``` ## 5. Vergelijkende Analyse ```python # Resultaten vergelijking results = { 'Algorithm': ['KMeans', 'DBSCAN', 'Agglomerative'], 'Silhouette_Score': [kmeans_silhouette, dbscan_silhouette, agg_silhouette], 'Calinski_Harabasz': [kmeans_ch_score, dbscan_ch_score, agg_ch_score], 'Clusters_Found': [3, n_clusters_dbscan, 3] } results_df = pd.DataFrame(results) print("\n=== VERGELIJKINGSCLUSTERINGSRESULTATEN ===") print(results_df) # Visualisatie fig, axes = plt.subplots(1, 3, figsize=(15, 5)) # KMeans visualisatie axes[0].scatter(scaled_data[:, 0], scaled_data[:, 1], c=kmeans_labels, cmap='viridis') axes[0].set_title(f'KMeans (Silhouette: {kmeans_silhouette:.3f})') # DBSCAN visualisatie axes[1].scatter(scaled_data[:, 0], scaled_data[:, 1], c=dbscan_labels, cmap='viridis') axes[1].set_title(f'DBSCAN (Clusters: {n_clusters_dbscan})') # Agglomerative visualisatie axes[2].scatter(scaled_data[:, 0], scaled_data[:, 1], c=agg_labels, cmap='viridis') axes[2].set_title(f'Agglomerative (Silhouette: {agg_silhouette:.3f})') plt.tight_layout() plt.show() ``` ## 6. Aanbeveling en Analyse Op basis van de resultaten: **KMeans:** - Goed voor bolvormige clusters - Snel en efficiënt - Werkt goed wanneer clusters even groot zijn **DBSCAN:** - Ontdekt clusters van willekeurige vorm - Identificeert outliers automatisch - Gevoelig voor parameterkeuze (eps, min_samples) **Agglomerative Clustering:** - Creëert hiërarchische clusterstructuur - Goed voor niet-bolvormige clusters - Meer rekenintensief **Aanbeveling:** Voor marketingdata met demografische kenmerken is **KMeans** vaak het meest geschikt vanwege: - Duidelijke clusterinterpretatie - Goede prestaties met gestandaardiseerde data - Eenvoudige implementatie Controleer altijd de clusterprofielen voor betekenisvolle interpretatie: ```python # Cluster analyse df['cluster'] = kmeans_labels cluster_profiles = df.groupby('cluster').mean() print(cluster_profiles) ``` Pas de parameters aan op basis van je specifieke dataset en gebruik domeinkennis om de clusters te interpreteren!