REPUBLIQUE DU CAMEROUN REPUBLIC OF CAMEROON

Paix-Travail-patrie Peace-Work-Fatherland
*************** ***************
UNIVERSITE DE YAOUNDE I THE UNIVERSITY OF YAOUNDE I
ENSPY NASEY
DEPARTEMENT DU GIM DEPARTMENT OF GIM
B.P. 8390 Yaoundé, Tel : +237 677 378 P.O. Box 8390Yaoundé, Tel : +237 677 378
474 474

EXPOSE DE MACHINE
LEARNING :
ALGORITHME K-MEANS ET
DBSCAN

GROUPE 4 :
PARTICIPANTS :

• ASSAKANG CHERODE
• MOMO EITEL DARLOS
• NOUTCHIEU DOMNGANG STEVE

Supervisé par : MR Herman TCHENEGHON

 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

Contents
I. INTRODUCTION ................................................................................................................... 3
II. ALGORITHME K-MEANS : ................................................................................................. 4
a) PRINCIPE DE BASE DE L’ALGORITHME K-MEANS : ............................................... 4
b) ETAPES DE L’ALGORITHME K-MEANS : .................................................................... 5
c) ALGORITHME CLASSIQUE K-MEANS :....................................................................... 8
d) ORGANIGRAMME CLASSIQUE ALGORITHME K-MEANS : ................................... 9
e) AVANTAGES ET INCONVENIENTS DE LA METHODE K-MEANS : ..................... 10
f) EXERCICE D’APPLICATION : ...................................................................................... 10
III. ALGORITHME DBSCAN ................................................................................................ 23
1. Principe de base .............................................................................................................. 23
2. CONCEPTS CLÉ DE DBSCAN ................................................................................. 24
3. ETAPES DE L’ALGORITHME .................................................................................... 25
4. AVANTAGES ET INCONVÉNIENTS ........................................................................ 26
5. EXEMPLE D’APPLICATION ...................................................................................... 26
IV. COMPARAISON ENTRE K-MEANS ET DBSCAN ......................................................... 29
V. CONCLUSION ..................................................................................................................... 30

Page 2 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

I. INTRODUCTION :

La classification est une technique d’analyse de données qui consiste à regrouper des
éléments similaires en catégories ou en classes. Il existe deux types de classification :
supervisée et non supervisée. La classification supervisée est utilisée pour prédire la classe de
nouvelles données inédites. Elle repose sur des données étiquetées, c’est-à-dire que chaque
observation de la population est associée à une classe connue. En revanche, la classification
non supervisée ne repose pas sur des données étiquetées. L’algorithme reçoit un ensemble de
données non étiquetées et doit identifier des modèles et des regroupements par lui-même. Au
sein de ce devoir, nous allons nous intéresser à la classification non supervisée plus
précisément en examinant les algorithmes K-means et DBSCAN.

Page 3 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

II. ALGORITHME K-MEANS :

a) PRINCIPE DE BASE DE L’ALGORITHME K-MEANS :

1. Contexte :
Le partitionnement en k-moyenne (ou k-means en anglais) est une méthode de
partitionnement de données et un problème d’optimisation combinatoire. Elle permet de
regrouper des individus ayant des caractéristiques similaires(clusters) à travers l’analyse de
jeux de données caractérisée par un ensemble de descripteurs.
La méthode des kmeans repose sur la minimisation de la somme des distances
euclidiennes au carré entre chaque objet (ou sujet, ou point) et le centroïde (le point central) de
son cluster.
Contrairement aux autres algorithmes de MACHINE LEARNING, il ne permet pas de
prédire un résultat puisqu’il fait partie de la catégorie des méthodes non supervisées. Les
termes “non supervisée” signifient que les groupes n’existent pas avant d’être créés ; il ne
s’agit d’apprendre à partir des données comment construire des clusters existants. Il s’agit
seulement de regrouper les données.
Remarque : Dans la méthode des kmeans, les objets (ou sujets, ou sites, ou points, etc.)
appartiennent à un seul cluster, et les clusters ne se chevauchent pas.
2. Principe de base :
• La distance euclidienne :
La distance euclidienne est à la base de la méthode des kmeans, puisqu’il s’agit
d’attribuer un cluster à chaque point, de façon à ce que la somme des distances euclidiennes au
carré entre chaque point et le centroïde de son cluster, soit la plus faible possible. On parle de
minimisation de la variation intra-cluster.
La distance euclidienne est simplement une généralisation du théorème de Pythagore
qui dit que ” le carré de la longueur de l’hypoténuse, qui est le côté opposé à l’angle droit, est
égal à la somme des carrés des longueurs des deux autres côtés.”
Ainsi, dans un espace à deux dimensions la distance euclidienne entre deux points
peut être estimée par hypoténuse d’un triangle rectangle.

d (A, B) =√(𝑿𝒂 − 𝑿𝒃 )𝟐 + (𝒀𝒂 − 𝒀𝒃 )𝟐

Page 4 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

Dans un espace à n dimensions (u, v, …z), la distance euclidienne entre les points, ou
deux observations A (Xa, Ya, Za) et B (Xb, Yb,…, Zb), est définie par :

d (A, B) =√(𝑿𝒂 − 𝑿𝒃 )𝟐 + (𝒀𝒂 − 𝒀𝒃 )𝟐 + ⋯ (𝒁𝒂 − 𝒁𝒃 )𝟐 .

b) ETAPES DE L’ALGORITHME K-MEANS :

