Python k-means algoritmo

SciPy kmeans2() tiene algunos problemas numéricos: otros han reportado mensajes de error como "Matrix is not positive definite - Cholesky decomposition cannot be computed" en la versión 0.6.0, y acabo de encontrar lo mismo en la versión 0.7.1.

Por ahora, recomendaría usar PyCluster en su lugar. Ejemplo de uso:

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

Para datos continuos, k-means es muy fácil.

Necesita una lista de sus medias, y para cada punto de datos, encuentre la media su más cercana y promedie el nuevo punto de datos a él. sus medios representarán los recientes grupos salientes de puntos en los datos de entrada.

Hago el promedio continuamente, por lo que no hay necesidad de tener los datos antiguos para obtener el nuevo promedio. Dado el antiguo promedio k, el siguiente punto de datos x, y una constante n que es el número de puntos de datos pasados a mantener el promedio de, el nuevo promedio es

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

Aquí está el código completo 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)

Simplemente podría imprimir los medios cuando todos los datos hayan pasado, pero es mucho más divertido verlo cambiar en tiempo real. Usé esto en envolventes de frecuencia de 20 ms bits de sonido y después de hablar con él durante un minuto o dos, tenía categorías consistentes para la vocal corta 'a', la vocal larga 'o' y la consonante 's'. ¡wierd!

Desde wikipedia , se podría usar scipy, K-significa agrupar una cuantización vectorial

O bien, podría usar un contenedor Python para OpenCV, ctypes-opencv.

O podría la nueva interfaz Python de OpenCV, y su implementación kmeans.

(Años después) esto kmeans.py bajo es-posible-especificar-su-propia-distancia-función-usando-scikits-learn-k-significa que es sencillo y razonablemente rápido; utiliza cualquiera de las 20 y pico métricas en scipy.espacial.distancia.

También puede usar GDAL, que tiene muchas funciones para trabajar con datos espaciales.

El método de SciKit Learn KMeans() es la forma más sencilla de aplicar clustering de k-means en Python. El montaje de clústeres es simple como: kmeans = KMeans(n_clusters=2, random_state=0).fit(X).

Este fragmento de código muestra cómo almacenar coordenadas centroides y predecir clústeres para una matriz de coordenadas.

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

(cortesía de la documentación de SciKit Learn, enlazada arriba)

El Pycluster y el pyplot de Python se pueden usar para clustering de k-means y para visualización de datos 2D. Una publicación reciente en el blog Análisis de Precios/Volúmenes de Acciones Usando Python y PyCluster da un ejemplo de clustering usando PyCluster en datos de acciones.