Python k-означает алгоритм

Я ищу реализацию Python алгоритма k-mean с примерами для кластеризации и кэширования моей базы данных координат.

Ответ 1

Внедрение Scipy clustering хорошо работает, и они включают k-mean.

Здесь также scipy-cluster, что делает агломеративную кластеризацию; Преимущество состоит в том, что вам не нужно заранее определять количество кластеров.

Ответ 2

SciPy kmeans2() имеет некоторые числовые проблемы: другие сообщили сообщения об ошибках, такие как "Матрица не является положительно определенной - декомпозиция Холецкого не может быть вычислена" в версии 0.6.0, и я просто столкнулся с тем же в версии 0.7.1.

В настоящее время я бы рекомендовал вместо этого использовать PyCluster. Пример использования:

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

Ответ 3

Для непрерывных данных k-средство очень просто.

Вам нужен список ваших средств, и для каждой точки данных найдите среднее значение, ближайшее к нему, и усредните новую точку данных. ваши средства будут представлять собой последние существенные кластеры точек во входных данных.

Я постоянно усредняю, поэтому нет необходимости иметь старые данные для получения нового среднего. Учитывая старую среднюю k, следующую точку данных x и константу n, которая является числом прошлых точек данных, чтобы сохранить среднее значение, новое среднее

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

Вот полный код в 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)

вы могли бы просто распечатать средства, когда все данные прошли, но гораздо интереснее смотреть, как он меняется в реальном времени. Я использовал это на частотных огибающих 20 мс звука и после разговора с ним в течение минуты или двух, он имел согласованные категории для короткой гласной "а", длинной гласной "о" и "согласного". Wierd!

Ответ 4

Из wikipedia вы можете использовать scipy, K -средства кластеризации векторного квантования

Или вы можете использовать оболочку Python для OpenCV, ctypes-opencv.

Или вы могли бы OpenCV новый интерфейс Python, а их kmeans.

Ответ 5

(Годы спустя) этот kmeans.py в is-it-possible-to-specify-your-own-distance-function-using-scikits-learn-k-means прост и разумен; он использует любую из 20-нечетных показателей в scipy.spatial.distance.

Ответ 6

Вы также можете использовать GDAL, который имеет много функций для работы с пространственными данными.

Ответ 7

SciKit Learn KMeans() - это самый простой способ применения кластеризации k-mean в Python. Скользящие кластеры просты: kmeans = KMeans(n_clusters=2, random_state=0).fit(X).

В этом фрагменте кода показано, как хранить координаты центра и прогнозировать кластеры для массива координат.

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

(любезно предоставлено документацией SciKit Learn, связанной выше)

Ответ 8

Python Pycluster и pyplot могут использоваться для кластеризации k-средних и для визуализации 2D-данных. Недавнее сообщение в блоге Анализ цен на акции/томов с использованием Python и PyCluster дает пример кластеризации с использованием PyCluster по данным запаса.

Ответ 9

* Этот код K-средства с Pyhon *

from math import math

from functions import functions

class KMEANS:

@staticmethod
def KMeans(data,classterCount,globalCounter):
counter=0
classes=[]
cluster =[[]]
cluster_index=[]
tempClasses=[]
for i in range(0,classterCount):
globalCounter+=1
classes.append(cluster)
cluster_index.append(cluster)
tempClasses.append(cluster)
classes2=classes[:]
for i in range(0,len(classes)):
globalCounter=1
cluster = [data[i]]
classes[i]=cluster
functions.ResetClasterIndex(cluster_index,classterCount,globalCounter)
functions.ResetClasterIndex(classes2,classterCount,globalCounter)
def clusterFills(classeses,globalCounter,counter):
counter+=1
combinedOfClasses = functions.CopyTo(classeses)
functions.ResetClasterIndex(cluster_index,classterCount,globalCounter)
functions.ResetClasterIndex(tempClasses,classterCount,globalCounter)
avarage=[]
for k in range(0,len(combinedOfClasses)):
globalCounter+=1
avarage.append(functions.GetAvarage(combinedOfClasses[k]))
for i in range(0,len(data)):
globalCounter+=1
minimum=0
index=0
for k in range(0,len(avarage)):
total=0.0
for j in range(0,len(avarage[k])):
total += (avarage[k][j]-data[i][j]) **2
tempp=math.sqrt(total)
if(k==0):
minimu=tempp
if(tempp&lt;=minimu):
minimu=tempp
index=k
tempClasses[index].append(data[i])
cluster_index[index].append(i)
if(functions.CompareArray(tempClasses,combinedOfClasses)==1):
return clusterFills(tempClasses,globalCounter,counter)
returnArray = []
returnArray.append(tempClasses)
returnArray.append(cluster_index)
returnArray.append(avarage)
returnArray.append(counter)
return returnArray

cdcd = clusterFills(classes,globalCounter,counter)
if cdcd !=None:
return cdcd

@staticmethod
def KMeansPer(data,classterCount,globalCounter):
perData=data[0:int(float(len(data))/100*30)]
result = KMEANS.KMeans(perData,classterCount,globalCounter)
cluster_index=[]
tempClasses=[]
classes=[]
cluster =[[]]
for i in range(0,classterCount):
globalCounter+=1
classes.append(cluster)
cluster_index.append(cluster)
tempClasses.append(cluster)
classes2=classes[:]
for i in range(0,len(classes)):
globalCounter=1
cluster = [data[i]]
classes[i]=cluster
functions.ResetClasterIndex(cluster_index,classterCount,globalCounter)
functions.ResetClasterIndex(classes2,classterCount,globalCounter)
counter=0
def clusterFills(classeses,globalCounter,counter):
counter+=1
combinedOfClasses = functions.CopyTo(classeses)
functions.ResetClasterIndex(cluster_index,classterCount,globalCounter)
functions.ResetClasterIndex(tempClasses,classterCount,globalCounter)
avarage=[]
for k in range(0,len(combinedOfClasses)):
globalCounter+=1
avarage.append(functions.GetAvarage(combinedOfClasses[k]))
for i in range(0,len(data)):
globalCounter+=1
minimum=0
index=0
for k in range(0,len(avarage)):
total=0.0
for j in range(0,len(avarage[k])):
total += (avarage[k][j]-data[i][j]) **2
tempp=math.sqrt(total)
if(k==0):
minimu=tempp
if(tempp&lt;=minimu):
minimu=tempp
index=k
tempClasses[index].append(data[i])
cluster_index[index].append(i)
if(functions.CompareArray(tempClasses,combinedOfClasses)==1):
return clusterFills(tempClasses,globalCounter,counter)
returnArray = []
returnArray.append(tempClasses)
returnArray.append(cluster_index)
returnArray.append(avarage)
returnArray.append(counter)
return returnArray

cdcd = clusterFills(result[0],globalCounter,counter)
if cdcd !=None:
return cdcd

Прочитать...