Les étapes de l’algorithme k-means sont les suivantes :
1. Sélectionner le nombre de clusters k que vous souhaitez former :

La détermination du nombre de clusters permet de garantir que les données sont

divisées efficacement et correctement. Une valeur appropriée de ce nombre « K » aide à
maintenir un bon équilibre entre la compressibilité et la précision. Voici deux méthodes de
calcul qui peuvent être utilisées pour déterminer le nombre de clusters :

• La Méthode du coude :

Elle est basée sur le fait que la somme de la variance intra clusters peut être réduite
grâce à l'augmentation du nombre de clusters. Plus il est élevé, plus il permet d'extraire des
groupes plus fins à partir de l'analyse d'objets de données qui ont plus de similarité entre eux.
On utilise le point de retournement de la courbe de la somme des variances pour choisir le bon
nombre de clusters. Cela signifie quoi qu’il faut exécutez l'algorithme des k-means pour
différents nombres de clusters (par exemple, de 1 à 10). Ensuite pour chaque nombre de
clusters, on calcule la somme des variances intra-cluster, qui est généralement mesurée par la
somme des carrés des distances entre chaque point et le centre de cluster auquel il est assigné.
Après on trace un graphique du nombre de clusters sur l'axe des x et de la somme des variances
intra-cluster sur l'axe des y. on analyse la courbe et on recherche le point détournement (coude)
où l'ajout de plus de clusters ne réduit pas significativement la somme des variances intra-
cluster. Le nombre de clusters correspondant au point de retournement est souvent choisi
comme le nombre optimal de clusters.

Page 5 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

• Méthode du coefficient de silhouette (Silhouette coefficient) :

Cette méthode permet d'évaluer la qualité des clusters créés grâce aux algorithmes de
clustering. Compris entre [-1,1], le score silhouette est parfois utilisé pour trouver la valeur
optimale du nombre de clusters « k ». Pour ce faire, on considère la valeur de « k » ayant le
score de silhouette le plus proche de 1. Autrement dit, Pour un point de données donné,
calculez la distance moyenne entre ce point et tous les autres points du même cluster. Cela
donne la cohésion intra-cluster (a). Pour le même point de données, calculez la distance
moyenne entre ce point et tous les points d'un autre cluster voisin. Cela donne la séparation
inter-cluster (b). Le coefficient de silhouette pour ce point est alors calculé comme suit :
(𝒃−𝒂)
silhouette = 𝐦𝐚𝐱⁡(𝒂,𝒃).Répétez les étapes 1 à 3 pour tous les points de données et calculez la
moyenne des coefficients de silhouette pour obtenir le score de silhouette global.

1. Sélectionnez aléatoirement k points de données pour servir de centres de

cluster initiaux :

Pour sélectionner aléatoirement k points de données pour servir de centres de cluster

initiaux, on peut utiliser la méthode de Forgy ou la méthode de partitionnement aléatoire :

i. La méthode de Forgy :

Cette méthode est l’une des méthodes d’initialisation les plus rapides pour les k-Means.
Si nous choisissons d’avoir k clusters, la méthode Forgy choisit k points parmi les données au
hasard comme points initiaux. Cette méthode a du sens car les clusters détectés par k-Means
sont plus susceptibles d’être proches des modes présents dans les données. En choisissant au
hasard des points à partir de données, nous rendons plus probable l’obtention d’un point proche
des modes.
ii. La méthode de partitionnement aléatoire :

Dans cette méthode, nous attribuons aléatoirement chaque point des données à un ID de
cluster aléatoire. Ensuite, nous regroupons les points en fonction de leur ID de cluster et
prenons la moyenne (par ID de cluster) pour obtenir les points initiaux. La méthode de partition
aléatoire est connue pour produire des points initiaux proches de la moyenne des données. En

Page 6 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

d’autres mots, Au départ, nous avons un ensemble de points de données que nous souhaitons
regrouper en clusters. Pour initialiser le processus de clustering, nous attribuons aléatoirement
à chaque point de données un identifiant de cluster (par exemple, un nombre de 1 à k, où k est
le nombre de clusters souhaité). Ensuite, nous regroupons les points de données en fonction de
leur identifiant de cluster. Cela signifie que tous les points ayant le même identifiant de cluster
sont regroupés ensemble. Pour chaque cluster, nous calculons le centre de gravité du cluster en
prenant la moyenne des coordonnées de tous les points qui lui sont assignés. Ce centre de
gravité est généralement appelé "centroid" ou "moyenne du cluster ». Les centroïdes calculés
deviennent les points initiaux pour les itérations suivantes des algorithmes de clustering, tels
que les itérations du k-means.

2. Pour chaque point de données, attribuez-le au centre de cluster le plus

proche en fonction de la distance entre le point et les centres :
La distance utilisée est généralement la distance euclidienne, mais cela peut dépendre
de la mesure de distance choisie pour l‘algorithme de clustering choisi. Si plusieurs centres de
cluster ont la même distance minimale, on peut choisir l'un d'entre eux de manière aléatoire ou
en utilisant une règle spécifique.

3. Une fois que tous les points de données ont été attribués à un centre de
cluster, recalculez les nouveaux centres en prenant la moyenne des points
de données de chaque cluster :

