Python: apprentissage non supervisé: clustering non hiérarchique

Technique de clustering

Classification hiérarchique

Le clustering hiérarchique consiste à trouver la combinaison la plus similaire dans les données. C'est une méthode de regroupement dans l'ordre, et elle se caractérise par une structure hiérarchique au milieu du processus.

Voir la figure ci-dessous pour un exemple concret. Il y a 5 points de données A, B, C, D et E. Collectez la plus proche de ces cinq données Faites cela pour créer un cluster.

　　　A,B,C,D,E
　　　→ (A,B), C,D,E

Dans ce cas, A et B sont les points les plus proches de la combinaison. Puisqu'il a été jugé par calcul, j'ai créé un groupe appelé (A, B).

Ensuite, considérez le cluster nouvellement créé comme un point de données et répétez cette opération.

　　　→ (A,B), (C,D), E
　　　→ (A,B,C,D), E
　　　→ (A,B,C,D,E)

Enfin, lorsque vous atteignez le cluster qui collecte toutes les données, vous avez terminé. C'est une représentation de quel cluster les points de données ont été regroupés. Comme le montre la figure de droite ci-dessous

Diagramme arborescent(Dendrogramme)est.

Clustering non hiérarchique

Le clustering non hiérarchique, comme le clustering hiérarchique, recherche des propriétés similaires à partir des données. Crée un cluster mais n'a pas de structure hiérarchique.

Compte tenu des données, le développeur décide à l'avance du nombre de clusters à diviser Créez un cluster à partir des données pendant quelques minutes.

Cependant, le nombre optimal de grappes n'est pas déterminé pour chaque donnée. Puisqu'il n'a pas de structure hiérarchique, la quantité de calcul est faible par rapport à la classification hiérarchique. C'est une méthode efficace lorsque la quantité de données est importante.

Une méthode typique de clustering non hiérarchique est

k-signifie méthode.

méthode k-means

Collecte de données

Les clusters sont générés dans les données pour le nombre spécifié de clusters

sklearn.faire dans les ensembles de données_Je voudrais vous présenter la fonction blobs.

# sklearn.les ensembles de données font_Fonction d'importation de blobs
from sklearn.datasets import make_blobs
#X a un tracé(x,y)Cependant, Y est le numéro de cluster auquel appartient le tracé.
X,Y = make_blobs(n_samples=150,   #Nombre total de points de données
               n_features=2,          #Spécification de la quantité d'objets (nombre de dimensions) par défaut:2 
               centers=3,             #Nombre de clusters
               cluster_std=0.5,       #Écart type au sein du cluster
               shuffle=True,          #Échantillon aléatoire
               random_state=0)        #Spécifiez l'état du générateur de nombres aléatoires

Avec le code ci-dessus, X est le point de données et Y est le libellé du cluster auquel appartient le point de données.

À propos de la méthode k-means

Un exemple typique de regroupement non hiérarchique est la "méthode des k-moyennes".

La méthode k-means est une méthode qui peut diviser les données en n groupes avec une distribution égale. Une valeur moyenne μ, qui est le centre des données, est attribuée à chaque cluster.

Ce centre de gravité est appelé "centroïde". Se diviser en grappes de distribution égale

Nous utilisons un index appelé "SSE".

SSE est la somme des carrés de la différence entre les points de données contenus dans chaque cluster et le centre de gravité. (Cela correspond à la distribution) La méthode k-means choisit les centroïdes pour égaliser et minimiser ce SSE dans tous les clusters.

L'algorithme de la méthode k-means comporte trois étapes.

1. Tout d'abord, extrayez kk (nombre arbitraire) de points de données du groupe de données et utilisez ces kk points comme centre de gravité initial. Après avoir initialisé le centre de gravité, répétez les deux étapes.

2. Attribuez tous les points de données au centre de gravité le plus proche.

3. Ensuite, calculez le centre de gravité du groupe de données affecté à chaque centre de gravité kk et mettez à jour le centre de gravité comme un nouveau centre de gravité.

Après chaque étape 3, calculez la distance entre le centre de gravité précédent et le nouveau centre de gravité. Lorsque la distance est réduite dans une certaine mesure, le processus itératif ci-dessus se termine. En d'autres termes, itérer jusqu'à ce que le Centroid se mette à jour et soit presque bloqué.

Voici un exemple de données regroupées par la méthode k-means.

bibliothèque KMeans de sklearn

sklearn.La classe KMeans pour le cluster
Recherchez le cluster dans les données et attribuez un numéro de cluster à chaque donnée.

# sklearn.Importer la classe KMeans pour le cluster
from sklearn.cluster import KMeans

km = KMeans(n_clusters=3,            #Nombre de clusters
            init="random",           #Définir aléatoirement la valeur initiale de Centroid default: "k-means++"
            n_init=10,               #K avec différentes valeurs initiales de centroïdes-Nombre d'exécutions de moyens
            max_iter=300,            # k-signifie Nombre maximum de fois pour répéter l'algorithme
            tol=1e-04,               #Tolérance relative pour déterminer la convergence
            random_state=0)          #Initialisation de la génération aléatoire

Y_km = km.fit_predict(X) #Transmettez les données où le cluster existe et recherchez le numéro de cluster pour chaque échantillon

