AI avec Python - Apprentissage non supervisé: clustering

Les algorithmes d'apprentissage automatique non supervisés n'ont pas de superviseur pour fournir des conseils. C'est pourquoi ils sont étroitement liés à ce que certains appellent la véritable intelligence artificielle.

Dans l'apprentissage non supervisé, il n'y aurait pas de réponse correcte et pas d'enseignant pour les conseils. Les algorithmes doivent découvrir le modèle intéressant des données pour l'apprentissage.

Qu'est-ce que le clustering?

Fondamentalement, il s'agit d'un type de méthode d'apprentissage non supervisé et d'une technique courante d'analyse de données statistiques utilisée dans de nombreux domaines. Le regroupement consiste principalement à diviser l'ensemble des observations en sous-ensembles, appelés groupes, de telle sorte que les observations dans le même groupe sont similaires dans un sens et elles sont différentes des observations dans d'autres groupes. En termes simples, nous pouvons dire que l'objectif principal du clustering est de regrouper les données sur la base de la similitude et de la dissemblance.

Par exemple, le diagramme suivant montre un type similaire de données dans différents clusters -

Algorithmes de clustering des données

Voici quelques algorithmes courants pour regrouper les données -

Algorithme K-Means

L'algorithme de clustering K-means est l'un des algorithmes bien connus pour le clustering des données. Nous devons supposer que le nombre de grappes est déjà connu. Ceci est également appelé clustering plat. C'est un algorithme de clustering itératif. Les étapes ci-dessous doivent être suivies pour cet algorithme -

Step 1 - Nous devons spécifier le nombre souhaité de K sous-groupes.

Step 2- Fixez le nombre de clusters et attribuez de manière aléatoire chaque point de données à un cluster. Ou en d'autres termes, nous devons classer nos données en fonction du nombre de clusters.

Dans cette étape, les centroïdes de cluster doivent être calculés.

Comme il s'agit d'un algorithme itératif, nous devons mettre à jour les emplacements des centres de gravité K à chaque itération jusqu'à ce que nous trouvions les optima globaux ou, en d'autres termes, que les centres de gravité atteignent leurs emplacements optimaux.

Le code suivant aidera à implémenter l'algorithme de clustering K-means en Python. Nous allons utiliser le module Scikit-learn.

Importons les packages nécessaires -

import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

La ligne de code suivante aidera à générer le jeu de données bidimensionnel, contenant quatre blobs, en utilisant make_blob du sklearn.dataset paquet.

from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4,
            cluster_std = 0.40, random_state = 0)

Nous pouvons visualiser l'ensemble de données en utilisant le code suivant -

plt.scatter(X[:, 0], X[:, 1], s = 50);
plt.show()

Ici, nous initialisons kmeans pour être l'algorithme KMeans, avec le paramètre requis de combien de clusters (n_clusters).

kmeans = KMeans(n_clusters = 4)

Nous devons former le modèle K-means avec les données d'entrée.

kmeans.fit(X)
y_kmeans = kmeans.predict(X)
plt.scatter(X[:, 0], X[:, 1], c = y_kmeans, s = 50, cmap = 'viridis')

centers = kmeans.cluster_centers_

Le code donné ci-dessous nous aidera à tracer et à visualiser les résultats de la machine en fonction de nos données, et l'ajustement en fonction du nombre de clusters à trouver.

plt.scatter(centers[:, 0], centers[:, 1], c = 'black', s = 200, alpha = 0.5);
plt.show()

Algorithme de décalage moyen

C'est un autre algorithme de clustering populaire et puissant utilisé dans l'apprentissage non supervisé. Il ne fait aucune hypothèse, il s'agit donc d'un algorithme non paramétrique. Il est également appelé clustering hiérarchique ou analyse de cluster à décalage moyen. Les étapes suivantes seraient les étapes de base de cet algorithme -

Tout d'abord, nous devons commencer par les points de données affectés à un cluster qui leur est propre.
À présent, il calcule les centres de gravité et met à jour l'emplacement des nouveaux centres de gravité.
En répétant ce processus, on rapproche le pic d'amas c'est-à-dire vers la région de densité la plus élevée.
Cet algorithme s'arrête au stade où les centres de gravité ne bougent plus.

Avec l'aide du code suivant, nous implémentons l'algorithme de clustering Mean Shift en Python. Nous allons utiliser le module Scikit-learn.

Importons les packages nécessaires -

import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")

Le code suivant vous aidera à générer le jeu de données bidimensionnel, contenant quatre objets blob, en utilisant make_blob du sklearn.dataset paquet.

from sklearn.datasets.samples_generator import make_blobs

Nous pouvons visualiser l'ensemble de données avec le code suivant

centers = [[2,2],[4,5],[3,10]]
X, _ = make_blobs(n_samples = 500, centers = centers, cluster_std = 1)
plt.scatter(X[:,0],X[:,1])
plt.show()

Maintenant, nous devons former le modèle de cluster Mean Shift avec les données d'entrée.

ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_

