K-Means: zwaartepunten, toewijzing en update-stappen
Cursisten doorlopen drie iteraties van K-Means met de hand, wijzen punten toe aan de dichtstbijzijnde zwaartepunten, berekenen de zwaartepunten opnieuw en volgen de convergentie in een 2D-spreidingsdiagram.
K-Means: zwaartepunten, toewijzing en update-stappen is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat is K-Means-clustering?
K-Means is een algoritme voor leren zonder toezicht dat n datapunten verdeelt over k elkaar niet overlappende clusters. In tegenstelling tot leren met toezicht zijn er geen labels — het algoritme ontdekt structuren puur op basis van de waarden van de kenmerken. K-Means is snel, schaalbaar en wordt veel gebruikt voor klantsegmentatie, beeldcompressie en anomaliedetectie.
Het algoritme in drie stappen
K-Means herhaalt drie stappen totdat het convergeert: 1) Initialiseren — plaats willekeurig k zwaartepunten in de kenmerkenruimte. 2) Toewijzen — wijs elk punt toe aan het dichtstbijzijnde zwaartepunt. 3) Bijwerken — verplaats elk zwaartepunt naar het gemiddelde van de eraan toegewezen punten. De lus stopt wanneer de toewijzingen niet meer veranderen.
Afstand tot zwaartepunten berekenen
Bij elke toewijzingsstap wordt de Euclidische afstand van elk punt tot elk zwaartepunt berekend. Een punt wordt toegewezen aan het zwaartepunt met de kleinste afstand. Voor een punt x en zwaartepunt c is de gekwadrateerde afstand sum((x_i - c_i)^2). Door de gekwadrateerde afstand te gebruiken vermijd je de dure vierkantswortel en krijg je dezelfde volgorde.
import numpy as np
def assign_clusters(X, centroids):
# X: (n, d), centroids: (k, d)
distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2) # (n, k)
return np.argmin(distances, axis=1) # label for each point
X = np.array([[1, 2], [3, 4], [5, 6], [8, 8]])
centroids = np.array([[2, 2], [7, 7]])
labels = assign_clusters(X, centroids)
print(labels) # [0, 0, 0, 1]De bijwerkstap: zwaartepunten opnieuw berekenen
Na de toewijzing wordt elk zwaartepunt verplaatst naar het rekenkundig gemiddelde van alle punten die momenteel in het cluster zitten. Als een cluster leeg raakt (er zijn geen punten aan toegewezen), wordt het zwaartepunt meestal opnieuw willekeurig geïnitialiseerd of verwijderd. Deze verschuiving naar het gemiddelde minimaliseert de totale som van gekwadrateerde afstanden binnen clusters (WCSS) — ook wel inertie genoemd.
import numpy as np
def update_centroids(X, labels, k):
d = X.shape[1]
new_centroids = np.zeros((k, d))
for c in range(k):
points = X[labels == c]
if len(points) > 0:
new_centroids[c] = points.mean(axis=0)
return new_centroids
X = np.array([[1, 2], [3, 4], [5, 6], [8, 8]])
labels = np.array([0, 0, 0, 1])
print(update_centroids(X, labels, k=2))Convergentie met de hand volgen
Bekijk vier eendimensionale punten: 1, 2, 8, 9 en k=2. Initialisatie: zwaartepunten = [1, 8]. Toewijzing in iteratie 1: 1→C0, 2→C0, 8→C1, 9→C1. Bijwerken in iteratie 1: C0=1.5, C1=8.5. Toewijzing in iteratie 2: onveranderd. Geconvergeerd in 2 iteraties! In hogere dimensies kan de convergentie meer stappen kosten, maar de logica is identiek.
Inertie: compactheid van clusters meten
Inertie (WCSS) is de som van de gekwadrateerde afstanden tussen elk punt en het zwaartepunt van zijn cluster. Een lagere inertie betekent strakkere, compactere clusters. K-Means minimaliseert de inertie bij elke bijwerkstap, maar het algoritme vindt niet gegarandeerd het globale minimum — afhankelijk van de initialisatie kan het vastlopen in lokale optima.
from sklearn.cluster import KMeans
import numpy as np
X = np.array([[1, 2], [1, 4], [1, 0],
[10, 2], [10, 4], [10, 0]])
km = KMeans(n_clusters=2, random_state=42)
km.fit(X)
print('Inertia:', km.inertia_)
print('Labels:', km.labels_)
print('Centroids:', km.cluster_centers_)K-Means++-initialisatie
Een willekeurige initialisatie van zwaartepunten leidt vaak tot trage convergentie of slechte lokale optima. K-Means++ (de standaardinstelling van scikit-learn via init='k-means++') kiest de zwaartepunten op een slimmere manier: het eerste zwaartepunt wordt willekeurig gekozen en elk volgend zwaartepunt wordt geselecteerd met een kans die evenredig is aan de gekwadrateerde afstand tot het dichtstbijzijnde al gekozen zwaartepunt. Hierdoor worden de startpunten beter verspreid en worden consequent betere oplossingen gevonden.
from sklearn.cluster import KMeans
import numpy as np
X = np.random.randn(300, 2)
# Default: k-means++ initialisation
km = KMeans(n_clusters=3, init='k-means++', n_init=10, random_state=0)
km.fit(X)
print('Inertia with k-means++:', round(km.inertia_, 2))
# Compare with random init
km_rand = KMeans(n_clusters=3, init='random', n_init=10, random_state=0)
km_rand.fit(X)
print('Inertia with random init:', round(km_rand.inertia_, 2))Clustertoewijzingen visualiseren
Als je clustertoewijzingen in een tweedimensionale spreidingsgrafiek tekent, zie je de Voronoi-verdeling — de beslissingsgrenzen waar het dichtstbijzijnde zwaartepunt van een punt verandert. Door zwaartepunten als grote sterren te tekenen en punten in te kleuren op basis van hun clusterlabel, wordt convergentie intuïtief. Deze visualisatie laat ook zien wanneer clusters overlappen of verschillende groottes hebben.
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
X, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.6, random_state=0)
km = KMeans(n_clusters=3, random_state=0)
labels = km.fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='tab10', s=30)
plt.scatter(km.cluster_centers_[:, 0], km.cluster_centers_[:, 1],
c='black', s=200, marker='*', label='Centroids')
plt.legend()
plt.title('K-Means Clusters')
plt.show()Meerdere herstarts en n_init
Omdat K-Means naar lokale optima kan convergeren, voert scikit-learn het algoritme n_init keer uit met verschillende willekeurige seeds en behoudt het resultaat met de laagste inertie. De standaardwaarde is n_init=10. Voor kleine gegevenssets zijn 10 uitvoeringen meestal voldoende; voor grote of lastige gegevenssets kun je dit verhogen naar 20 of 50. Controleer altijd de uiteindelijke inertie ten opzichte van de beste inertie uit de afzonderlijke uitvoeringen om slechte convergentie op te sporen.
from sklearn.cluster import KMeans
import numpy as np
X = np.random.randn(500, 5)
km = KMeans(n_clusters=4, n_init=20, random_state=0)
km.fit(X)
print('Best inertia over 20 runs:', round(km.inertia_, 2))
print('Number of iterations until convergence:', km.n_iter_)Beperkingen van K-Means
K-Means heeft verschillende bekende zwakke punten: 1) Het gaat uit van bolvormige clusters — langgerekte of sikkelvormige structuren zijn lastig. 2) Het is gevoelig voor uitschieters — een ver weg gelegen uitschieter trekt het zwaartepunt weg van het werkelijke clustergemiddelde. 3) k moet vooraf worden opgegeven — je moet het aantal clusters kennen of schatten voordat je het model fit. 4) De schaal van kenmerken is belangrijk — standaardiseer kenmerken altijd voordat je K-Means uitvoert, zodat variabelen met grote waarden de afstanden niet overheersen.
K-Means uitvoeren met scikit-learn
In de praktijk is het gebruik van sklearn.cluster.KMeans de standaardaanpak. Belangrijke parameters zijn: n_clusters (k), init (standaard 'k-means++'), n_init, max_iter (standaard 300) en random_state. Na het fitten bevat km.labels_ de clustertoewijzingen, bevat km.cluster_centers_ de posities van de zwaartepunten en rapporteert km.inertia_ de WCSS.
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
X, _ = load_iris(return_X_y=True)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
km = KMeans(n_clusters=3, random_state=42)
km.fit(X_scaled)
print('Cluster sizes:', {i: (km.labels_ == i).sum() for i in range(3)})
print('Inertia:', round(km.inertia_, 2))Korte toets
Toets je begrip van de concepten rond K-Means-clustering uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat K-Means de stappen voor toewijzing en bijwerken herhaalt totdat de clustertoewijzingen stabiel zijn, dat inertie (WCSS) de compactheid meet en bij elke bijwerkstap wordt geminimaliseerd, en dat K-Means++-initialisatie en meerdere herstarts helpen om slechte lokale optima te vermijden. Hierna bekijken we hoe je de juiste waarde van k kiest met de elleboogmethode en de silhouetscore.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “K-Means: zwaartepunten, toewijzing en update-stappen” gratis?
Ja — de volledige tekst van “K-Means: zwaartepunten, toewijzing en update-stappen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat leer ik in “K-Means: zwaartepunten, toewijzing en update-stappen”?
Cursisten doorlopen drie iteraties van K-Means met de hand, wijzen punten toe aan de dichtstbijzijnde zwaartepunten, berekenen de zwaartepunten opnieuw en volgen de convergentie in een 2D-spreidingsd… Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Machine Learning Academy te beginnen?
Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “K-Means: zwaartepunten, toewijzing en update-stappen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?
Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- K-Means: zwaartepunten, toewijzing en update-stappen
- K kiezen: elleboogmethode en silhouetscore
- DBSCAN: kernpunten, randpunten en ruis
- Clustering voor klantsegmentatie: een end-to-endvoorbeeld