Hieronder vind je een voorbeeld van een NumPy-functie die het K-means clustering algoritme implementeert op jouw dataset met 100 punten en 5 clusters. Ik zal ook enkele overwegingen geven voor efficiëntie, convergentie en valkuilen. Voorbeeldcode: ```python import numpy as np def kmeans_numpy(data, k=5, max_iters=300, tol=1e-4): """ Voert K-means clustering uit op de dataset. Parameters: data (np.ndarray): 2D-array met shape (100, n_features). k (int): Aantal clusters. max_iters (int): Maximum aantal iteraties. tol (float): Convergentiedrempel op basis van verandering in centroiden. Returns: labels (np.ndarray): Clusterlabels voor elk datapunt. centroids (np.ndarray): Eindpunten van de clusters. """ n_points, n_features = data.shape # Initializeer centroids door willekeurig data points te kiezen rng = np.random.default_rng() centroids = data[rng.choice(n_points, size=k, replace=False)] for i in range(max_iters): # Stap 1: Toewijzen van punten aan de dichtstbijzijnde centroid distances = np.linalg.norm(data[:, np.newaxis] - centroids, axis=2) labels = np.argmin(distances, axis=1) # Stap 2: Nieuwe centroids berekenen new_centroids = np.array([ data[labels == j].mean(axis=0) if np.any(labels == j) else centroids[j] for j in range(k) ]) # Convergentiecontrole shift = np.linalg.norm(new_centroids - centroids) if shift < tol: break centroids = new_centroids return labels, centroids ``` Overwegingen: 1. **Efficiëntie:** - Gebruik numpy-operaties om de afstandsberekeningen vectorized uit te voeren, wat snel is. - Initialiseer centroids willekeurig uit de dataset om goede startpunten te krijgen. - Vermijd herhaaldelijk loops over data punten. 2. **Convergentiecriteria:** - Stop na een maximum aantal iteraties of wanneer de verschuiving van centroiden onder een bepaalde drempel (`tol`) ligt. - Dit voorkomt oneindige lussen en zorgt voor voldoende convergentie. 3. **Valkuilen:** - **Lokale minima:** K-means convergeert soms niet naar de globale optimum; meerdere initialisaties kunnen helpen. - **Lege clusters:** Soms bevat een cluster geen punten (bijvoorbeeld bij kleine datasets). In het voorbeeld behouden we de oude centroid als dat gebeurt. - **Initialisatie:** Slechte initialisatie kan leiden tot slechte clusters; overweeg meerdere runs of geavanceerde methoden zoals k-means++. - **Dimensionaliteit:** Bij hoge dimensies kunnen afstanden minder onderscheidend zijn; overweeg normalisatie of standaardisatie. Gebruik deze functie door je dataset als volgt aan te roepen: ```python labels, centroids = kmeans_numpy(data, k=5) ``` Hiermee wordt jouw 2D-array met 100 punten geclusterd in 5 groepen.

Hier is een efficiënte implementatie van K-means clustering in NumPy voor jouw dataset: ```python import numpy as np import matplotlib.pyplot as plt def kmeans_clustering(X, k=5, max_iter=300, tol=1e-4): """ K-means clustering implementatie Parameters: X : numpy array (100, 2) - Jouw dataset met 100 2D-punten k : int (5) - Aantal clusters max_iter : int - Maximum aantal iteraties tol : float - Convergentie tolerantie Returns: centroids : numpy array (5, 2) - Cluster middelpunten labels : numpy array (100,) - Cluster labels voor elk punt """ n_samples, n_features = X.shape # 1. Initialisatie: Kies willekeurige startpunten np.random.seed(42) # Voor reproduceerbaarheid random_indices = np.random.choice(n_samples, k, replace=False) centroids = X[random_indices] # 2. K-means iteraties for iteration in range(max_iter): # a. Toewijzingsstap: Wijs punten toe aan dichtstbijzijnde centroid distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2) labels = np.argmin(distances, axis=1) # b. Update stap: Bereken nieuwe centroids new_centroids = np.array([X[labels == i].mean(axis=0) for i in range(k)]) # c. Convergentie check: Stop als centroids nauwelijks veranderen centroid_shift = np.linalg.norm(new_centroids - centroids) if centroid_shift < tol: print(f"Convergentie bereikt na {iteration + 1} iteraties") break centroids = new_centroids return centroids, labels # Voorbeeld gebruik met jouw dataset # X = np.random.randn(100, 2) # Jouw 100x2 dataset # centroids, labels = kmeans_clustering(X, k=5) ``` **Belangrijke overwegingen en valkuilen:** 1. **Initialisatie strategie:** - Willekeurige initialisatie kan leiden tot suboptimale resultaten - Overweeg K-means++ voor betere startpunten 2. **Convergentie criteria:** - `tol=1e-4`: Stop wanneer centroids minder dan 0.0001 verschuiven - `max_iter=300`: Voorkom oneindige loops 3. **Efficiëntie optimalisaties:** - Vectorisatie met NumPy (geen Python loops voor berekeningen) - Gebruik van broadcasting voor afstandsberekening 4. **Veiligheidsmaatregelen:** ```python # Voeg deze checks toe voor robuustheid def safe_kmeans(X, k=5): # Check op lege clusters if len(X) == 0: raise ValueError("Dataset mag niet leeg zijn") if k <= 0 or k > len(X): raise ValueError("Ongeldig aantal clusters") # Voorkom NaN values if np.any(np.isnan(X)): raise ValueError("Dataset bevat NaN values") return kmeans_clustering(X, k) ``` 5. **Verbeterde initialisatie (K-means++):** ```python def kmeans_plus_plus(X, k): n_samples = X.shape[0] centroids = [X[np.random.randint(n_samples)]] for _ in range(1, k): distances = np.array([min([np.linalg.norm(x - c)**2 for c in centroids]) for x in X]) probabilities = distances / distances.sum() cumulative_probs = probabilities.cumsum() r = np.random.rand() for j, p in enumerate(cumulative_probs): if r < p: centroids.append(X[j]) break return np.array(centroids) ``` **Praktische tips:** - Normaliseer je data als features verschillende schalen hebben - Herhaal het algoritme meerdere keren met verschillende initialisaties - Gebruik de elbow-methode om het optimale aantal clusters te bepalen - Check altijd op lege clusters in de implementatie Deze implementatie biedt een goede balans tussen efficiëntie, nauwkeurigheid en praktische bruikbaarheid voor jouw 100-punten dataset met 5 clusters.