Pour chaque cluster, on calcule la moyenne de toutes les coordonnées des points de
données qui lui sont attribués. Par exemple, si on travaille avec des données bidimensionnelles
ou chaque point à des coordonnées (x, y), on calcule la moyenne des coordonnées x et y des
centres de cluster. Les moyennes calculées deviennent les nouvelles coordonnées des centres
de cluster. Ainsi, chaque centre de cluster sera déplacé vers le centre de gravité de ses points de
données associés.
4. Répétez les étapes 3 et 4 jusqu'à ce que les centres de cluster ne changent
plus ou jusqu'à ce qu'un critère d'arrêt prédéfini (comme un nombre
maximum d'itérations) soit atteint.
Le nombre d’itérations maximum dans l’algorithme K-means est un hyper paramètre
qui peut être ajusté pour améliorer la performance de l’algorithme. En général, le nombre
d’itérations est fixé à un nombre suffisamment élevé pour que les centres de cluster convergent
vers une solution stable. Cependant, un nombre d’itérations trop élevé peut entraîner un temps
de traitement plus long et un sur ajustement des données.
Il n’y a pas de règle stricte pour choisir le nombre d’itérations maximum. Cependant, il
est recommandé de commencer par un nombre d’itérations élevé, puis de réduire
progressivement le nombre d’itérations jusqu’à ce que la performance de l’algorithme ne
s’améliore plus. En général, un nombre d’itérations compris entre 100 et 1000 est suffisant
pour la plupart des applications.

5. Les clusters formés contiennent des points de données similaires, c'est-à-

dire que les points à l'intérieur d'un même cluster sont plus proches les uns
des autres que des points d'autres clusters.

Page 7 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

c) ALGORITHME CLASSIQUE K-MEANS :

Entrée
Ensemble de N données, notés par x
Nombres de groupes souhaités
Sortie
Une partition de K groupes {C1, C2,… Ck}
Début
1) Initialisation aléatoire des centres Ck ;

Répéter

2) Affectation : générer une nouvelle partition en assignant chaque objet au groupe dont le centre
est le plus proche :

Xiϵ Ck si pour tout j |Xi-µk|=min|Xi-µj|

Avec µk le centre de la classe K ;

3) Représentation : calculer les centres associés à la nouvelle partition :

µk=𝑁1 ∑𝑋𝜖𝑐𝑘 𝑥𝑖
Jusqu’à convergence de l’algorithme vers une partition stable ;
Fin.

Page 8 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

d) ORGANIGRAMME CLASSIQUE ALGORITHME K-MEANS :

Début

Entrez le paramètre k et x du
processus de clustering

Initialisez les k centres des clusters

Affectez chaque objet de données à

la classe la plus proche

Recalculer le centre des clusters

Non Déterminer si Enregistrer les informations

le résultat Oui correspondantes des k centres de
satisfait la clusters
condition pour
stopper les
itérations Sortir le résultat

fin

Page 9 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

e) AVANTAGES ET INCONVENIENTS DE LA METHODE K-MEANS :

1. AVANTAGES :

➢ L’algorithme K-means est facile à comprendre et à mettre en œuvre.

➢ Les résultats de l’algorithme K-means sont faciles à interpréter. Il génère des
descriptions de cluster sous une forme minimisée pour maximiser la
compréhension des données.
➢ Pour le traitement de grands ensembles de données, l’algorithme conserve son
évolutivité et son efficacité.
➢ L’algorithme K-means est rapide et efficace en termes de coût de calcul. Sa
complexité est O (K * n * d).

2. INCONVENIENTS :

➢ Le nombre de classe doit être fixé au départ.

➢ Le résultat dépend de tirage initial des centres des classes.
➢ Les clusters sont construits par rapports à des objets inexistants (les milieux).

f) EXERCICE D’APPLICATION :

Comme exercice d’application, nous allons utiliser le k-Means pour la segmentation de

la clientèle.

DATASET UTILISE : https://www.kaggle.com/datasets/akram24/mall-customers/

1. Importation des bibliothèques :

• « Numpy » :
Numpy est une bibliothèque Python très populaire qui est principalement utilisée pour
effectuer des calculs mathématiques et scientifiques. Elle introduit une gestion facilitée des
tableaux de nombres. Elle fournit des structures de données de base, telles que les tableaux

Page 10 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

multidimensionnels, qui sont essentielles pour effectuer des calculs numériques efficaces.
Numpy offre une vaste gamme de fonctions mathématiques et d'opérations de manipulation de
tableaux, ce qui en fait un outil incontournable en Machine Learning.
• « Pandas »:
Pandas est une bibliothèque du langage de programmation Python, entièrement dédiée
à la Data Science. Grâce à Pandas, le langage Python permet enfin de charger, d’aligner,
de manipuler ou encore de fusionner des données. Le fonctionnement de Pandas repose sur les
« Data frame » : des tableaux de données en deux dimensions, dont chaque colonne contient les
valeurs d’une variable et chaque ligne contient un ensemble de valeurs de chaque colonne. Les
données stockées dans un Data frame peuvent être des nombres ou des caractères.

• « Matplotlib » :
Est une bibliothèque qui permet d’améliorer l’aspect visuel des graphiques notamment
en ajoutant un titre et des légendes, mais aussi en choisissant le style et la couleur des
visualisations. Il est aussi possible de jouer sur la taille des figures ainsi que de choisir la
disposition des graphiques si vous choisissez d’afficher plusieurs graphiques dans une même
figure. Elle permet : le tracé des fonctions, faire des graphique 2D,3D, faire des widgets…

