Algorithme de clustering K-means
salut à tous.
svp j'ai un programme Kmeans, je veux le modifier pour qu'il soit kmeans incrémental.
comment pouvais-je le faire..
et merci d'avance.
Code :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
from scipy.spatial import distance
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import style
import pandas as pd
#import tkinter as tk
from tkinter import *
from sklearn.preprocessing import LabelEncoder
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score
from sklearn.metrics import adjusted_rand_score
import matplotlib.cm as cm
np.seterr(divide='ignore', invalid='ignore')
style.use('ggplot')
x=0
y=0
silhouette_avg = []
cluster_err = []
clusters_df=[]
adj_rand_score = []
class K_Means:
def __init__(self, k = 3, tolerance = 0.0001, max_iterations = 500):
self.k = k
self.tolerance = tolerance
self.max_iterations = max_iterations
self.itr = 0
def manhattan(a,b):
return sum(abs(x - y) for x,y in zip(a, b))
def fit(self, data, dist):
self.centroids = {}
self.dist = dist
#Initializer les centroids par les 'k' premiers elements du dataset
for i in range(self.k):
self.centroids[i] = data[i]
#self.centroids[i] = data[randint(1, taille)]
# Début des iterations
for i in range(self.max_iterations):
self.classes = {}
for i in range(self.k):
self.classes[i] = []
#Chercher la distance entre point et cluster; choix du plus proche centroid
for features in data:
if dist == "euclidean":
distances = [distance.euclidean(features,self.centroids[centroid]) for centroid in self.centroids]
elif dist == "cosine":
distances = [distance.cosine(features,self.centroids[centroid]) for centroid in self.centroids]
elif dist == "manhattan":
distances = [K_Means.manhattan(features,self.centroids[centroid]) for centroid in self.centroids]
elif dist == "minkowski":
distances = [distance.minkowski(features,self.centroids[centroid]) for centroid in self.centroids]
classification = distances.index(min(distances))
self.classes[classification].append(features)
previous = dict(self.centroids)
#Varier les points de données du cluster pour recalculer les centroïdes
for classification in self.classes:
self.centroids[classification] = np.average(self.classes[classification], axis = 0)
isOptimal = True
for centroid in self.centroids:
original_centroid = previous[centroid]
curr = self.centroids[centroid]
if len(original_centroid)!=0:
if np.sum((curr - original_centroid)/(original_centroid) * 100.0) > self.tolerance:
isOptimal = False
self.itr += 1
#sortir de la boucle si les résultats sont optimaux, à savoir. les centroïdes ne changent pas beaucoup leurs positions (plus que la tolérance)
if isOptimal:
break |
