Essayez l'analyse de cluster par K-means
Qu'est-ce que l'analyse de cluster? Quelle est la méthode de la moyenne K?
C'est comme ça.
Analyse de cluster: une analyse qui regroupe des données similaires. Méthode de calcul de la moyenne K: une des méthodes d'analyse de cluster.
Il existe différents domaines d'application, mais l'exemple le plus évident est Un programme qui rassemble les points éparpillés sur les coordonnées les uns avec les autres. C'est ce que je vais faire cette fois.
Comment puis-je faire?
Selon Wikipedia, il semble que ce soit le cas.
La méthode de calcul de la moyenne K est généralement implémentée dans le flux suivant. Soit n le nombre de données et K le nombre de clusters.
- Allouez au hasard des clusters pour chaque donnée x_i (i = 1 \ ... n).
- Calculez le centre V_j (j = 1 \ ... K) de chaque cluster en fonction des données allouées. Le calcul utilise généralement la moyenne arithmétique de chaque élément des données attribuées.
- Trouvez la distance entre chaque x_i et chaque V_j et réaffectez x_i au cluster central le plus proche.
- Si l'allocation de tous les clusters x_i ne change pas dans le processus ci-dessus, ou si la quantité de changement tombe en dessous d'un certain seuil prédéfini, il est déterminé que le processus a convergé et le processus se termine. Sinon, recalculez V_j à partir du cluster nouvellement alloué et répétez le processus ci-dessus.
C'est facile à faire, mais c'est difficile. Faire
- Dispersez les points au hasard. Je vais les diviser en groupes sans aucune raison.
- Trouvez le centre de chaque groupe.
- Le regroupement précédent était approprié, je vais donc regrouper en fonction du centre du groupe le plus proche.
- Répétez les étapes 1 à 3 jusqu'à ce qu'il n'y ait aucun changement.
Je pense que c'est ce que c'est.
J'ai essayé de le faire.
Oui.
Ceci au début. J'ai fait ça cette fois.
La source
99 lignes au total. Il tient dans 100 lignes. heureux. Je vous l'expliquerai plus tard.
k-means.py
# -*- coding: utf-8 -*-
import wx
import random
import math
class MyMainWindow(wx.Frame):
def __init__(self, parent=None, id=-1, title=None):
#Définir le panneau sur le cadre
wx.Frame.__init__(self, parent, id, title)
self.panel = wx.Panel(self, size=(300, 300))
self.panel.SetBackgroundColour('000000')
self.Fit()
#un événement
self.panel.Bind(wx.EVT_PAINT, self.on_paint)
self.panel.Bind(wx.EVT_LEFT_DOWN, self.on_left_click)
self.panel.Bind(wx.EVT_RIGHT_DOWN, self.on_right_click)
#Initialisation variable
self.dots = []
self.dc = None
#Il existe trois types de clusters: rouge, vert et bleu
self.cluster_types = ('#FF0000', '#00FF00', '#0000FF')
self.clusters = [(0, 0), (0, 0), (0, 0)]
#Ensemble initial de points
self.shuffle_dots()
def on_paint(self, event):
u"""Événement de dessin"""
self.dc = wx.PaintDC(self.panel)
#Ecrire un carré
self.dc.SetPen(wx.Pen('#CCCCCC', 1))
for x in range(0, 300, 10):
self.dc.DrawLine(x, 0, x, 300)
for y in range(0, 300, 10):
self.dc.DrawLine(0, y, 300, y)
#Dessinez un point
for dot in self.dots:
self.dc.SetPen(wx.Pen(self.cluster_types[dot['cluster']], 5))
self.dc.DrawPoint(dot['x'], dot['y'])
#Dessinez le centre de gravité du cluster.
self.draw_cluster()
def on_left_click(self, evt):
u"""Clic gauche pour recalculer le cluster"""
self.change_cluster()
self.Refresh()
def on_right_click(self, evt):
u"""Faites un clic droit pour réinitialiser le point"""
self.shuffle_dots()
self.Refresh()
def shuffle_dots(self):
u"""Disposez les points au hasard."""
self.dots = []
for i in range(30):
self.dots.append({'x': random.randint(0, 300),
'y': random.randint(0, 300),
'cluster': random.randint(0, len(self.cluster_types) - 1)})
def draw_cluster(self):
u"""Dessinez un cluster."""
self.clusters = []
for c in range(len(self.cluster_types)):
#Centre de gravité du cluster = moyenne des coordonnées des points appartenant au cluster
self.dc.SetPen(wx.Pen(self.cluster_types[c], 1))
count = sum(1 for dot in self.dots if dot['cluster'] == c)
x = sum(dot['x'] for dot in self.dots if dot['cluster'] == c) // count if count != 0 else 150
y = sum(dot['y'] for dot in self.dots if dot['cluster'] == c) // count if count != 0 else 150
self.clusters.append({'x': x, 'y': y})
#Dessinez le cluster avec une croix
self.dc.DrawLine(x - 5, y - 5, x + 5, y + 5)
self.dc.DrawLine(x + 5, y - 5, x - 5, y + 5)
#Tracez une ligne du cluster à chaque point.
self.dc.SetPen(wx.Pen(self.cluster_types[c], 0.8))
for dot in self.dots:
if dot['cluster'] == c:
self.dc.DrawLine(x, y, dot['x'], dot['y'])
def change_cluster(self):
u"""Modifiez l'affiliation de chaque point au cluster le plus proche."""
for d in range(len(self.dots)):
near_dist = 99999
#Distance entre deux points = √( (X1-X2)^2+(Y1-Y2)^2 )
for c in range(len(self.cluster_types)):
dist = math.sqrt(
(self.dots[d]['x'] - self.clusters[c]['x']) ** 2 + (self.dots[d]['y'] - self.clusters[c]['y']) ** 2)
#Passer au cluster le plus proche
if near_dist >= dist:
self.dots[d]['cluster'] = c
near_dist = dist
if __name__ == '__main__':
app = wx.PySimpleApp()
w = MyMainWindow(title='K-Means Test')
w.Center()
w.Show()
app.MainLoop()
Commentaire
wxPython Cette fois, j'ai utilisé une bibliothèque GUI appelée wxPython. Il fonctionne sur Mac, Windows et Linux et l'affiche d'une manière familière à chaque plate-forme.
class MyMainWindow(wx.Frame):
Créez une classe qui hérite de wx.Frame et
if __name__ == '__main__':
app = wx.PySimpleApp()
w = MyMainWindow(title='K-Means Test')
w.Center()
w.Show()
app.MainLoop()
appel. Un tel flux.
Oui. La logique réelle est expliquée à partir d'ici.
Dispersez les points au hasard et regroupez-les de manière appropriée
shuffle_dots()
Cette fonction disperse les points et les place dans un tableau appelé points.
À ce moment-là, les groupes sont attribués de manière appropriée.
À la recherche du centre du groupe
draw_cluster()
La moyenne de chaque point appartenant au groupe est calculée et utilisée comme centre du groupe.
À propos, tracez une ligne du centre à chaque point pour le rendre plus facile à comprendre.
Changer pour le groupe le plus proche
change_cluster()
Distance entre deux points = √ ((X1-X2) ^ 2 + (Y1-Y2) ^ 2)
Utilisez cette formule pour trouver la distance entre chaque point et le centre du groupe et basculer vers le groupe le plus proche. Il y avait une telle formule. C'était utile pour la première fois depuis le collège.
Dessiner à l'écran
on_paint()
Cette fonction est appelée au moment du dessin.
Parce qu'il était lié à self.panel.Bind (wx.EVT_PAINT, self.on_paint) au début.
L'ordre des explications et du traitement a changé, mais le traitement expliqué précédemment est appelé dans cette fonction.
Répéter
Chaque fois que vous cliquez, le flux jusqu'à présent est recalculé. Si vous appuyez plusieurs fois, il sera classé dans le formulaire rempli. Cliquez avec le bouton gauche pour repositionner.
Résumé
C'est une méthode d'analyse qui semble avoir un seuil élevé, Quand je l'essaye, c'est relativement simple.
Cependant, cette méthode de moyennage K a tendance à donner un résultat biaisé, donc Il semble y avoir une méthode d'analyse améliorée.
Même si vous tapez des points dans les coordonnées et les divisez en groupes, c'est juste vide. Il peut être intéressant d'analyser la similitude de vos animaux préférés en attribuant l'axe X au goût du chat et l'axe Y au goût du chien.
J'aime aussi augmenter le système de coordonnées de deux et faire une analyse de cluster en quatre dimensions. Il y a un sens de l'avenir.
Recommended Posts