• « Seaborn » :
Est une bibliothèque python qui offre la possibilité de résumer et de visualiser des
données. Elle permet de créer de jolis graphiques statistiques en python. Cette bibliothèque
apporte des fonctionnalités inédites qui favorisent l’exploration des données. Seaborn facilite la
création de graphiques tels que des diagrammes de dispersion, des histogrammes, des
diagrammes en boîte, des graphiques à barres et bien d'autres. Elle fournit également des
fonctionnalités avancées pour la visualisation de modèles de données complexes, tels que les
matrices de corrélation et les graphiques de régression. Seaborn permet d'ajouter des palettes de
couleurs esthétiques et de personnaliser facilement l'apparence des graphiques, ce qui en fait un
outil précieux pour communiquer et interpréter les résultats des modèles de Machine Learning.

• « from sklearn. Preprocessing import StandardScaler » :

La ligne de code from sklearn. preprocessing import StandardScaler importe la classe
StandardScaler du module sklearn.preprocessing de la bibliothèque scikit-learn.
« StandardScaler » est une classe de la bibliothèque scikit-learn qui permet de standardiser les
caractéristiques d’un ensemble de données en supprimant la moyenne et en mettant à l’échelle
la variance unitaire.

2. Importation du data set :

• « "C:/Users/LENOVO/Downloads/Mall_customers.csv" » : Cette ligne charge le

fichier CSV " Mall_customers.csv" à partir de l'emplacement spécifié dans le chemin

Page 11 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

d'accès complet. La fonction « read_csv » de pandas est utilisée pour lire les données du
fichier CSV et les stocker dans un objet appelé df.

a) Premières lignes du data set :

• « df. head ()»: Cette ligne affiche les premières lignes du Data frame . La méthode head () visualise,
par défaut les cinq premières lignes du data set. Cela peut être modifié en mettant le nombre de
lignes souhaité entre les parenthèses.

b) Types de chaque colonne et nombre non nuls :

• « df.info () » : Est une méthode de la bibliothèque pandas qui fournit des

informations sur un objet data frame. Elle affiche le nombre total de lignes et de
colonnes dans le data frame, ainsi que le nombre de valeurs non nulles pour chaque
colonne. Elle fournit également des informations sur le type de données de chaque
colonne et la quantité de mémoire utilisée par le data frame.

Page 12 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

On se rends compte qu’au total, on a 5 colonnes dont 4 ont pour types des entiers code
sur 64 bits, une ayant pour type des objets et 200 lignes. Dans ce data set il y’a aucun nombre
nul.

c) Dimension du data set :

• « df.shape » :cette ligne de code renvoie un tuple représentant la dimensionnalité

du Data Frame . Le tuple contient deux éléments, le nombre de lignes et le nombre de
colonnes du Data Frame.

Notre data set a donc 200 lignes et 5 colonnes.

d) Description sommaire du data set :

• « df. describe() » : cette ligne de code fournit des statistiques descriptives pour un objet
Data Frame . Elle calcule des statistiques telles que la moyenne, l’écart type, le
minimum, le maximum et les quartiles pour chaque colonne numérique du Data Frame.
Les colonnes non numériques sont ignorées par défaut.

Page 13 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

e) Renommer les variables "Annula Income (k)" en 'Income' et 'Spending

Score (1-100)' en 'Score' :

On renomme ces variables pour pouvoir mieux les manipuler dans la suite du data
set.

f) Affichage du paire plot de la colonne genre (mâle - femelle) :

• « X = df.drop(['Customer ID', 'Genre'], axis=1) » :ligne de code crée un nouveau Data

Frame X en supprimant les colonnes Customer ID et Genre du Data Frame df 1. La
méthode drop () est utilisée pour supprimer les colonnes spécifiées, et l’argument axis=1
indique que les colonnes doivent être supprimées plutôt que les lignes.

• « sns.pairplot(df.drop('Customer ID', axis=1), hue='Genre', aspect=1.5) »:cette

ligne de code utilise la bibliothèque seaborn pour créer une matrice de graphiques de
dispersion pour chaque paire de variables dans le Data Frame df. L’argument
hue='Genre' indique que les points doivent être colorés en fonction de la valeur de la
colonne Genre. L’argument aspect=1.5 spécifie le rapport hauteur/largeur des
graphiques.

• « plt.show() »La troisième ligne de code affiche les graphiques créés à l’aide de la
méthode show() de matplotlib.pyplot.
Ainsi on obtient les graphes ci-dessous :

Page 14 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

ANALYSE : Le graphique ci-dessus montre que le sexe n'a pas de rapport direct
avec la segmentation de la clientèle.

a) Utilisation de la règle du coude (Elbow Rule) :

• « From sklearn. cluster import KMeans explication » : cette ligne de code

est une commande qui permet d’importer la classe KMeans. KMeans est une

Page 15 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

classe de la bibliothèque scikit-learn qui implémente l’algorithme de clustering

K-means. Elle nous permet de créer une instance de la classe en spécifiant le
nombre de clusters que l’on souhaite créer à l’aide de l’argument n_clusters,
spécifier d’autres paramètres tels que la méthode d’initialisation des centres de
cluster et le nombre d’itérations de l’algorithme etc…
• « Clusters = [] » : cette ligne de code crée une liste vide appelée clusters. Cette
liste sera utilisée pour stocker les valeurs d'inertie calculées à chaque itération
de la boucle ultérieurement dans le code.

