Pitone algoritmo k-means

Question

Sto cercando implementazione di Python di algoritmo k-means con esempi di cluster e memorizzare nella cache il mio database di coordinate.

Answer 1

di clustering di SciPy implementazioni funzionano bene, e comprendono un k-means attuazione.

C'è anche SciPy-cluster, che fa agglomerative clustering; THS ha il vantaggio che non è necessario decidere il numero di cluster prima del tempo.

Answer 2

kmeans2 () ha alcuni problemi numerici: gli altri avere riportato messaggi di errore quali "Matrix non è positivo definitiva -. Cholesky decomposizione non può essere calcolato" nella versione 0.6.0, e ho appena incontrato lo stesso nella versione 0.7.1

Per il momento, mi consiglia di utilizzare PyCluster . Esempio di utilizzo:

>>> 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

Answer 3

Per dati continui, k-mezzi è molto semplice.

Hai bisogno di una lista dei vostri mezzi, e per ogni punto di dati, trovare la media il suo più vicino alla e nella media il nuovo punto di dati su di esso. i vostri mezzi rappresenteranno i recenti cluster salienti dei punti nei dati di input.

faccio la media di continuo, quindi non c'è bisogno di avere i vecchi dati per ottenere il nuovo media. Data la vecchia k media, il successivo punto dati x, e un n costante che è il numero di punti dati del passato per mantenere la media, il nuovo media è

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

Ecco il codice completo in Python

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)

si può solo stampare i mezzi quando tutti i dati è passato attraverso, ma la sua molto più divertente da guardare cambia in tempo reale. Ho usato questo su buste frequenza di 20ms frammenti di suono e dopo aver parlato con esso per un minuto o due, aveva categorie omogenee per il breve 'a' vocale, la lunga 'o' vocale e consonante le 's'. strano!

Answer 4

wikipedia , è possibile utilizzare SciPy, K-means una quantizzazione vettoriale

In alternativa, è possibile utilizzare un wrapper Python per OpenCV, ctypes-OpenCV .

nuova un'interfaccia Python di OpenCV, e la loro Kmeans implementazione.

Answer 5

(anni dopo) questo kmeans.py in è-da-possibile-per-indicare-your-own-distance-funzione-con-scikits-imparare-K-Means è semplice e ragionevolmente veloce; utilizza una qualsiasi delle metriche 20 e rotti in scipy.spatial.distance.

Answer 6

È inoltre possibile utilizzare GDAL, che ha molte molte funzioni per lavorare con dati spaziali.

Answer 7

K-Means () è il modo più semplice per applicare k-means clustering in Python. Montaggio cluster è semplice come: kmeans = KMeans(n_clusters=2, random_state=0).fit(X).

Questo frammento di codice mostra come memorizzare coordinate del centroide e prevedere cluster per una serie di coordinate.

>>> 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.]])

(per gentile concessione di SciKit di Learn documentazione, linkata sopra)

Answer 8

Pycluster e pyplot Python possono essere utilizzati per k-means e per la visualizzazione dei dati 2D. Un recente post sul blog Analisi Stock Price / volume utilizzando Python e PyCluster fornisce un esempio di cluster utilizzando PyCluster sui dati di stock.