Le code suivant imprimera les centres de cluster et le nombre prévu de cluster selon les données d'entrée -

print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
[[ 3.23005036 3.84771893]
[ 3.02057451 9.88928991]]
Estimated clusters: 2

Le code donné ci-dessous aidera à tracer et à visualiser les résultats de la machine en fonction de nos données, et le montage en fonction du nombre de clusters à trouver.

colors = 10*['r.','g.','b.','c.','k.','y.','m.']
   for i in range(len(X)):
   plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 10)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
   marker = "x",color = 'k', s = 150, linewidths = 5, zorder = 10)
plt.show()

Mesure de la performance du clustering

Les données du monde réel ne sont pas naturellement organisées en nombre de clusters distinctifs. Pour cette raison, il n'est pas facile de visualiser et de tirer des inférences. C'est pourquoi nous devons mesurer la performance du clustering ainsi que sa qualité. Cela peut être fait à l'aide de l'analyse de la silhouette.

Analyse de la silhouette

Cette méthode peut être utilisée pour vérifier la qualité du clustering en mesurant la distance entre les clusters. Fondamentalement, il fournit un moyen d'évaluer les paramètres tels que le nombre de clusters en donnant un score de silhouette. Ce score est une métrique qui mesure à quel point chaque point d'un cluster est proche des points des clusters voisins.

Analyse du score de silhouette

Le score a une plage de [-1, 1]. Voici l'analyse de ce score -

Score of +1 - Un score proche de +1 indique que l'échantillon est éloigné du cluster voisin.
Score of 0 - Le score 0 indique que l'échantillon est sur ou très proche de la limite de décision entre deux clusters voisins.
Score of -1 - Un score négatif indique que les échantillons ont été attribués aux mauvais groupes.

Calcul du score de silhouette

Dans cette section, nous allons apprendre à calculer le score de silhouette.

Le score de silhouette peut être calculé en utilisant la formule suivante -

$$ silhouette score = \ frac {\ left (pq \ right)} {max \ left (p, q \ right)} $$

Voici la distance moyenne aux points du cluster le plus proche dont le point de données ne fait pas partie. Et, est la distance intra-cluster moyenne à tous les points de son propre cluster.

Pour trouver le nombre optimal de clusters, nous devons exécuter à nouveau l'algorithme de clustering en important le metrics module du sklearnpaquet. Dans l'exemple suivant, nous exécuterons l'algorithme de clustering K-means pour trouver le nombre optimal de clusters -

Importez les packages nécessaires comme indiqué -

import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

À l'aide du code suivant, nous allons générer le jeu de données bidimensionnel, contenant quatre blobs, en utilisant make_blob du sklearn.dataset paquet.

from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4, cluster_std = 0.40, random_state = 0)

Initialisez les variables comme indiqué -

scores = []
values = np.arange(2, 10)

Nous devons itérer le modèle K-means à travers toutes les valeurs et également l'entraîner avec les données d'entrée.

for num_clusters in values:
kmeans = KMeans(init = 'k-means++', n_clusters = num_clusters, n_init = 10)
kmeans.fit(X)

Maintenant, estimez le score de silhouette pour le modèle de clustering actuel à l'aide de la métrique de distance euclidienne -

score = metrics.silhouette_score(X, kmeans.labels_,
metric = 'euclidean', sample_size = len(X))

La ligne de code suivante aidera à afficher le nombre de clusters ainsi que le score Silhouette.

print("\nNumber of clusters =", num_clusters)
print("Silhouette score =", score)
scores.append(score)

Vous recevrez la sortie suivante -

Number of clusters = 9
Silhouette score = 0.340391138371

num_clusters = np.argmax(scores) + values[0]
print('\nOptimal number of clusters =', num_clusters)

Maintenant, la sortie pour le nombre optimal de clusters serait la suivante -

Optimal number of clusters = 2

Trouver les voisins les plus proches

Si nous voulons créer des systèmes de recommandation tels qu'un système de recommandation de films, nous devons comprendre le concept de recherche des voisins les plus proches. C'est parce que le système de recommandation utilise le concept de voisins les plus proches.

le concept of finding nearest neighborspeut être défini comme le processus de recherche du point le plus proche du point d'entrée à partir de l'ensemble de données donné. L'utilisation principale de cet algorithme KNN) K-plus proche voisins) est de construire des systèmes de classification qui classifient un point de données sur la proximité du point de données d'entrée à diverses classes.

Le code Python donné ci-dessous aide à trouver les K voisins les plus proches d'un ensemble de données donné -

Importez les packages nécessaires comme indiqué ci-dessous. Ici, nous utilisons leNearestNeighbors module du sklearn paquet

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors

Définissons maintenant les données d'entrée -

A = np.array([[3.1, 2.3], [2.3, 4.2], [3.9, 3.5], [3.7, 6.4], [4.8, 1.9], 
             [8.3, 3.1], [5.2, 7.5], [4.8, 4.7], [3.5, 5.1], [4.4, 2.9],])