• « for i in range (1, 11): » Cette boucle itère sur les nombres de 1 à 10. Cela
signifie que la boucle sera exécutée 10 fois, à chaque itération la valeur de i sera
mise à jour.

• « km = KMeans(n_clusters=i).fit(X) » : cette ligne de code cree un objet

KMeans avec n_clusters=i, où i est la valeur actuelle de la variable de boucle.
Cela signifie que chaque itération de la boucle, un nouveau modèle KMeans est
créé avec un nombre de clusters différent. Ensuite, le modèle est ajusté aux
données X.

• « clusters. append (km. inertia_) » : La valeur d'inertie du modèle KMeans

ajusté est ajoutée à la liste clusters. L'inertie est une mesure de la cohérence des
points dans chaque cluster. Une faible inertie indique que les points à l'intérieur
de chaque cluster sont similaires.

• « fig, ax = plt.subplots(figsize=(12, 8)) » : Cette ligne de code crée une

nouvelle figure et un nouvel axe (subplot) pour tracer le graphique. La figure a
une taille de 12 pouces de largeur et 8 pouces de hauteur.

• « sns.lineplot(x=list(range(1, 11)), y=clusters, ax=ax) » : Cette ligne de code

trace un graphique de ligne à partir des données fournies. Les valeurs de x
correspondent aux nombres de clusters (1 à 10), et les valeurs de y
correspondent aux valeurs d'inertie stockées dans la liste clusters. L'axe ax
spécifie l'axe sur lequel le graphique doit être tracé.

• « ax.set_title('Searching for Elbow') » : Cette ligne de code définit le titre du

graphique comme "Searching for Elbow".

• « ax.set_xlabel('Clusters') »: Cette ligne de code définit le label de l'axe des

abscisses comme "Clusters".

• « ax.set_ylabel('Inertia') » : Cette ligne de code définit le label de l'axe des

ordonnées comme "Inertia".

Page 16 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

b) Affichage des graphiques :

• « ax. annotate ('Possible Elbow Point', xy=(3, 140000), xytext=(3, 50000),

xycoords='data', arrowprops=dict(arrowstyle='->', connectionstyle='arc3',
color='blue', lw=2)) » : Cette ligne de code ajoute une annotation à l'axe ax du
graphique. L'annotation est placée à la position (3, 140000) sur le graphique,
avec le texte "Possible Elbow Point". L'argument xycoords='data' indique que
les coordonnées sont spécifiées en utilisant les coordonnées des données.
L'argument arrowprops spécifie les propriétés de la flèche utilisée pour indiquer
l'annotation, telles que le style de la flèche, le style de connexion et la couleur.

• « ax. annotate('Possible Elbow Point', xy=(5, 80000), xytext=(5, 150000),

xycoords='data', arrowprops=dict(arrowstyle='->', connectionstyle='arc3',
color='blue', lw=2)) » : Cette ligne de code ajoute une deuxième annotation à
l'axe ax du graphique. L'annotation est placée à la position (5, 80000) sur le
graphique, avec le même texte "Possible Elbow Point". Comme pour la
première annotation, les coordonnées sont spécifiées en utilisant les
coordonnées des données et les propriétés de la flèche sont définies par
l'argument arrowprops.

• « plt.show() » : Cette ligne affiche le graphique complet avec toutes les

annotations ajoutées. Elle est généralement utilisée à la fin du code de traçage
pour afficher le graphique à l'écran.

ANALYSE :
Comme on peut le voir sur le graphique, on peut dire que le coude peut être 3 ou 5. pour
faire le choix, nous allons utiliser les deux valeurs de k et voir laquelle a un meilleur rendu.

Page 17 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

a) kmeans pour k=3 et Kmeans avec K = 5 :

Ces codes utilise l'algorithme KMeans avec 5 et 3 clusters. Il ajuste le modèle KMeans
aux données `X` et attribue des étiquettes de cluster à chaque point de données. Ensuite, un
nuage de points est tracé pour représenter les données en fonction des revenus et des scores, en
utilisant les étiquettes de cluster pour colorer les points à l’aide de la fonction
sns.scatterplot(X['Income'], X['Score'], hue=X['Labels'], palette=sns.color_palette('hls',
5)). Cela permet de visualiser la structure des données et de voir comment les points sont
regroupés en fonction de leurs caractéristiques.

Page 18 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

ANALYSE :
On se rends compte que le nombre de clusters le mieux adaptés est 5.

a) Variation des revenus annuelles et des dépenses annuelles :

Page 19 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

• « fig = plt.figure(figsize=(20, 8)) » : Cette ligne de code crée une nouvelle figure avec une
taille de 20 pouces de largeur et 8 pouces de hauteur. La figure est stockée dans la variable
fig et sera utilisée pour les sous-graphiques à venir.

• « ax = fig.add_subplot(121 ) » : Cette ligne de code crée le premier sous-graphique dans

une grille de 1 ligne et 2 colonnes. Le chiffre 121 signifie qu'il y a une seule ligne et deux
colonnes, et le sous-graphique actuel est le premier (le chiffre 1). L'objet ax est créé pour
représenter ce sous-graphique.

• « sns.swarmplot(x='Labels', y='Income', data=X, ax=ax) » : Cette ligne trace un graphique

de type "swarm plot" utilisant les données du DataFrame X. L'axe des abscisses (x)
représente les étiquettes de cluster, et l'axe des ordonnées (y) représente les revenus . Les
points sont répartis horizontalement autour de chaque étiquette de cluster, permettant de
visualiser la distribution des revenus pour chaque cluster.

