introduzione

1. L'apprendimento senza supervisione è un paradigma nell'apprendimento automatico in cui creiamo modelli senza fare affidamento su dati di addestramento etichettati .
2. Gestire i dati etichettati in qualche modo significa che gli algoritmi di apprendimento possono esaminare i dati e imparare a classificarli in base alle etichette.
3. Nel mondo dell'apprendimento senza supervisione, non abbiamo questa opportunità! Questi algoritmi vengono utilizzati quando si desidera trovare sottogruppi all'interno di set di dati utilizzando una metrica di similarità.
4. Nell'apprendimento senza supervisione, le informazioni dal database vengono estratte automaticamente. Tutto ciò avviene senza la preventiva conoscenza del contenuto da analizzare.
5. Nell'apprendimento non supervisionato, non ci sono informazioni sulle classi a cui appartengono gli esempi o sull'output corrispondente a un dato input.
6. Vogliamo un modello in grado di scoprire proprietà interessanti, come gruppi con caratteristiche simili, che avviene nel clustering. Un esempio dell'applicazione di questi algoritmi è un motore di ricerca. Queste applicazioni sono in grado di creare un elenco di link relativi alla nostra ricerca, partendo da una o più parole chiave.
7. Questi algoritmi funzionano confrontando i dati e cercando somiglianze o differenze. La validità di questi algoritmi dipende dall'utilità delle informazioni che possono estrarre dal database.
8. I dati disponibili riguardano solo l'insieme di caratteristiche che descrivono ogni
   esempio. Uno dei metodi più comuni è il clustering . Avrai sentito questo termine essere usato abbastanza frequentemente; lo usiamo principalmente per l'analisi dei dati quando vogliamo trovare cluster nei nostri dati.
9. Questi cluster vengono solitamente trovati utilizzando un certo tipo di misura di somiglianza, come la distanza euclidea.
10. L'apprendimento senza supervisione è ampiamente utilizzato in molti campi, come data mining, imaging medico, analisi del mercato azionario, visione artificiale e segmentazione del mercato.

1. L'algoritmo k-means è uno degli algoritmi di clustering più popolari.
2. Questo algoritmo viene utilizzato per dividere i dati di input in k sottogruppi utilizzando vari attributi dei dati.
3. Il raggruppamento viene ottenuto utilizzando una tecnica di ottimizzazione in cui si cerca di ridurre al minimo la somma dei quadrati delle distanze tra i punti dati e il corrispondente centroide del cluster.

Useremo l'algoritmo k-means per raggruppare i dati in quattro cluster
identificati dal relativo centroide. Potremo inoltre tracciare i confini per identificare le aree di rilevanza di ogni cluster.

Come farlo

Vediamo come eseguire un'analisi dei dati di clustering utilizzando l'algoritmo k-means:

1. Importa i seguenti pacchetti:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

input_file = ('data_multivar.txt')
# Load data
x = []
with open(input_file, 'r') as f:
    for line in f.readlines():
        data = [float(i) for i in line.split(',')]
        x.append(data)
data = np.array(x)
num_clusters = 4

plt.figure()
plt.scatter(data[:,0], data[:,1], marker='o',
facecolors='none', edgecolors='k', s=30)
x_min, x_max = min(data[:, 0]) - 1, max(data[:, 0]) + 1
y_min, y_max = min(data[:, 1]) - 1, max(data[:, 1]) + 1
plt.title('Input data')
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.xticks(())
plt.yticks(())

       

kmeans = KMeans(init='k-means++', n_clusters=num_clusters, n_init=10)
kmeans.fit(data)

# Step size of the mesh
step_size = 0.01
# Plot the boundaries
x_min, x_max = min(data[:, 0]) - 1, max(data[:, 0]) + 1
y_min, y_max = min(data[:, 1]) - 1, max(data[:, 1]) + 1
x_values, y_values = np.meshgrid(np.arange(x_min, x_max,
step_size), np.arange(y_min, y_max, step_size))
# Predict labels for all points in the mesh
predicted_labels = kmeans.predict(np.c_[x_values.ravel(),
y_values.ravel()])

# Plot the results
predicted_labels = predicted_labels.reshape(x_values.shape)
plt.figure()
plt.clf()
plt.imshow(predicted_labels, interpolation='nearest',
extent=(x_values.min(), x_values.max(), y_values.min(),
y_values.max()), cmap=plt.cm.Paired,
aspect='auto', origin='lower')
plt.scatter(data[:,0], data[:,1], marker='o', facecolors='none', edgecolors='k', s=30)

       

centroids = kmeans.cluster_centers_
plt.scatter(centroids[:,0], centroids[:,1], marker='o', s=200,
linewidths=3,
color='k', zorder=10, facecolors='black')
x_min, x_max = min(data[:, 0]) - 1, max(data[:, 0]) + 1
y_min, y_max = min(data[:, 1]) - 1, max(data[:, 1]) + 1
plt.title('Centoids and boundaries obtained using KMeans')
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.xticks(())
plt.yticks(())
plt.show()

       

1. K-means è stato sviluppato da James MacQueen, che, nel 1967, lo ha progettato allo scopo di dividere gruppi di oggetti in k partizioni in base ai loro attributi.
2. È una variazione dell'algoritmo di massimizzazione delle aspettative (EM), il cui obiettivo è determinare i gruppi di k dati generati dalle distribuzioni gaussiane.
3. La differenza tra i due algoritmi risiede nel metodo di calcolo della distanza euclidea. In k-means, si presume che gli attributi dell'oggetto possano essere rappresentati come vettori e quindi formare uno spazio vettoriale.
4. L'obiettivo è ridurre al minimo la varianza totale intra-cluster (o deviazione standard). Ogni cluster è identificato da un centroide.

1. Scegli il numero di k cluster.
2. Inizialmente, creare k partizioni e assegnare ciascuna partizione di ingresso in modo casuale o utilizzando alcune informazioni euristiche
3. Calcola il baricentro di ogni gruppo
4. Calcola la distanza tra ogni osservazione e ogni centroide del cluster
5. Quindi, costruire una nuova partizione associando ciascun punto di ingresso al cluster il cui centroide è più vicino ad esso
6. Il centroide per i nuovi cluster viene ricalcolato
7. Ripetere i passaggi da 4 a 6 finché l'algoritmo non converge

1. Lo scopo dell'algoritmo è individuare k centroidi , uno per ogni cluster.
2. La posizione di ciascun baricentro è di particolare importanza poiché posizioni diverse causano risultati diversi.
3. La scelta migliore è metterli il più distanti possibile l'uno dall'altro . Fatto ciò, è necessario associare ogni oggetto al centroide più vicino.
4. In questo modo otterremo il primo raggruppamento. Dopo aver terminato il primo ciclo, si passa a quello successivo ricalcolando i nuovi k centroidi come baricentro dell'ammasso usando quello precedente.
5. Una volta individuati questi nuovi k centroidi, è necessario creare una nuova connessione tra lo stesso set di dati e il nuovo centroide più vicino. Al termine di queste operazioni viene eseguito un nuovo ciclo.
6. A causa di questo ciclo, possiamo notare che i k centroidi cambiano la loro posizione passo dopo passo fino a quando non vengono modificati. Quindi, il centroide non si muove più .