Discussion :

[fideel]

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

Sélectionner tout - Visualiser dans une fenêtre à part

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

[fideel]

Quelqu'un...