Python algorithme k-means
8 réponses
Scipy clustering les implémentations de bien travailler, et ils comprennent une k-means la mise en œuvre.
il y a aussi scipy-cluster , qui fait du clustering agglomératif; ths a l'avantage que vous n'avez pas besoin de décider sur le nombre de clusters à l'avance.
SciPy kmeans2 () a quelques problèmes numériques: d'autres ont rapporté messages d'erreur tels que" la matrice n'est pas positive definite - la décomposition Cholesky ne peut pas être calculée " dans la version 0.6.0, et je viens de rencontrer la même chose dans la version 0.7.1.
pour l'instant, je recommande 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
pour les données continues, k-means est très facile.
vous avez besoin d'une liste de vos moyens, et pour chaque point de données, Trouver le moyen le plus proche et la moyenne le nouveau point de données à lui. vos moyens représenteront les groupes de points saillants récents dans les données d'entrée.
je fais la moyenne de façon continue, il n'est donc pas nécessaire d'avoir les anciennes données pour obtenir la nouvelle moyenne. Compte tenu de l'ancienne moyenne k
, le prochain point de données x
, et un la constante n
, qui est le nombre de points de données pour garder 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 ont traversé, mais il est beaucoup plus amusant de le regarder changer en temps réel. J'ai utilisé ceci sur des enveloppes de fréquence de 20ms de bits de son et après lui avoir parlé pendant une minute ou deux, il avait des catégories cohérentes pour le court "a" la voyelle, la longue voyelle et la consonne. bizarre!
à Partir de wikipedia , vous pouvez utiliser scipy, K-means clustering une quantification de vecteur
ou, vous pouvez utiliser une enveloppe Python pour OpenCV, ctypes-opencv .
ou vous pouvez la nouvelle interface Python D'OpenCV , et leur kmeans implémentation.
(années plus tard) kmeans.py sous est-il-possible-de-spécifier-votre-propre-distance-Fonction-en utilisant-scikits-learn-k-signifie est simple et raisonnablement rapide; il utilise l'une des 20 mesures impaires dans scipy.spatial.distance.
vous pouvez également utiliser GDAL, qui a de nombreuses fonctions pour travailler avec des données spatiales.
SciKit Learn's KMeans () est la manière la plus simple d'appliquer le clustering k-means en Python. Raccord de clusters est simple comme:
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
.
cet extrait de code montre comment stocker les coordonnées centroïdes et prédire les 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 SciKit Learn's documentation, en lien ci-dessus)
le Pycluster de Python et le polyplot peuvent être utilisés pour le clustering de K-means et pour la visualisation de données 2D. Un récent billet de blog analyse du Volume et du prix des actions en utilisant Python et PyCluster donne un exemple de regroupement en utilisant PyCluster sur des données boursières.