Klastrowanie K-średnich jest Uczenie maszynowe bez nadzoru algorytm, który grupuje nieoznakowany zbiór danych w różne klastry. Celem artykułu jest zbadanie podstaw i działania grupowania k średnich wraz z implementacją.
Spis treści
- Co to jest grupowanie K-średnich?
- Jaki jest cel grupowania k-średnich?
- Jak działa grupowanie k-średnich?
- Implementacja klastrowania K-średnich w Pythonie
Co to jest grupowanie K-średnich?
Uczenie maszynowe bez nadzoru to proces uczenia komputera korzystania z nieoznaczonych, niesklasyfikowanych danych i umożliwiania algorytmowi działania na tych danych bez nadzoru. Bez żadnego wcześniejszego uczenia danych zadaniem maszyny w tym przypadku jest organizowanie nieposortowanych danych według podobieństw, wzorców i odmian.
K oznacza grupowanie, przypisuje punkty danych do jednego z K klastrów w zależności od ich odległości od centrum klastrów. Rozpoczyna się od losowego przypisania środka ciężkości klastrów w przestrzeni. Następnie każdy punkt danych jest przypisywany do jednego z klastrów na podstawie jego odległości od środka ciężkości klastra. Po przypisaniu każdego punktu do jednego ze skupień przypisywane są nowe centroidy skupień. Proces ten przebiega iteracyjnie, dopóki nie znajdzie dobrego klastra. W analizie zakładamy, że numer skupienia jest podany z wyprzedzeniem i musimy umieścić punkty w jednym z grup.
W niektórych przypadkach K nie jest jasno zdefiniowane i musimy pomyśleć o optymalnej liczbie K. K oznacza, że klastrowanie sprawdza się najlepiej, gdy dane są dobrze oddzielone. Kiedy punkty danych nakładają się na siebie, takie grupowanie nie jest odpowiednie. K Means jest szybszy w porównaniu do innych technik grupowania. Zapewnia silne sprzężenie pomiędzy punktami danych. Klaster K Means nie dostarcza jednoznacznych informacji na temat jakości skupień. Różne początkowe przypisanie środka ciężkości klastrów może prowadzić do różnych klastrów. Algorytm K Means jest także wrażliwy na szum. Być może utknął w lokalnych minimach.
Jaki jest cel grupowania k-średnich?
Celem grupowanie jest podzielenie populacji lub ustawić punktów danych na kilka grup, tak aby punktów danych w każdej grupie było więcej porównywalny między sobą i różnią się od punktów danych w innych grupach. Zasadniczo jest to grupowanie rzeczy na podstawie tego, jak bardzo są do siebie podobne i różne.
Jak działa grupowanie k-średnich?
Otrzymujemy zbiór danych elementów z określonymi cechami i wartościami tych cech (jak wektor). Zadanie polega na podzieleniu tych elementów na grupy. Aby to osiągnąć, użyjemy algorytmu K-średnich, algorytmu uczenia się bez nadzoru. „K” w nazwie algorytmu oznacza liczbę grup/klastrów, do których chcemy zaklasyfikować nasze elementy.
(Pomocne będzie, jeśli pomyślisz o przedmiotach jak o punktach w przestrzeni n-wymiarowej). Algorytm podzieli elementy na k grup lub klastrów podobieństwa. Aby obliczyć to podobieństwo, jako miarę użyjemy odległości euklidesowej.
Algorytm działa w następujący sposób:
- Najpierw losowo inicjujemy k punktów, zwanych średnimi lub centroidami klastrów.
- Kategoryzujemy każdą pozycję według najbliższej średniej i aktualizujemy współrzędne średniej, które są średnimi pozycjami sklasyfikowanymi dotychczas w tym skupieniu.
- Proces powtarzamy przez określoną liczbę iteracji i na koniec mamy swoje klastry.
Punkty wspomniane powyżej nazywane są średnimi, ponieważ są średnimi wartościami pozycji w nich sklasyfikowanych. Aby zainicjować te środki, mamy wiele opcji. Intuicyjna metoda polega na inicjalizacji średnich na losowych elementach zbioru danych. Inną metodą jest inicjalizacja średnich przy losowych wartościach pomiędzy granicami zbioru danych (jeśli dla funkcji X, pozycje mają wartości w [0,3], zainicjujemy średnie wartościami for X przy [0,3]).
Powyższy algorytm w pseudokodzie wygląda następująco:
Initialize k means with random values -->Dla danej liczby iteracji: --> Iteruj po elementach: --> Znajdź średnią najbliższą elementowi, obliczając odległość euklidesową elementu za pomocą każdej ze średnich --> Przypisz elementowi znaczenie --> Aktualizuj średnią za pomocą przesuwając go do średniej pozycji w tym skupieniu>
Implementacja klastrowania K-średnich w Pythonie
Przykład 1
Zaimportuj niezbędne biblioteki
Importujemy Numpy do obliczeń statystycznych, Matplotlib wykreślić wykres, i make_blobs z sklearn.datasets.
Python3
losowy c
import> numpy as np> import> matplotlib.pyplot as plt> from> sklearn.datasets>import> make_blobs> |
>
>
Utwórz niestandardowy zestaw danych za pomocą make_blobs i wykreśl go
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()> |
>
>
Wyjście :
Klastrowanie zbioru danych
Zainicjuj losowe centroidy
Kod inicjuje trzy klastry dla grupowania K-średnich. Ustawia losowe ziarno i generuje losowe centra klastrów w określonym zakresie i tworzy puste lista punktów dla każdego klastra.
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> |
>
>
Wyjście:
{0: {'center': array([0.06919154, 1.78785042]), 'points': []}, 1: {'center': array([ 1.06183904, -0.87041662]), 'points': []}, 2: {'center': array([-1.11581855, 0.74488834]), 'points': []}}> Narysuj losowe centrum inicjalizacji z punktami danych
Python3
przewijanie myszy nie działa
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()> |
>
>
Wyjście :
Punkty danych z losowym środkiem
Wykres przedstawia wykres punktowy punktów danych (X[:,0], X[:,1]) z liniami siatki. Oznacza także początkowe centra skupień (czerwone gwiazdy) wygenerowane dla grupowania K-średnich.
Zdefiniuj odległość euklidesową
Python3
def> distance(p1,p2):> >return> np.sqrt(np.>sum>((p1>->p2)>*>*>2>))> |
>
>
Utwórz funkcję przypisania i zaktualizowania centrum klastra
Krok E przypisuje punkty danych do najbliższego centrum klastrów, a krok M aktualizuje centra klastrów w oparciu o średnią przypisanych punktów w grupowaniu K-średnich.
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> |
>
>
Krok 7: Utwórz funkcję przewidywania klastra dla punktów danych
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> |
>
>
Przypisz, zaktualizuj i przewiduj centrum klastra
Python3
clusters>=> assign_clusters(X,clusters)> clusters>=> update_clusters(X,clusters)> pred>=> pred_cluster(X,clusters)> |
>
>
Narysuj punkty danych wraz z ich przewidywanym środkiem skupienia
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()> |
>
rozpakowywanie w Linuksie
>
Wyjście :
K-oznacza grupowanie
Wykres przedstawia punkty danych pokolorowane według przewidywanych skupień. Czerwone znaczniki reprezentują zaktualizowane centra skupień po etapach E-M w algorytmie grupowania K-średnich.
Przykład 2
Zaimportuj niezbędne biblioteki
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> |
>
>
Załaduj zestaw danych
Python3
X, y>=> load_iris(return_X_y>=>True>)> |
jak wyłączyć tryb programisty na Androidzie
>
>
Metoda łokciowa
Znalezienie idealnej liczby grup, na które można podzielić dane, jest podstawowym etapem każdego algorytmu nienadzorowanego. Jedną z najczęstszych technik obliczania idealnej wartości k jest podejście łokciowe.
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_)> |
>
>
Narysuj wykres łokcia, aby znaleźć optymalną liczbę skupień
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()> |
>
>
Wyjście:
Metoda łokciowa
Z powyższego wykresu możemy zaobserwować, że przy k=2 i k=3 sytuacja przypomina kolano. Zatem rozważamy K=3
Zbuduj model grupowania Kmeans
Python3
kmeans>=> KMeans(n_clusters>=> 3>, random_state>=> 2>)> kmeans.fit(X)> |
>
>
Wyjście:
KMeans KMeans(n_clusters=3, random_state=2)>
Znajdź centrum klastra
Python3
co to jest 25 ze 100
kmeans.cluster_centers_> |
>
>
Wyjście:
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]])>
Przewiduj grupę klastrów:
Python3
pred>=> kmeans.fit_predict(X)> pred> |
>
>
Wyjście:
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)>
Narysuj środek klastra z punktami danych
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()> |
>
>
Wyjście:
K-oznacza grupowanie
Wykres cząstkowy po lewej stronie przedstawia długość płatka w funkcji szerokości płatka z punktami danych pokolorowanymi przez skupienia, a czerwone znaczniki wskazują środki skupień K-średnie. Wykres cząstkowy po prawej stronie pokazuje podobnie długość działki i jej szerokość.
Wniosek
Podsumowując, klastrowanie K-średnich to potężny algorytm uczenia maszynowego bez nadzoru do grupowania nieoznaczonych zbiorów danych. Jego celem jest podzielenie danych na klastry, dzięki czemu podobne punkty danych będą częścią tej samej grupy. Algorytm inicjuje centroidy klastrów i iteracyjnie przypisuje punkty danych do najbliższej centroidy, aktualizując centroidy na podstawie średniej punktów w każdym klastrze.
Często zadawane pytania (FAQ)
1. Czym jest grupowanie k-średnich w analizie danych?
K-średnie to metoda partycjonowania, która dzieli zbiór danych na „k” odrębnych, niezachodzących na siebie podzbiorów (skupisków) w oparciu o podobieństwo, mając na celu zminimalizowanie wariancji w obrębie każdego skupienia.
2.Jaki jest przykład k-średnich w prawdziwym życiu?
Segmentacja klientów w marketingu, gdzie k-średnie grupuje klientów na podstawie zachowań zakupowych, umożliwiając firmom dostosowywanie strategii marketingowych dla różnych segmentów.
3. Jakiego typu danych jest model grupowania k-średnich?
K-średnie dobrze sprawdzają się w przypadku danych numerycznych, gdzie znaczenie ma koncepcja odległości między punktami danych. Jest powszechnie stosowany do zmiennych ciągłych.
4. Czy do przewidywania używa się K-średnich?
Średnie K są używane głównie do grupowania i grupowania podobnych punktów danych. Nie przewiduje etykiet dla nowych danych; przypisuje je do istniejących klastrów na podstawie podobieństwa.
5. Jaki jest cel grupowania k-średnich?
Celem jest podzielenie danych na „k” skupień, minimalizując wariancję wewnątrz skupień. Ma na celu utworzenie grup, w których punkty danych w każdym klastrze są do siebie bardziej podobne niż w innych klastrach.