Python-k signifie algorithme

Question

Je cherche la mise en œuvre Python de k-means avec des exemples en vue de regrouper et mettre en cache ma base de données de coordonnées.

Answer 1

de regroupement de Scipy mises en œuvre fonctionnent bien, et ils comprennent un la mise en œuvre de k-means.

Il y a aussi scipy cluster , qui fait le regroupement agglomératif; EMH a l'avantage que vous n'avez pas besoin de décider du nombre de grappes à l'avance.

Answer 2

de SciPy kmeans2 () a quelques problèmes numériques: les autres rapporté des messages d'erreur tels que « Matrix n'est pas positif défini -. décomposition Cholesky ne peut pas être calculée » dans la version 0.6.0, et je viens de la même rencontré dans la version 0.7.1

Pour l'instant, je vous conseille d'utiliser PyCluster à la place. Exemple d'utilisation:

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

Pour des données continues, k-moyens est très facile.

Vous avez besoin d'une liste de vos moyens, et pour chaque point de données, trouver la moyenne la plus proche de et moyenne, le nouveau point de données à elle. vos moyens représenteront les derniers groupes saillants de points dans les données d'entrée.

Je fais la moyenne en continu, donc il n'y a pas besoin d'avoir les anciennes données pour obtenir la nouvelle moyenne. Compte tenu de l'ancienne k moyenne, le point de données suivant x et une n constante qui est le nombre de points de données passées pour maintenir la moyenne, la nouvelle moyenne est

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

Voici le code complet en 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)

vous pouvez simplement imprimer les moyens lorsque toutes les données est passé à travers, mais il est beaucoup plus amusant de regarder changer en temps réel. J'ai utilisé ce sur des enveloppes de fréquence de 20ms bits de son et après avoir parlé à pendant une minute ou deux, il y avait des catégories cohérentes à court 'une voyelle, long « o » voyelle, et les consonne « s ». Weird!

Answer 4

De wikipedia , vous pouvez utiliser scipy, K-means une quantification vectorielle

Ou, vous pouvez utiliser un wrapper Python pour OpenCV, ctypes-OpenCV .

Ou vous pouvez nouvelle interface Python OpenCV, et leur la mise en œuvre de kmeans.

Answer 5

(Des années plus tard) ce kmeans.py sous est-il possible-à spécifier-votre-propre-distance fonction à l'aide-scikits-learn-k-means est simple et assez rapide; il utilise l'un des paramètres 20-impair dans scipy.spatial.distance.

Answer 6

Vous pouvez également utiliser GDAL, qui a beaucoup de nombreuses fonctions pour travailler avec des données spatiales.

Answer 7

SciKit LEARN KMeans () est moyen le plus simple d'appliquer des k-means en Python. grappes de montage est simple: kmeans = KMeans(n_clusters=2, random_state=0).fit(X).

Cet extrait de code montre comment stocker les coordonnées barycentre et de prévoir des clusters pour un tableau de coordonnées.

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

(avec la permission de la documentation SciKit savoir, lien ci-dessus)

Answer 8

Pycluster et pyplot Python peuvent être utilisés pour k-means et pour la visualisation des données 2D. Un récent blog Stock Prix / Analyse du volume en utilisant Python et PyCluster donne un exemple de regroupement en utilisant PyCluster sur les données de stock.