Apprendimento approfondito con Keras - Preparazione dei dati

Prima di inviare i dati alla nostra rete, è necessario convertirli nel formato richiesto dalla rete. Questa operazione viene chiamata preparazione dei dati per la rete. Consiste generalmente nella conversione di un input multidimensionale in un vettore monodimensionale e nella normalizzazione dei punti dati.

Rimodellamento del vettore di input

Le immagini nel nostro set di dati sono costituite da 28 x 28 pixel. Questo deve essere convertito in un vettore unidimensionale di dimensione 28 * 28 = 784 per inserirlo nella nostra rete. Lo facciamo chiamando ilreshape metodo sul vettore.

X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)

Ora, il nostro vettore di addestramento consisterà di 60000 punti dati, ciascuno costituito da un singolo vettore dimensione di dimensione 784. Allo stesso modo, il nostro vettore di prova sarà composto da 10000 punti dati di un vettore monodimensionale di dimensione 784.

Normalizzazione dei dati

I dati contenuti nel vettore di input hanno attualmente un valore discreto compreso tra 0 e 255 - i livelli della scala di grigi. La normalizzazione di questi valori di pixel tra 0 e 1 aiuta ad accelerare la formazione. Dato che utilizzeremo la discesa del gradiente stocastico, la normalizzazione dei dati aiuterà anche a ridurre la possibilità di rimanere bloccati negli ottimali locali.

Per normalizzare i dati, lo rappresentiamo come tipo float e lo dividiamo per 255 come mostrato nel seguente frammento di codice:

X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255

Vediamo ora come appaiono i dati normalizzati.

Esame dei dati normalizzati

Per visualizzare i dati normalizzati, chiameremo la funzione istogramma come mostrato qui -

plot.hist(X_train[0])
plot.title("Digit: {}".format(y_train[0]))

Qui, tracciamo l'istogramma del primo elemento del file X_trainvettore. Stampiamo anche la cifra rappresentata da questo punto dati. L'output dell'esecuzione del codice sopra è mostrato qui -

Noterai una fitta densità di punti con valore vicino allo zero. Questi sono i punti neri nell'immagine, che ovviamente sono la parte principale dell'immagine. Il resto dei punti della scala di grigi, che sono vicini al colore bianco, rappresentano la cifra. Puoi controllare la distribuzione dei pixel per un'altra cifra. Il codice seguente stampa l'istogramma di una cifra con indice 2 nel set di dati di addestramento.

plot.hist(X_train[2])
plot.title("Digit: {}".format(y_train[2])

L'output dell'esecuzione del codice sopra è mostrato di seguito:

Confrontando le due figure precedenti, noterai che la distribuzione dei pixel bianchi in due immagini differisce indicando una rappresentazione di una cifra diversa - "5" e "4" nelle due immagini precedenti.

Successivamente, esamineremo la distribuzione dei dati nel nostro set di dati di addestramento completo.

Esame della distribuzione dei dati

Prima di addestrare il nostro modello di apprendimento automatico sul nostro set di dati, dovremmo conoscere la distribuzione di cifre univoche nel nostro set di dati. Le nostre immagini rappresentano 10 cifre distinte che vanno da 0 a 9. Vorremmo conoscere il numero di cifre 0, 1, ecc. Nel nostro set di dati. Possiamo ottenere queste informazioni utilizzando ilunique metodo di Numpy.

Utilizzare il seguente comando per stampare il numero di valori univoci e il numero di occorrenze di ciascuno

print(np.unique(y_train, return_counts=True))

Quando esegui il comando sopra, vedrai il seguente output:

(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8), array([5923, 6742, 5958, 6131, 5842, 5421, 5918, 6265, 5851, 5949]))

Mostra che sono presenti 10 valori distinti, da 0 a 9. Sono presenti 5923 occorrenze della cifra 0, 6742 occorrenze della cifra 1 e così via. Lo screenshot dell'output è mostrato qui -

Come passaggio finale nella preparazione dei dati, dobbiamo codificare i nostri dati.

Codifica dei dati

Abbiamo dieci categorie nel nostro set di dati. Codificheremo quindi il nostro output in queste dieci categorie utilizzando la codifica one-hot. Usiamo il metodo to_categorial delle utilità Numpy per eseguire la codifica. Dopo che i dati di output sono stati codificati, ogni punto dati verrebbe convertito in un vettore monodimensionale di dimensione 10. Ad esempio, la cifra 5 sarà ora rappresentata come [0,0,0,0,0,1,0,0,0 , 0].

Codifica i dati utilizzando la seguente parte di codice:

n_classes = 10
Y_train = np_utils.to_categorical(y_train, n_classes)

Puoi controllare il risultato della codifica stampando i primi 5 elementi del vettore Y_train classificato.

Usa il codice seguente per stampare i primi 5 vettori:

for i in range(5):
   print (Y_train[i])

Vedrai il seguente output:

[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]

Il primo elemento rappresenta la cifra 5, il secondo rappresenta la cifra 0 e così via.

Infine, dovrai classificare anche i dati del test, cosa che viene eseguita utilizzando la seguente dichiarazione:

Y_test = np_utils.to_categorical(y_test, n_classes)

In questa fase, i tuoi dati sono completamente preparati per essere immessi nella rete.

Successivamente, viene la parte più importante e cioè l'addestramento del nostro modello di rete.