• « ax.set_title('Labels According to Annual Income') » : Cette ligne définit le titre du premier

sous-graphique comme "Labels According to Annual Income".

• « ax = fig.add_subplot(122) » : Cette ligne crée le deuxième sous-graphique dans la grille de

1 ligne et 2 colonnes. Le chiffre 122 signifie qu'il y a une seule ligne et deux colonnes, et le
sous-graphique actuel est le deuxième (le chiffre 2). Un nouvel objet ax est créé pour
représenter ce sous-graphique.

• « sns.swarmplot(x='Labels', y='Score', data=X, ax=ax) » : Cette ligne trace un deuxième

graphique de type "swarm plot" utilisant les données du dataframe X. Cette fois-ci, l'axe des
abscisses (x) représente toujours les étiquettes de cluster, mais l'axe des ordonnées (y)
représente maintenant les scores. Les points sont répartis horizontalement autour de
chaque étiquette de cluster, permettant de visualiser la distribution des scores pour chaque
cluster.

• « ax.set_title('Labels According to Scoring History') » : Cette ligne définit le titre

du deuxième sous-graphique comme "Labels According to Scoring History".

Page 20 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

ANALYSE : on se rends compte qu'on peut enfin donner un nom à nos groupes :
Cluster 0 correspond aux revenus faibles et dépenses faibles
Cluster 1 correspond aux revenus élevés et dépenses élevés
Cluster 2 correspond aux revenus élevés et dépenses faibles
Cluster 3 correspond aux revenus moyens et dépenses moyens
Cluster 4 correspond aux revenus faibles et dépenses élevés

b) Application de l'algorithme kmeans :

• « x=df.iloc[:,[3,4]].values »: Cette ligne de code sélectionne les colonnes 3 et 4 du

dataframe df et les convertit en un tableau numpy.

• « kmeansmodel = KMeans(n_clusters = 5 , init = "means++",random_state=0) »:

Cette ligne de code crée un objet KMeans avec 5 clusters, une initialisation “k-
means++” et une graine aléatoire de 0.

Page 21 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

• « y_kmeans = kmeansmodel.fit_predict(x) »: Cette ligne de code effectue l’analyse

de clustering K-means sur les données x et stocke les étiquettes de cluster dans
y_kmeans.

• « plt.scatter(x[y_kmeans==0,0],x[y_kmeans==0,1],s=100,c="red",label =
"revenus faibles et dépenses faibles") »: Cette ligne de code trace un nuage de
points pour les points appartenant au cluster 0. Les points sont affichés en rouge avec
une taille de 100 et une étiquette “revenus faibles et dépenses faibles”.

• « plt.scatter(x[y_kmeans==1,0],x[y_kmeans==1,1],s=100,c="blue",label =
"revenus eleve et dépenses eleves") »: Cette ligne de code trace un nuage de points
pour les points appartenant au cluster 1. Les points sont affichés en bleu avec une
taille de 100 et une étiquette “revenus eleve et dépenses eleves”.

• « plt.scatter(x[y_kmeans==2,0],x[y_kmeans==2,1],s=100,c="green",label =
"revenu eleve et dépenses faibles") »: Cette ligne de code trace un nuage de points
pour les points appartenant au cluster 2. Les points sont affichés en vert avec une
taille de 100 et une étiquette “revenu eleve et dépenses faibles”.

• « plt.scatter(x[y_kmeans==3,0],x[y_kmeans==3,1],s=100,c="cyan",label =
"revenus moyens et dépenses moyens") »: Cette ligne de code trace un nuage de
points pour les points appartenant au cluster 3. Les points sont affichés en cyan avec
une taille de 100 et une étiquette “revenus moyens et dépenses moyens”.
• « plt.scatter(x[y_kmeans==4,0],x[y_kmeans==4,1],s=100,c="magenta",label =
"revenu faibles et dépenses eleves") »: Cette ligne de code trace un nuage de points
pour les points appartenant au cluster 4. Les points sont affichés en magenta avec une
taille de 100 et une étiquette “revenu faibles et dépenses eleves”.

• « plt.scatter(kmeansmodel.cluster_centers_[:,0],kmeansmodel.cluster_centers_[:,
1],s=300,c="yellow",label="centroids") »: Cette ligne de code trace les centres de
cluster pour chaque cluster. Les centres de cluster sont affichés en jaune avec une
taille de 300 et une étiquette “centroids”.

• « plt.title("clusters of customers") »: Cette ligne de code ajoute un titre au

graphique.

• « plt.xlabel("Yıllık gelir") »: Cette ligne de code ajoute une étiquette d’axe x au

graphique.

• « plt.ylabel=("harcama skoru") »: Cette ligne de code ajoute une étiquette d’axe y

au graphique.

• « plt.legend(loc='center left', bbox_to_anchor=(1, 0.5)) »: Cette ligne de code

ajoute une légende au graphique.

• « plt.show() »: Cette ligne de code affiche le graphique.

Page 22 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

Ainsi, nous avons fait une classification supervisé en utilisant le K-means pour la
segmentation de la clientèle.

III. ALGORITHME DBSCAN

1. Principe de base
Étant donnés des points et un entier k, l’algorithme vise à diviser les points en k
groupes, appelés clusters, homogènes et compacts.
Le DBSCAN est un algorithme simple qui définit des clusters en utilisant l’estimation
de la densité locale. On peut le diviser en 4 étapes :

