Dans ce TP, nous abordons la classification non supervisée, en particulier les méthodes de partitionnement, ou segmentation, de données, clustering en anglais.
On pourra consulter mes notes de cours de fouille de données pour une présentation de la classification non supervisée (chapitre 10).
À l'issue de ce TP, vous m'envoyez par email un compte-rendu (format pdf) indiquant la réponse aux questions qui sont posées. Vous m'envoyez également un fichier python réalisant toutes les manipulations de ce TP : je dois pouvoir exécuter ce fichier en tapant python3 nom-de-votre-fichier.py et reproduire vos résultats. Cette exécution ne doit pas provoquer d'erreur de python. Remarque : un notebook ne convient pas.
Nous allons étudier la méthode probablement la plus connue, les k-moyennes (k-means en anglais) qui a été décrite en cours. Au besoin, se référer à mon polycopié concernant cette méthode.
Par rapport à la classification supervisée, la classification non supervisée a ceci de particulier que l'on ne connait pas la valeur à prédire. Aussi, juger de la qualité d'un partitionnement est-il quelque chose qui est difficile à juger.
Là encore, à chaque fois que cela est possible, une exploration visuelle des données est essentielle que ce soit avant d'appliquer un algorithme de partitionnement de données pour essayer de voir ce qu'il semble raisonnable que l'algorithme produise et ensuite, pour juger le résultat produit par l'algorithme. Comme tous les algorithmes, ceux de partionnement font toujours quelque chose, il calcule toujours un résultat. Ils sont incapables de juger si ce qu'ils ont fait est pertinent : seul l'humain peut le déterminer en anticipant sur le résultat que devrait produire l'algorithme et en jugeant le résultat produit par l'algorithme.
KMeans () de scikit_learn
On utilise la méthode KMeans () de scikit_learn. Sous sa forme la plus simple, on l'utilise comme suit. On commence par créer un objet Kmeans :
partitionneur = sklearn.cluster.KMeans (nombre_de_parties, random_state)
que l'on peut ensuite appliquer à un jeu de données contenu dans une matrice X :
partition = partitionneur. fit (X)
L'objet partition contient différentes informations :
partition. clusters_centers_ contient les coordonnées des centroïdes,partition. labels_ contient le numéro de partie de chaque donnée,partition. inertia_ contient l'inertie intraclasse de la partition.
Les deux paramètres de KMeans () indiqués plus haut sont :
nombre_de_parties qui spcifie le nombre de parties qui doivent être constituées (donc le nombre de centroïdes),random_state que l'on a rencontré au semestre précédent.
On va mettre en application la méthode KMeans () sur ce jeu de données.
Pour cela :
KMeans ()
L'une des difficultés rencontrées en partitionnement de données concerne la détermination du nombre de parties. Sur l'exemple que nous venons de traiter, ce nombre est évident, il saute aux yeux. Sur des données réelles, c'est rarement le cas. On va utiliser ce jeu de données très simple pour voir comment déterminer ce nombre de parties vraisemblablement le meilleur. On va voir deux méthodes, l'une basée sur l'inertie, l'autre sur le score de silhouette.
Dans les deux cas, l'idée est simple : on calcule des partitions avec des nombres de parties variant par exemple de 2 à 10 et on utilise un score pour déterminer le « bon » nombre de parties.
Déterminer le nombre de groupes avec l'inertie
Effectuer des partitionnements pour un nombre de parties variant de 2 à 10. Pour chaque partitionnement, stocker son inertie dans une liste. Ensuite, visualiser l'inertie en fonction du nombre de groupes et déterminer le coude.
Que trouvez-vous ?
Déterminer le nombre de groupes par le score de silhouette
Le principe est le même mais avant cela, je dois expliquer comment on calcule le coefficient de silhouette.
On utilise la méthode sklearn.metrics.silhouette_score (X, cluster_labels) où X est le jeu de données à partionner et cluster_labels est le numéro de partie assigné à chaque donnée.
Effectuer des partitionnements pour un nombre de parties variant de 2 à 10. Pour chaque partitionnement, calculer son coefficient de silhouette et stocker le liste. Ensuite, déterminer le nombre de parties qui maximise ce score. Il est intéressant également de visualiser ce coefficient en fonction du nombre de parties.
Que trouvez-vous ? La même chose qu'avec l'inertie ?
Dans la méthode des k-moyennes, l'initialisation des centroïdes détermine l'issue de la partition puisque l'algorithme est déterministe. Aussi cette initialisation est-elle très importante : une mauvaise initialisation peut entraîner de mauvais résultats.
Tel qu'utilisé jusqu'ici, la méthode KMeans () initialise automatiquement les centroïdes en utilisant un algorithme qui généralement donne de bons résultats. Néanmoins, il peut arriver que cet algorithme initialise mal les centroïdes. Aussi, il est toujours prudent de comparer les résultats obtenus avec cette initialisation et d'autres, par exemple une initialisation au hasard. Pour cela, il faut ajouter le paramètre init = "random" lors de l'appel de KMeans ().
On peut aussi réaliser un certain nombre d'exécutions de l'algorithme des k moyennes en initialisant aléatoirement les centroïdes. Pour cela, on indique n_init = 20 si on veut réaliser 20 exécutions. KMeans () renvoie alors le meilleur résultat parmi les 20 (meilleur au sens de l'inertie).
Tester cette initialisation aléatoire effectuer par exemple 10 exécutions de KMeans () avec une initialisation aléatoire. On mesure la qualité du partitionnement à l'aide de l'inertie et du coefficient de silhouette. Trouvez-vous de meilleurs partionnements ?
Appliquer tout ce qui vient d'être expliqué aux jeux de données suivants~:
sklearn.datasets.load_iris ().data. Est-ce que les centres mobiles indiquent qu'il y a 3 groupes ? Comparer les partitions en 2, 3 et 4 groupes aux regroupement en 3 classes du jeu de données.Dans chaque cas, il faut essayer de déterminer le nombre de groupes. Comme d'habitude et rappelé en début de TP, il faut visualiser les données avant d'essayer de les partitionner afin d'essayer de voir ce que l'on aimerait obtenir et ce que l'algorithme des k-moyennes devrait calculer, et ensuite, visualiser le résultat et constater l'accord ou le désaccord entre ce que l'on attendait et ce que l'on a obtenu. En cas de désaccord, comprendre son origine.