K-betekent clustering is een Machine learning zonder toezicht algoritme, dat de ongelabelde dataset in verschillende clusters groepeert. Het artikel heeft tot doel de fundamenten en werking van k mean clustering te onderzoeken, samen met de implementatie ervan.
Inhoudsopgave
- Wat is K-means clustering?
- Wat is het doel van k-means-clustering?
- Hoe k-means-clustering werkt?
- Implementatie van K-Means Clustering in Python
Wat is K-means clustering?
Machine learning zonder toezicht is het proces waarbij een computer wordt geleerd ongelabelde, niet-geclassificeerde gegevens te gebruiken en het algoritme in staat wordt gesteld zonder toezicht met die gegevens te werken. Zonder voorafgaande datatraining is het in dit geval de taak van de machine om ongesorteerde data te ordenen op basis van parallellen, patronen en variaties.
K betekent clustering, wijst datapunten toe aan een van de K-clusters, afhankelijk van hun afstand tot het midden van de clusters. Het begint met het willekeurig toewijzen van het zwaartepunt van de clusters in de ruimte. Vervolgens wordt elk datapunt toegewezen aan een van de clusters op basis van de afstand tot het zwaartepunt van de cluster. Nadat elk punt aan een van de clusters is toegewezen, worden nieuwe clusterzwaartepunten toegewezen. Dit proces wordt iteratief uitgevoerd totdat het een goed cluster vindt. In de analyse gaan we ervan uit dat het aantal clusters vooraf wordt opgegeven en dat we punten in een van de groepen moeten plaatsen.
In sommige gevallen is K niet duidelijk gedefinieerd en moeten we nadenken over het optimale aantal K. K Betekent dat clustering het beste presteert, gegevens zijn goed gescheiden. Wanneer gegevenspunten elkaar overlappen, is deze clustering niet geschikt. K Means is sneller in vergelijking met andere clustertechnieken. Het zorgt voor een sterke koppeling tussen de datapunten. K Middelclusters geven geen duidelijke informatie over de kwaliteit van clusters. Een verschillende initiële toewijzing van het clusterzwaartepunt kan tot verschillende clusters leiden. Bovendien is het K Means-algoritme gevoelig voor ruis. Het kan zijn dat het in lokale minima is blijven steken.
Wat is het doel van k-means-clustering?
Het doel van clustering is om de bevolking te verdelen of set van datapunten in een aantal groepen, zodat de datapunten binnen elke groep groter zijn vergelijkbaar met elkaar en verschillend van de datapunten binnen de andere groepen. Het is in wezen een groep dingen op basis van hoe vergelijkbaar en verschillend ze met elkaar zijn.
Hoe k-means-clustering werkt?
We krijgen een dataset van items, met bepaalde kenmerken, en waarden voor deze kenmerken (zoals een vector). De taak is om deze items in groepen te categoriseren. Om dit te bereiken zullen we het K-means-algoritme gebruiken, een leeralgoritme zonder toezicht. ‘K’ in de naam van het algoritme vertegenwoordigt het aantal groepen/clusters waarin we onze items willen classificeren.
(Het helpt als je items beschouwt als punten in een n-dimensionale ruimte). Het algoritme categoriseert de items in k groepen of clusters van gelijkenis. Om die gelijkenis te berekenen, zullen we de Euclidische afstand als maatstaf gebruiken.
Het algoritme werkt als volgt:
- Eerst initialiseren we willekeurig k punten, middelen of clusterzwaartepunten genoemd.
- We categoriseren elk item op basis van het dichtstbijzijnde gemiddelde, en we werken de coördinaten van het gemiddelde bij, wat de gemiddelden zijn van de items die tot nu toe in dat cluster zijn gecategoriseerd.
- We herhalen het proces voor een bepaald aantal iteraties en aan het einde hebben we onze clusters.
De hierboven genoemde punten worden gemiddelden genoemd omdat ze de gemiddelde waarden zijn van de items die erin zijn gecategoriseerd. Om deze middelen te initialiseren, hebben we veel opties. Een intuïtieve methode is om de middelen op willekeurige items in de dataset te initialiseren. Een andere methode is om de gemiddelden te initialiseren op willekeurige waarden tussen de grenzen van de dataset (indien voor een feature X, de items hebben waarden in [0,3], we zullen de gemiddelden initialiseren met waarden voor X bij [0,3]).
Het bovenstaande algoritme in pseudocode is als volgt:
Initialize k means with random values -->Voor een bepaald aantal iteraties: --> Doorloop items: --> Zoek het gemiddelde dat het dichtst bij het item ligt door de euclidische afstand van het item met elk van de gemiddelden te berekenen --> Wijs item toe aan gemiddelde --> Update gemiddelde door verschuiven naar het gemiddelde van de items in dat cluster>
Implementatie van K-Means Clustering in Python
voorbeeld 1
Importeer de benodigde bibliotheken
Wij zijn aan het importeren Numpy voor statistische berekeningen, Matplotlib om de te plotten grafiek, en make_blobs van sklearn.datasets.
Python3
reeks van array in c
import> numpy as np> import> matplotlib.pyplot as plt> from> sklearn.datasets>import> make_blobs> |
>
>
Maak de aangepaste gegevensset met make_blobs en plot deze
Python3
X,y>=> make_blobs(n_samples>=> 500>,n_features>=> 2>,centers>=> 3>,random_state>=> 23>)> fig>=> plt.figure(>0>)> plt.grid(>True>)> plt.scatter(X[:,>0>],X[:,>1>])> plt.show()> |
>
>
Uitvoer :
Dataset clusteren
Initialiseer de willekeurige zwaartepunten
De code initialiseert drie clusters voor K-means-clustering. Het stelt een willekeurig zaad in en genereert willekeurige clustercentra binnen een gespecificeerd bereik, en creëert een leeg lijst punten per cluster.
Python3
k>=> 3> clusters>=> {}> np.random.seed(>23>)> for> idx>in> range>(k):> >center>=> 2>*>(>2>*>np.random.random((X.shape[>1>],))>->1>)> >points>=> []> >cluster>=> {> >'center'> : center,> >'points'> : []> >}> > >clusters[idx]>=> cluster> > clusters> |
>
>
Uitgang:
{0: {'center': array([0.06919154, 1.78785042]), 'points': []}, 1: {'center': array([ 1.06183904, -0.87041662]), 'points': []}, 2: {'center': array([-1.11581855, 0.74488834]), 'points': []}}> Teken het willekeurige initialisatiecentrum met gegevenspunten
Python3
plt.scatter(X[:,>0>],X[:,>1>])> plt.grid(>True>)> for> i>in> clusters:> >center>=> clusters[i][>'center'>]> >plt.scatter(center[>0>],center[>1>],marker>=> '*'>,c>=> 'red'>)> plt.show()> |
>
>
Uitvoer :
Gegevenspunten met willekeurig midden
De plot toont een spreidingsdiagram van gegevenspunten (X[:,0], X[:,1]) met rasterlijnen. Het markeert ook de initiële clustercentra (rode sterren) die zijn gegenereerd voor K-means-clustering.
Definieer de Euclidische afstand
Python3
def> distance(p1,p2):> >return> np.sqrt(np.>sum>((p1>->p2)>*>*>2>))> |
>
>
Maak de functie om het clustercentrum toe te wijzen en bij te werken
De E-stap wijst datapunten toe aan het dichtstbijzijnde clustercentrum, en de M-stap werkt clustercentra bij op basis van het gemiddelde van toegewezen punten in K-means-clustering.
verbinding krijgen
Python3
#Implementing E step> def> assign_clusters(X, clusters):> >for> idx>in> range>(X.shape[>0>]):> >dist>=> []> > >curr_x>=> X[idx]> > >for> i>in> range>(k):> >dis>=> distance(curr_x,clusters[i][>'center'>])> >dist.append(dis)> >curr_cluster>=> np.argmin(dist)> >clusters[curr_cluster][>'points'>].append(curr_x)> >return> clusters> > #Implementing the M-Step> def> update_clusters(X, clusters):> >for> i>in> range>(k):> >points>=> np.array(clusters[i][>'points'>])> >if> points.shape[>0>]>>0>:> >new_center>=> points.mean(axis>=>0>)> >clusters[i][>'center'>]>=> new_center> > >clusters[i][>'points'>]>=> []> >return> clusters> |
>
>
Stap 7: Maak de functie om het cluster voor de datapunten te voorspellen
Python3
def> pred_cluster(X, clusters):> >pred>=> []> >for> i>in> range>(X.shape[>0>]):> >dist>=> []> >for> j>in> range>(k):> >dist.append(distance(X[i],clusters[j][>'center'>]))> >pred.append(np.argmin(dist))> >return> pred> |
>
shweta tiwari
>
Wijs het clustercentrum toe, update het en voorspel het
Python3
clusters>=> assign_clusters(X,clusters)> clusters>=> update_clusters(X,clusters)> pred>=> pred_cluster(X,clusters)> |
>
>
Zet de gegevenspunten uit met hun voorspelde clustercentrum
Python3
plt.scatter(X[:,>0>],X[:,>1>],c>=> pred)> for> i>in> clusters:> >center>=> clusters[i][>'center'>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.show()> |
>
>
Uitvoer :
K-betekent Clustering
De grafiek toont gegevenspunten gekleurd door hun voorspelde clusters. De rode markeringen vertegenwoordigen de bijgewerkte clustercentra na de E-M-stappen in het K-means clusteralgoritme.
Voorbeeld 2
Importeer de benodigde bibliotheken
Python3
import> pandas as pd> import> numpy as np> import> seaborn as sns> import> matplotlib.pyplot as plt> import> matplotlib.cm as cm> from> sklearn.datasets>import> load_iris> from> sklearn.cluster>import> KMeans> |
>
>
Laad de gegevensset
Python3
X, y>=> load_iris(return_X_y>=>True>)> |
bash slaap
>
>
Elleboog Methode
Het vinden van het ideale aantal groepen om de gegevens in te verdelen is een basisfase in elk algoritme zonder toezicht. Een van de meest gebruikelijke technieken om deze ideale waarde van k te achterhalen, is de elleboogbenadering.
Python3
#Find optimum number of cluster> sse>=> []>#SUM OF SQUARED ERROR> for> k>in> range>(>1>,>11>):> >km>=> KMeans(n_clusters>=>k, random_state>=>2>)> >km.fit(X)> >sse.append(km.inertia_)> |
>
>
Teken de Ellebooggrafiek om het optimale aantal clusters te vinden
Python3
sns.set_style(>'whitegrid'>)> g>=>sns.lineplot(x>=>range>(>1>,>11>), y>=>sse)> g.>set>(xlabel>=>'Number of cluster (k)'>,> >ylabel>=> 'Sum Squared Error'>,> >title>=>'Elbow Method'>)> plt.show()> |
>
>
Uitgang:
Elleboog Methode
Uit de bovenstaande grafiek kunnen we zien dat bij k=2 en k=3 een elleboogachtige situatie bestaat. We beschouwen dus K=3
Bouw het Kmeans-clustermodel
Python3
kmeans>=> KMeans(n_clusters>=> 3>, random_state>=> 2>)> kmeans.fit(X)> |
>
>
Uitgang:
KMeans KMeans(n_clusters=3, random_state=2)>
Zoek het clustercentrum
Python3
jvm in Java
kmeans.cluster_centers_> |
>
>
Uitgang:
array([[5.006 , 3.428 , 1.462 , 0.246 ], [5.9016129 , 2.7483871 , 4.39354839, 1.43387097], [6.85 , 3.07368421, 5.74210526, 2.07105263]])>
Voorspel de clustergroep:
Python3
pred>=> kmeans.fit_predict(X)> pred> |
>
>
Uitgang:
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 1], dtype=int32)>
Teken het clustercentrum met datapunten
Python3
plt.figure(figsize>=>(>12>,>5>))> plt.subplot(>1>,>2>,>1>)> plt.scatter(X[:,>0>],X[:,>1>],c>=> pred, cmap>=>cm.Accent)> plt.grid(>True>)> for> center>in> kmeans.cluster_centers_:> >center>=> center[:>2>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.xlabel(>'petal length (cm)'>)> plt.ylabel(>'petal width (cm)'>)> > plt.subplot(>1>,>2>,>2>)> plt.scatter(X[:,>2>],X[:,>3>],c>=> pred, cmap>=>cm.Accent)> plt.grid(>True>)> for> center>in> kmeans.cluster_centers_:> >center>=> center[>2>:>4>]> >plt.scatter(center[>0>],center[>1>],marker>=> '^'>,c>=> 'red'>)> plt.xlabel(>'sepal length (cm)'>)> plt.ylabel(>'sepal width (cm)'>)> plt.show()> |
>
>
Uitgang:
K-betekent clustering
De subplot aan de linkerkant geeft de lengte van de bloembladen versus de breedte van de bloembladen weer, waarbij gegevenspunten gekleurd door clusters zijn, en rode markeringen geven K-gemiddelde clustercentra aan. De subplot aan de rechterkant toont de kelkbladlengte versus de kelkbladbreedte op dezelfde manier.
Conclusie
Concluderend is K-means clustering een krachtig machine learning-algoritme zonder toezicht voor het groeperen van ongelabelde datasets. Het doel is om gegevens in clusters te verdelen, waardoor vergelijkbare gegevenspunten deel uitmaken van dezelfde groep. Het algoritme initialiseert clusterzwaartepunten en wijst iteratief gegevenspunten toe aan het dichtstbijzijnde zwaartepunt, waarbij de zwaartepunten worden bijgewerkt op basis van het gemiddelde van de punten in elk cluster.
Veelgestelde vragen (FAQ's)
1. Wat is k-means clustering voor data-analyse?
K-means is een partitiemethode die een dataset verdeelt in ‘k’ verschillende, niet-overlappende subsets (clusters) op basis van gelijkenis, met als doel de variantie binnen elk cluster te minimaliseren.
2.Wat is een voorbeeld van k-means in het echte leven?
Klantsegmentatie in marketing, waarbij k-means klanten groepeert op basis van koopgedrag, waardoor bedrijven marketingstrategieën kunnen afstemmen op verschillende segmenten.
3. Welk type gegevens is het k-means clusteringmodel?
K-means werkt goed met numerieke gegevens, waarbij het concept van afstand tussen gegevenspunten zinvol is. Het wordt vaak toegepast op continue variabelen.
4. Worden K-middelen gebruikt voor voorspellingen?
K-means wordt voornamelijk gebruikt voor het clusteren en groeperen van vergelijkbare datapunten. Het voorspelt geen labels voor nieuwe gegevens; het wijst ze toe aan bestaande clusters op basis van gelijkenis.
5.Wat is het doel van k-means-clustering?
Het doel is om gegevens in ‘k’-clusters te verdelen, waardoor de variantie binnen de cluster wordt geminimaliseerd. Het probeert groepen te vormen waarin datapunten binnen elke cluster meer op elkaar lijken dan op die in andere clusters.