• Pour chaque observation on regarde le nombre de points à au plus une distance ε de celle-
ci. On appelle cette zone le ε-voisinage de l’observation.
• Si une observation compte au moins un certain nombre de voisins y compris elle-même,
elle est considérée comme une observation cœur. On a alors décelé une observation à
haute densité.
• Toutes les observations au voisinage d’une observation cœur appartiennent au même
cluster. Il peut y avoir des observations cœur proche les unes des autres. Par conséquent
de proche en proche on obtient une longue séquence d’observations cœur qui constitue un
unique cluster.
• Toute observation qui n’est pas une observation cœur et qui ne comporte pas
d’observation cœur dans son voisinage est considérée comme une anomalie.

Page 23 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

2. Concepts clé de dbscan :

• Définition 1 :
le 𝜀 −voisinage d’un point⁡𝑝 noté D est défini par :
𝑵𝜺 (𝒑) = {𝒒 ∈ 𝑫/𝒅(𝒑, 𝒒) ≤ 𝜺}⁡
où 𝜀⁡𝜖⁡𝑅 + et 𝑑(𝑝, 𝑞) est la distance entre les points 𝑞 et 𝑝. La distance euclidienne
est généralement utilisée.
NB : 𝒑⁡𝝐⁡𝑵𝜺 (𝒑).
• Définition 2.
• La densité en un point 𝑝 est le nombre de point intérieur au cercle de rayon 𝜀 formé
autour de 𝑝.
• Un point 𝑝 est un point dit central (core point) si|𝑁𝜀 (𝑝)| ≥ 𝑀𝑖𝑛𝑃𝑡𝑠, 𝑀𝑖𝑛𝑃𝑡𝑠𝜖⁡𝑁
• Un point p est un point frontière (borde point) si |𝑁𝜀 (𝑝)| ≤ 𝑀𝑖𝑛𝑃𝑡𝑠, mais 𝑝⁡𝜖⁡𝑁𝜀 (𝑤) et
𝑤 est un point central.
• Un point 𝑝 est un point dit aberrant (noise point) si 𝑝 n’est pas un point central ou un
point frontière.

• Définition 3(directly density-reachable)

Un point 𝑝 est dit directement accessible par la densité à partir d’un point 𝑞 si
• 𝒑⁡𝝐⁡𝑵𝜺 (𝒒).
• |𝑵𝜺 (𝒒)| ≥ 𝑴𝒊𝒏𝑷𝒕𝒔

A noter que cette relation est symétrique entre deux points centraux, mais ne l’est
généralement pas entre un point central et un point frontière.

• Définition 4(density-reachable)
Un point 𝑝 est dit accessible par la densité à partir d’un point 𝑞 s’il existe une séquence
de points (𝑝1 , 𝑝2 , … , 𝑝𝑛 ) où 𝑝1 = 𝑞 , 𝑝𝑛 = 𝑝, 𝑝𝑖+1 est directement accessible par la densité à
partir de 𝑝𝑖 , ∀𝑖 ∈ {1,2, … , 𝑛 − 1}.
Cette relation est transitive, mais pas symétrique.
• Définition 5(density-conected)
Un point 𝑝⁡est connecté par densité la densité à un point 𝑞 s’il existe un point 𝑚 tel que
𝑝⁡𝑒𝑡⁡⁡q sont accessibles par la densité à partir de ⁡𝑚.
Cette relation est symétrique.
• Définition 6
Un cluster 𝐶 est un ensemble non vide de points appartenant à 𝐷 qui respecte les
conditions suivantes :
• ∀(𝑝, 𝑞), 𝑠𝑖⁡𝑝 ∈ 𝐶 et 𝑞 accessible par la densité à partir de 𝑝, 𝑞 ∈ 𝐶 .
• ∀(𝑝, 𝑞), 𝑝 est connecté par la densité à 𝑞.

Page 24 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

• Lemme 7
Soit le point 𝑝 ∈ 𝐷 et |𝑁𝜀 (𝑝)| ≥ 𝑀𝑖𝑛𝑃𝑡𝑠. Alors,
𝑂 = {𝑜|𝑜 ∈ 𝐷⁡, o⁡accessible⁡par⁡la⁡densité⁡à⁡partir⁡de⁡p} est un cluster.
Lemme 8
Soit 𝐶 un cluster et 𝑝 ∈ 𝐶 tel que |𝑁𝜀 (𝑝)| ≥ 𝑀𝑖𝑛𝑃𝑡𝑠. Alors,
𝐶 = 𝑂 = {𝑜|𝑜 ∈ 𝐷⁡, o⁡accessible⁡par⁡la⁡densité⁡à⁡partir⁡de⁡p}.
• Définition 9
Soit 𝐶1 , 𝐶2 , … , 𝐶𝑘 les clusters de 𝐷. Le Bruit B est défini par :
𝑩 = {𝒑 ∈ 𝑫|∀𝒊 ∶ 𝒑 ∉ 𝑪𝒊 }

3. ETAPES DE L’ALGORITHME :

