AI con Python - Apprendimento non supervisionato: clustering

Gli algoritmi di apprendimento automatico non supervisionati non hanno alcun supervisore che fornisca alcun tipo di guida. Ecco perché sono strettamente allineati con quella che alcuni chiamano la vera intelligenza artificiale.

Nell'apprendimento senza supervisione, non ci sarebbe una risposta corretta e nessun insegnante per la guida. Gli algoritmi devono scoprire il modello interessante nei dati per l'apprendimento.

Cos'è il clustering?

Fondamentalmente, è un tipo di metodo di apprendimento non supervisionato e una tecnica comune per l'analisi dei dati statistici utilizzata in molti campi. Il raggruppamento è principalmente un compito di dividere l'insieme di osservazioni in sottoinsiemi, chiamati cluster, in modo tale che le osservazioni nello stesso cluster siano simili in un certo senso e dissimili dalle osservazioni in altri cluster. In parole semplici, possiamo dire che l'obiettivo principale del clustering è raggruppare i dati sulla base di similarità e dissomiglianza.

Ad esempio, il diagramma seguente mostra tipi di dati simili in cluster diversi:

Algoritmi per il raggruppamento dei dati

Di seguito sono riportati alcuni algoritmi comuni per raggruppare i dati:

Algoritmo K-Means

L'algoritmo di clustering K-means è uno degli algoritmi ben noti per il clustering dei dati. Dobbiamo presumere che il numero di cluster sia già noto. Questo è anche chiamato clustering piatto. È un algoritmo di clustering iterativo. I passaggi indicati di seguito devono essere seguiti per questo algoritmo:

Step 1 - Dobbiamo specificare il numero desiderato di K sottogruppi.

Step 2- Correggi il numero di cluster e assegna in modo casuale ciascun punto dati a un cluster. O in altre parole, dobbiamo classificare i nostri dati in base al numero di cluster.

In questo passaggio, è necessario calcolare i centroidi del cluster.

Poiché si tratta di un algoritmo iterativo, dobbiamo aggiornare le posizioni dei centroidi K con ogni iterazione finché non troviamo gli ottimali globali o, in altre parole, i centroidi raggiungono le loro posizioni ottimali.

Il codice seguente aiuterà nell'implementazione dell'algoritmo di clustering K-means in Python. Useremo il modulo Scikit-learn.

Importiamo i pacchetti necessari -

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

La seguente riga di codice aiuterà a generare il set di dati bidimensionale, contenente quattro BLOB, utilizzando make_blob dal sklearn.dataset pacchetto.

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)

Possiamo visualizzare il set di dati utilizzando il codice seguente:

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

Qui stiamo inizializzando kmeans come algoritmo di KMeans, con il parametro richiesto di quanti cluster (n_clusters).

kmeans = KMeans(n_clusters = 4)

Dobbiamo addestrare il modello K-means con i dati di input.

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_

Il codice fornito di seguito ci aiuterà a tracciare e visualizzare i risultati della macchina in base ai nostri dati e il montaggio in base al numero di cluster che devono essere trovati.

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

Algoritmo di spostamento medio

È un altro algoritmo di clustering popolare e potente utilizzato nell'apprendimento senza supervisione. Non fa alcuna supposizione, quindi è un algoritmo non parametrico. È anche chiamato clustering gerarchico o analisi del cluster a spostamento medio. I seguenti sarebbero i passaggi fondamentali di questo algoritmo:

Prima di tutto, dobbiamo iniziare con i punti dati assegnati a un loro cluster.
Ora calcola i centroidi e aggiorna la posizione dei nuovi centroidi.
Ripetendo questo processo, ci avviciniamo al picco del cluster, cioè verso la regione di maggiore densità.
Questo algoritmo si ferma nella fase in cui i centroidi non si muovono più.

Con l'aiuto del seguente codice stiamo implementando l'algoritmo di clustering Mean Shift in Python. Useremo il modulo Scikit-learn.

Importiamo i pacchetti necessari -

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

Il codice seguente aiuterà a generare il set di dati bidimensionale, contenente quattro BLOB, utilizzando make_blob dal sklearn.dataset pacchetto.

from sklearn.datasets.samples_generator import make_blobs

Possiamo visualizzare il dataset con il seguente codice

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()

Ora, dobbiamo addestrare il modello di cluster Mean Shift con i dati di input.

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

Il codice seguente stamperà i centri del cluster e il numero previsto di cluster in base ai dati di input -

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

Il codice fornito di seguito aiuterà a tracciare e visualizzare i risultati della macchina in base ai nostri dati e il montaggio in base al numero di cluster che devono essere trovati.

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()

Misurare le prestazioni del clustering

I dati del mondo reale non sono organizzati naturalmente in un numero di cluster distinti. Per questo motivo, non è facile visualizzare e trarre conclusioni. Questo è il motivo per cui dobbiamo misurare le prestazioni del clustering e la sua qualità. Può essere fatto con l'aiuto dell'analisi della silhouette.

Analisi della silhouette

Questo metodo può essere utilizzato per verificare la qualità del raggruppamento misurando la distanza tra i cluster. Fondamentalmente, fornisce un modo per valutare i parametri come il numero di cluster dando un punteggio di silhouette. Questo punteggio è una metrica che misura quanto è vicino ogni punto in un cluster ai punti nei cluster vicini.

Analisi del punteggio di silhouette

Il punteggio ha un intervallo di [-1, 1]. Di seguito è riportata l'analisi di questo punteggio:

Score of +1 - Il punteggio vicino a +1 indica che il campione è lontano dal cluster vicino.
Score of 0 - Il punteggio 0 indica che il campione si trova o è molto vicino al confine decisionale tra due cluster vicini.
Score of -1 - Il punteggio negativo indica che i campioni sono stati assegnati ai cluster sbagliati.