Trouvez le nombre spécifié de clusters à partir des données à l'aide du code ci-dessus Le numéro de cluster est automatiquement stocké dans Y_km pour chaque échantillon. Il existe de nombreuses autres fonctions dans la classe KMeans.

#Effectuer des calculs de clustering
km.fit(X[, y])
#Effectue le calcul de regroupement, convertit X en espace de distance utilisé pour l'analyse et renvoie
km.fit_transform(X[, y])

#Renvoie les paramètres utilisés dans le calcul
km.get_params([deep])
#Renvoie le numéro de cluster auquel appartient l'échantillon X
km.predict(X)
#Définir les paramètres
km.set_params(**params)
#Convertir X en espace de distance utilisé pour l'analyse et le retour
km.transform(X[, y])

À propos de SSE

L'une des fonctions d'évaluation des performances du clustering

SSE(Somme des erreurs au carré dans le cluster)il y a

En utilisant SSE, les performances de divers regroupements k-means peuvent être évaluées. La formule SSE est omise, mais la valeur SSE indique la distance entre les valeurs du cluster.

Dans sklearn, l'inertie de classe KMeans_Vous pouvez obtenir la valeur de SSE via l'attribut.

Parce que la somme de l'écart de chaque donnée par rapport au centre de gravité du cluster auquel elle appartient (distribuée) est SSE Plus la valeur SSE est petite, meilleur est le modèle de clustering.

#Accéder à la somme des erreurs quadratiques dans le cluster
print ("Distortion: %.2f"% km.inertia_)

Méthode du coude

Il y a un problème de comment décider du nombre de clusters à spécifier dans le clustering k-means.

Certaines techniques peuvent être utiles pour déterminer le nombre de clusters. c'est

Appelé la méthode du coude
Tracez comment l'ESS change à mesure que le nombre de clusters augmente
D'après le résultat k-Il s'agit d'une méthode pour déterminer le nombre de groupes de moyennes.

Comme vous pouvez le voir en exécutant le code ci-dessous, il y a un point où la valeur SSE se plie fortement. Le nombre de grappes à ce moment peut être considéré comme l'optimum.

Parce que la forme de l'intrigue ressemble à un coude plié C'est ce qu'on appelle la méthode du coude.

Cependant, en réalité, c'est aussi beau que le résultat du problème. Il est difficile d'obtenir un diagramme en coude qui rend le graphique déprimé.

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

#Génération d'échantillons de données
X, Y = make_blobs(n_samples=150, n_features=2, centers=3,
                  cluster_std=0.5, shuffle=True, random_state=0)

distortions = []
for i in range(1, 11):                #Nombre de clusters 1~Calculez 10 à la fois
    km = KMeans(n_clusters=i,
                init="k-means++",     # k-means++Sélectionnez le centre du cluster par méthode
                n_init=10,
                max_iter=300,
                random_state=0)
    km.fit(X)                         #Effectuer le clustering
    distortions.append(km.inertia_)   # km.fit et km.inertia_Peut être obtenu

#Graphique graphique
plt.plot(range(1, 11), distortions, marker="o")
plt.xticks(np.arange(1, 11, 1))
plt.xlabel("Number of clusters")
plt.ylabel("Distortion")
plt.show()

DBSCAN

Algorithme DBSCAN

Un autre algorithme de clustering non hiérarchique pour la méthode k-means

Il y a "DBS CAN".

L'algorithme "DBSCAN" trouve des emplacements à haute densité (agglomération de données) dans le cluster. Capturez séparément des zones à faible densité. Il montre sa vraie valeur lorsque la taille et la forme du cluster sont biaisées.

La méthode k-means a été regroupée de manière à ce que les données soient collectées autant que possible au centre du cluster. Par conséquent, l'amas prend inévitablement une forme proche d'un cercle (sphérique). Il est efficace lorsque la taille et la forme du cluster ne sont pas biaisées. Un bon regroupement a tendance à être impossible pour les données avec un biais dans la taille et la forme du cluster.

"DBS CAN" définit deux paramètres.

min_échantillons et eps.

L'algorithme "DBSCAN" classe les points de données dans les trois types suivants:

1.Point central
Min dans le rayon eps de certaines données_Points de données lorsqu'il y a autant de données que d'échantillon

2.Point frontière
Données qui ne sont pas un point central mais qui se trouvent dans le rayon eps du point central

3.Point de bruit
Points de données qui ne se rencontrent pas non plus

Un cluster est formé à partir d'un ensemble de points centraux.

Les points de bordure sont attribués au cluster auquel appartient le point central le plus proche.

De cette manière, avec l'algorithme "DBSCAN" En classant toutes les données en 3 données Les données biaisées et les clusters non moyens peuvent désormais être catégorisés Vous pouvez également supprimer correctement le bruit.

«DBSCAN» peut utiliser la classe DBSCAN de sklearn.cluster. Comme paramètre principal

eps、min_Spécifiez la méthode de calcul de distance par échantillon et métrique.

from sklearn.cluster import DBSCAN
db = DBSCAN(eps=0.2,
            min_samples=5,
            metric="euclidean")
Y_db = db.fit_predict(X)

Alors que la méthode k-means est vulnérable aux données avec des formes complexes comme celle-ci, DBSCAN peut regrouper des formes arbitraires.