❖ 𝐸1 : commencer toujours par un point aléatoire 𝑝 qui n’a pas été visité et calculer
𝑁𝜀 (𝑝)⁡𝑒𝑡 |𝑁𝜀 (𝑝)|.
❖ 𝐸2 :Si 𝑝 est un point central, alors un nouveau cluster est crée avec les points
appartenant à 𝑁𝜀 (𝑝). Si un point 𝑞 ∈ 𝑁𝜀 (𝑝) est également un point central , 𝑁𝜀 (𝑞) est
ajouté au cluster. S’il n’y a plus de points centraux dans le voisinage étendu, alors le
cluster est complet et finalisé.
❖ 𝐸3 : Si 𝑝 n’est pas un point central, il est considéré comme un Bruit pour l’instant.
❖ 𝐸4 : Les étapes 𝐸1⁡, 𝐸2 et 𝐸3 sont répétés avec un nouveau point.
❖ 𝐸5 : Après avoir explorer tous les points, les points toujours seuls sont identifiés comme
du Bruit.

Page 25 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

4. AVANTAGES ET INCONVÉNIENTS

1. Avantages :

➢ On n’a pas besoin de définir au préalable le nombre de cluster à trouver.

➢ On peut trouver les clusters de toute forme.
➢ L’algorithme gère bien les données aberrantes en les identifiant.
➢ L’algorithme demande seulement deux paramètres en entrée.
➢ Un des avantages de cette algorithme est qu’il fonctionne mieux avec beaucoup
de données.

2. Inconvénients :

➢ L’algorithme est moins performant lorsque les clusters sont de densités variées
étant donné que les paramètres sont globaux.
➢ Vue que les points frontières peuvent se retrouver dans différents clusters
dépendamment de l’ordre de visite des points alors cet algorithme n’est plus
certain malgré le fait que cette circonstance est très rare.
➢ L’algorithme est très sensible aux valeurs des paramètres.

5. EXEMPLE D’APPLICATION :
Utilisation de l’algorithme DBSCAN pour grouper l’Annula Income et le Spending
Score du des clients du Mall dont le data set est Mall_customers.

❖ Importation des bibliothèques

Import numpy as np
Import matplotlib.pyplot as plt
import pandas as pd

❖ Importation du datasetbet affichage des cinq premières lignes

df=pd.read_csv("Mall_Customers.csv")
df.head()

Page 26 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

❖ Affichage des dernières lignes du data set et les nombres de lignes et

colonnes

❖ Importation des bibliothèques importante pour estimer le nombre de

clusters
From sklearn.cluster, import KMeans
Import seaborn as sns
From sklearn.preprocessing import StandardScaler

❖ Estimation du nombre de clusters

❖ wcss=[]
❖ for i in range(1,11):
❖ kmeans=KMeans(n_clusters=i,init='k-means++',max_iter=300,n_init=10)
❖ kmeans.fit(df)
❖ wcss.append(kmeans.inertia_)
❖ plt.plot(range(1,11),wcss)

Page 27 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

❖ plt.title("the Elblow method")

❖ plt.xlabel("number of clusters")
❖ plt.ylabel("WCSS")
❖ plt.show()
❖
le résultat du tracer est le suivant

❖ importation et définition de dbscan

from sklearn.cluster import DBSCAN
dbscan=DBSCAN(eps=5,min_samples=5)

❖ Appellation de l’algorithme dbscan

labels=dbscan.fit_predict(df)

❖ Tracer du nuage

Page 28 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

❖ Résultat du tracer

IV. COMPARAISON ENTRE K-MEANS ET DBSCAN

Quelque points clés sur le k-means :

- Le k-means nécessite de spécifier a priori le nombre de clusters que l’on souhaite obtenir,
ce qui peut être un défi lorsque ce nombre est inconnu.
- Il est sensible à l’initialisation de centroides et peut converger vers des optimums locaux.
- Les clusters produits par k-means sont de forme sphérique et ont une taille similaire.

Quelque points clés sur le DBSCAN :

Page 29 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

- Le DBSCAN identifie les clusters en se focalisent sur la densité des points dans l’espace
des données, ce qui lui permet de trouver des clusters de forme complexes.
- Il est capable de détecter les points aberrants(outiliers) en tant que bruit (noise) et de les
exclure des clusters.
- DBSCAN peut gérer des clusters de densités différentes, ce qui en fait un choix plus
robuste pour certaines distributions de données

V. CONCLUSION

En conclusion K-means et DBSCAN sont deux algorithmes de classification non

supervisée couramment utilisés. K-means est un algorithme de clustering qui vise à partitionner
un ensemble de données en K clusters. Il fonctionne en minimisant la somme des carrés des
distances entre les points et leur centroïde respectif. DBSCAN, quant à lui, est un algorithme
de clustering qui identifie les régions de haute densité de points. Il est capable de trouver des
clusters de formes arbitraires et de gérer les valeurs aberrantes. Les deux algorithmes ont leurs
avantages et leurs inconvénients et sont utilisés dans divers domaines

Page 30 sur 31
 PROJET DE MACHINE LEARNING K-MEANS ET DBSCAN

SOURCE :

• kMeans : Stratégies d’initialisation - kmeans++, forgy, partition aléatoire | Analytique Vidhya

(medium.com)
• Machine Learning - Non supervisé - Correction | Kaggle (en anglais seulement)
• datascientest.com
• https://www.datacamp.com/tutorial/k-nearest-neighbor-classification-scikit-
learn
• https://www.datacamp.com/tutorial/svm-classification-scikit-learn-python
• https://blog.paperspace.com/implementing-support-vector-machine-in-python-
using-sklearn/
• geeksforgeeks.org
• machinelearningknowledge.ai
• datascientest.com
• datacamp.com
• scikit-learn.org
• stackoverflow.com
• analyticsvidhya.com

Page 31 sur 31