Calcolo del punteggio della silhouette

In questa sezione impareremo come calcolare il punteggio della silhouette.

Il punteggio della silhouette può essere calcolato utilizzando la seguente formula:

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

Ecco la distanza media dai punti nel cluster più vicino di cui il punto dati non fa parte. E, è la distanza media intra-cluster da tutti i punti nel proprio cluster.

Per trovare il numero ottimale di cluster, è necessario eseguire nuovamente l'algoritmo di clustering importando il file metrics modulo dal sklearnpacchetto. Nel seguente esempio, eseguiremo l'algoritmo di clustering K-means per trovare il numero ottimale di cluster -

Importa i pacchetti necessari come mostrato -

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

Con l'aiuto del codice seguente, genereremo il set di dati bidimensionale, contenente quattro BLOB, utilizzando make_blob dal sklearn.dataset pacchetto.

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)

Inizializza le variabili come mostrato -

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

Dobbiamo iterare il modello K-means attraverso tutti i valori e dobbiamo anche addestrarlo con i dati di input.

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

Ora, stima il punteggio della silhouette per il modello di cluster corrente utilizzando la metrica della distanza euclidea -

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

La seguente riga di codice aiuterà a visualizzare il numero di cluster e il punteggio Silhouette.

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

Riceverai il seguente output:

Number of clusters = 9
Silhouette score = 0.340391138371

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

Ora, l'output per il numero ottimale di cluster sarebbe il seguente:

Optimal number of clusters = 2

Trovare i vicini più vicini

Se vogliamo creare sistemi di raccomandazione come un sistema di raccomandazione di film, allora dobbiamo comprendere il concetto di trovare i vicini più vicini. È perché il sistema di raccomandazione utilizza il concetto di vicini più vicini.

Il concept of finding nearest neighborspuò essere definito come il processo di ricerca del punto più vicino al punto di input dal dataset dato. L'uso principale di questo algoritmo KNN) K-neighbours vicini è quello di costruire sistemi di classificazione che classificano un punto dati in prossimità del punto dati di input a varie classi.

Il codice Python fornito di seguito aiuta a trovare i vicini K-più vicini di un dato set di dati -

Importare i pacchetti necessari come mostrato di seguito. Qui stiamo usando ilNearestNeighbors modulo dal sklearn pacchetto

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

Definiamo ora i dati di input -

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],])

Ora, dobbiamo definire i vicini più vicini -

k = 3

Dobbiamo anche fornire i dati del test da cui trovare i vicini più vicini -

test_data = [3.3, 2.9]

Il codice seguente può visualizzare e tracciare i dati di input definiti da noi -

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

Ora, dobbiamo costruire il K Nearest Neighbor. Anche l'oggetto deve essere addestrato

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

Ora possiamo stampare i K vicini più vicini come segue

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

Possiamo visualizzare i vicini più vicini insieme al punto dati del 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()

Produzione

K Nearest Neighbors

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

Classificatore K-Nearest Neighbors

Un classificatore K-Nearest Neighbors (KNN) è un modello di classificazione che utilizza l'algoritmo dei vicini più vicini per classificare un dato punto dati. Abbiamo implementato l'algoritmo KNN nell'ultima sezione, ora costruiremo un classificatore KNN usando quell'algoritmo.

Concetto di classificatore KNN

Il concetto di base della classificazione del vicino più prossimo K è quello di trovare un numero predefinito, cioè la "k" - di campioni di addestramento più vicini in distanza a un nuovo campione, che deve essere classificato. I nuovi campioni riceveranno la loro etichetta dai vicini stessi. I classificatori KNN hanno una costante definita dall'utente per il numero di vicini che devono essere determinati. Per la distanza, la distanza euclidea standard è la scelta più comune. Il classificatore KNN funziona direttamente sui campioni appresi piuttosto che creare le regole per l'apprendimento. L'algoritmo KNN è tra i più semplici di tutti gli algoritmi di apprendimento automatico. Ha avuto un discreto successo in un gran numero di problemi di classificazione e regressione, ad esempio il riconoscimento dei caratteri o l'analisi delle immagini.

Example

Stiamo costruendo un classificatore KNN per riconoscere le cifre. Per questo, useremo il set di dati MNIST. Scriveremo questo codice nel Jupyter Notebook.

Importare i pacchetti necessari come mostrato di seguito.

Qui stiamo usando il KNeighborsClassifier modulo dal sklearn.neighbors pacchetto -

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

Il codice seguente mostrerà l'immagine della cifra per verificare quale immagine dobbiamo testare -

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

Ora, dobbiamo caricare il set di dati MNIST. In realtà ci sono un totale di 1797 immagini, ma stiamo usando le prime 1600 immagini come campione di addestramento e le rimanenti 197 sarebbero conservate a scopo di test.

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

Ora, visualizzando le immagini possiamo vedere l'output come segue:

Image_display(0)

Image_display (0)

L'immagine di 0 viene visualizzata come segue:

Image_display (9)

L'immagine di 9 viene visualizzata come segue:

digit.keys ()

Ora, dobbiamo creare il set di dati di addestramento e test e fornire il set di dati di test ai classificatori KNN.

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

Il seguente output creerà il costruttore del classificatore del vicino più vicino K -

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

Dobbiamo creare il campione di test fornendo qualsiasi numero arbitrario maggiore di 1600, che erano i campioni di addestramento.

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

Image_display (6)

L'immagine di 6 viene visualizzata come segue:

Ora prevediamo i dati del test come segue:

KNN.predict(test1)

Il codice sopra genererà il seguente output:

array([6])

Ora, considera quanto segue:

digit['target_names']