Python K-oznacza algorytm

Kmeans2 () ma pewne problemy numeryczne: inne mają zgłoszone komunikaty o błędach, takie jak "macierz nie jest dodatnia określona - rozkładu Cholesky nie można obliczyć" w wersji 0.6.0, a ja właśnie spotkałem się z tym samym w wersji 0.7.1.

>>> import numpy
>>> import Pycluster
>>> points = numpy.vstack([numpy.random.multivariate_normal(mean, 
                                                            0.03 * numpy.diag([1,1]),
                                                            20) 
                           for mean in [(1, 1), (2, 4), (3, 2)]])
>>> labels, error, nfound = Pycluster.kcluster(points, 3)
>>> labels  # Cluster number for each point
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], dtype=int32)
>>> error   # The within-cluster sum of distances for the solution
1.7721661785401261
>>> nfound  # Number of times this solution was found
1

Dla danych ciągłych, K-oznacza jest bardzo proste.

Potrzebujesz listy swoich środków i dla każdego punktu danych Znajdź średnią najbliższą i uśrednij nowy punkt danych do niego. twoje środki będą reprezentować Ostatnie istotne skupiska punktów w danych wejściowych.

Robię uśrednianie w sposób ciągły, więc nie ma potrzeby posiadania starych danych, aby uzyskać nową średnią. Biorąc pod uwagę starą średnią k, następny punkt danych x i stałą n, która jest liczbą przeszłych punktów danych do zachowaj średnią z, nowa średnia to

k*(1-(1/n)) + n*(1/n)

Oto Pełny kod w Pythonie

from __future__ import division
from random import random

# init means and data to random values
# use real data in your code
means = [random() for i in range(10)]
data = [random() for i in range(1000)]

param = 0.01 # bigger numbers make the means change faster
# must be between 0 and 1

for x in data:
    closest_k = 0;
    smallest_error = 9999; # this should really be positive infinity
    for k in enumerate(means):
        error = abs(x-k[1])
        if error < smallest_error:
            smallest_error = error
            closest_k = k[0]
        means[closest_k] = means[closest_k]*(1-param) + x*(param)

Możesz po prostu wydrukować środki, gdy wszystkie dane zostaną przepuszczone, ale oglądanie ich zmian w czasie rzeczywistym jest o wiele przyjemniejsze. Użyłem tego na kopercie częstotliwości 20ms bitów dźwięku i po rozmowie z nim przez minutę lub dwie, miał spójne kategorie dla krótkiej samogłoski "a", długiej samogłoski " o "i spółgłoski "s". dziwne!

Z Wikipedii, można użyć scypy, K-oznacza klastrowanie kwantyzacji wektorowej

Lub mógłbyś Nowy interfejs OpenCV w Pythonie i ich implementację kmeans .

(Years later) this kmeans.py Pod is-it-possible-to-specific-your-own-distance-function-using-scikits-learn-k-means jest proste i dość szybkie; używa dowolnej z 20-nieparzystych metryk w scipy.przestrzenne.odległość.

Można również użyć GDAL, który posiada wiele funkcji do pracy z danymi przestrzennymi.

SciKit Learn ' s KMeans () jest najprostszym sposobem zastosowania k-means clustering w Pythonie. Montaż klastrów jest prosty jak: kmeans = KMeans(n_clusters=2, random_state=0).fit(X).

Ten fragment kodu pokazuje, jak przechowywać współrzędne centroidowe i przewidywać klastry dla tablicy współrzędnych.

>>> from sklearn.cluster import KMeans
>>> import numpy as np
>>> X = np.array([[1, 2], [1, 4], [1, 0],
...               [4, 2], [4, 4], [4, 0]])
>>> kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
>>> kmeans.labels_
array([0, 0, 0, 1, 1, 1], dtype=int32)
>>> kmeans.predict([[0, 0], [4, 4]])
array([0, 1], dtype=int32)
>>> kmeans.cluster_centers_
array([[ 1.,  2.],
       [ 4.,  2.]])

(dzięki uprzejmości dokumentacji SciKit Learn, podlinkowanej powyżej)

Pycluster i pypllot w Pythonie mogą być używane do klastrowania k-means oraz do wizualizacji danych 2D. Ostatni post na blogu Analiza ceny/wolumenu akcji za pomocą Pythona i PyCluster daje przykład klastrowania za pomocą PyCluster na danych giełdowych.