Maintenant, nous devons définir les voisins les plus proches -

k = 3

Nous devons également donner les données de test à partir desquelles les voisins les plus proches doivent être trouvés -

test_data = [3.3, 2.9]

Le code suivant peut visualiser et tracer les données d'entrée définies par nous -

plt.figure()
plt.title('Input data')
plt.scatter(A[:,0], A[:,1], marker = 'o', s = 100, color = 'black')

Maintenant, nous devons construire le K Nearest Neighbor. L'objet doit également être formé

knn_model = NearestNeighbors(n_neighbors = k, algorithm = 'auto').fit(X)
distances, indices = knn_model.kneighbors([test_data])

Maintenant, nous pouvons imprimer les K voisins les plus proches comme suit

print("\nK Nearest Neighbors:")
for rank, index in enumerate(indices[0][:k], start = 1):
   print(str(rank) + " is", A[index])

Nous pouvons visualiser les voisins les plus proches avec le point de données de test

plt.figure()
plt.title('Nearest neighbors')
plt.scatter(A[:, 0], X[:, 1], marker = 'o', s = 100, color = 'k')
plt.scatter(A[indices][0][:][:, 0], A[indices][0][:][:, 1],
   marker = 'o', s = 250, color = 'k', facecolors = 'none')
plt.scatter(test_data[0], test_data[1],
   marker = 'x', s = 100, color = 'k')
plt.show()

Production

K Nearest Neighbors

1 is [ 3.1 2.3]
2 is [ 3.9 3.5]
3 is [ 4.4 2.9]

Classificateur K-Nearest Neighbours

Un classificateur KNN (K-Nearest Neighbours) est un modèle de classification qui utilise l'algorithme des voisins les plus proches pour classer un point de données donné. Nous avons implémenté l'algorithme KNN dans la dernière section, maintenant nous allons construire un classificateur KNN en utilisant cet algorithme.

Concept de classificateur KNN

Le concept de base de la classification K-plus proche voisin est de trouver un nombre prédéfini, c'est-à-dire le «k» - d'échantillons d'apprentissage les plus proches en distance d'un nouvel échantillon, qui doit être classé. Les nouveaux échantillons recevront leur étiquette des voisins eux-mêmes. Les classificateurs KNN ont une constante définie par l'utilisateur fixe pour le nombre de voisins qui doivent être déterminés. Pour la distance, la distance euclidienne standard est le choix le plus courant. Le classificateur KNN fonctionne directement sur les échantillons appris plutôt que de créer les règles d'apprentissage. L'algorithme KNN est l'un des plus simples de tous les algorithmes d'apprentissage automatique. Il a été assez réussi dans un grand nombre de problèmes de classification et de régression, par exemple, la reconnaissance de caractères ou l'analyse d'images.

Example

Nous construisons un classificateur KNN pour reconnaître les chiffres. Pour cela, nous utiliserons le jeu de données MNIST. Nous écrirons ce code dans le Jupyter Notebook.

Importez les packages nécessaires comme indiqué ci-dessous.

Ici, nous utilisons le KNeighborsClassifier module du sklearn.neighbors paquet -

from sklearn.datasets import *
import pandas as pd
%matplotlib inline
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
import numpy as np

Le code suivant affichera l'image du chiffre pour vérifier quelle image nous devons tester -

def Image_display(i):
   plt.imshow(digit['images'][i],cmap = 'Greys_r')
   plt.show()

Maintenant, nous devons charger le jeu de données MNIST. En fait, il y a au total 1797 images, mais nous utilisons les 1600 premières images comme échantillon de formation et les 197 autres seraient conservées à des fins de test.

digit = load_digits()
digit_d = pd.DataFrame(digit['data'][0:1600])

Maintenant, en affichant les images, nous pouvons voir la sortie comme suit -

Image_display(0)

Affichage_image (0)

L'image de 0 s'affiche comme suit -

Affichage_image (9)

L'image de 9 s'affiche comme suit -

digit.keys ()

Nous devons maintenant créer l'ensemble de données d'entraînement et de test et fournir l'ensemble de données de test aux classificateurs KNN.

train_x = digit['data'][:1600]
train_y = digit['target'][:1600]
KNN = KNeighborsClassifier(20)
KNN.fit(train_x,train_y)

La sortie suivante créera le constructeur de classificateur K voisin le plus proche -

KNeighborsClassifier(algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
   metric_params = None, n_jobs = 1, n_neighbors = 20, p = 2,
   weights = 'uniform')

Nous devons créer l'échantillon de test en fournissant tout nombre arbitraire supérieur à 1600, qui étaient les échantillons d'apprentissage.

test = np.array(digit['data'][1725])
test1 = test.reshape(1,-1)
Image_display(1725)

Affichage_image (6)

L'image de 6 s'affiche comme suit -

Nous allons maintenant prédire les données de test comme suit -

KNN.predict(test1)

Le code ci-dessus générera la sortie suivante -

array([6])

Maintenant, considérez ce qui suit -

digit['target_names']