Corso di Keras per machine learning – seconda lezione

In questo articolo impareremo ad usare keras attraverso un piccolo esempio che servirà a comprendere  le strutture fondamentali già introdotte nell’articolo precedente.

Iniziamo subito  importando le librerie necessarie:

import numpy as np

Come già detto in altre occasioni numpy è una potente libreria matematica che ci aiuta nelle problematiche vettoriali e matriciali tipiche di questi contesti applicativi.

Adesso importiamo le librerie di Keras necessarie:

from keras.models import Sequential

Per capire meglio l’esempio, bisogna tener presente che il model sequential è lo strumento che ci consente di infilare in cascata i livelli di una rete neurale, specificando volta per  volta il tipo di livello, ad esempio il livello di input (giallo) il livello hidden (blu) ed il livello di output  ( verde).

 

Sebbene sia possibile creare reti neurali complesse, nel nostro esempio ci limiteremo a costruire una rete neurale a tre livelli, ovvero facendo riferimento alla terminologia usata in keras implementeremo una sola  sequenza.

Il model Sequential come già detto è la classe che ci consentirà  di aggiungere i Livelli partendo dall’input fino all’output, mentre il dense Layer  è un livello generico di una rete neurale feed forward full connected, che si importa nel seguente modo:

from keras.layers import Dense

Usando questi due strumenti, messi a disposizione in keras,  sarà possibile implementare reti neurali generiche composte da uno strato di input, n strati intermedi (hidden) e uno strato di output.

Nota: La classe Dense, è un normale livello composto da n neuroni; costituisce il classico livello di una rete neurale artificiale in cui gli input vengono pesati e trasferiti attraverso la funzione di attivazione all’output insieme al bias.

 

Bene vediamo come sia possibile istruire keras ad implementare una rete neurale, usando  Sequential e Dense;  basterà istanziare il modello di tipo sequential e definire i livelli di input  e di output.

# istanziamo il nodello Sequential 
model = Sequential() 

#Livello di input di 20 neuroni, livello hidden di 64 neuroni 
model.add(Dense(64, input_dim=10, activation='relu')) 

#Livello di output
model.add(Dense(1, activation='sigmoid')) 

In questo esempio  abbiamo definito una rete neurale (MLP) con 20 neuroni nel livello di input, un livello intermedio (hidden) costituito da  64 neuroni e funzione di  attivazione reLU ed un livello di uscita con un solo neurone :  1 uscita con funzione di trasferimento sigmoide. (funzione logistica)

Per chi non ne avesse memoria la relu è una funzione di questo tipo:

mentre la sigmoide è una funzione di questo tipo:

Nelle righe precedenti abbiamo definito il tipo di modello della rete neurale; a questo punto non ci resta che decidere quale algoritmo utilizzare per l’addestramento della rete; in altri termini l’algoritmo che calcolerà il minimo della funzione di costo attraverso (gradient descent)

Per lo scopo utilizzeremo la funzione compile sul modello sequential definito prima ed utilizzeremo come optimizer  rmsprop (Root Mean Square Propagation) ovvero il tipo di algoritmo che si basa sul calcolo dell’errore quadratico medio per il calcolo del minimo della funzione di costo.

Come metrica per valutare la qualità del training  useremo l’accuracy : maggiore sarà l’accuracy migliore sarà l’addestramento ( in percentuale) mentre per la funzione di perdita (loss) useremo la  ‘binary_crossentropy’ che viene usata nei casi di classificazione binaria ovvero nei casi in cui l’uscita della rete neurale ha una sola classe:

 model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

A questo punto la struttura della rete neurale è pronta e sarà sufficiente lanciare la fase di apprendimento, ma prima di effettuare il training abbiamo bisogno di dati utili. 

Per il nostro esempio proveremo a crearne di casuali  e per fare ciò utilizzeremo numpy.

La fase di training, per chi non ne fosse al corrente consiste nel dire alla rete neurale attraverso un approccio chiamato addestramento supervisionato, quali sia la corrispondenza tra un determinato input ed il suo corrispondente output. ( per esempio nel caso di classificazione di immagini in fase di training dovrò dare alla rete  i dati che costruiscono la foto in ingresso e dire che questi dati sono  di un gatto)

# generazione dei dati di input : vettore di 20 elementi 
# potrebbe essere ad esempio una immagine di 5 pixel * 4 pixel
# generiamo 5000 fake images tutte di possibili gatti
x_train = np.random.random((5000, 20))  

# generiamo i corrispondenti dati di out necessari per l'apprendimento (train) 
# composto da 5000 valori casuali possibili : 0 / 1 ( non è un gatto , è un gatto)
y_train = np.random.randint(2, size=(5000, 1))   

Ottimo a questo punto abbiamo i dati per il training, ma nella realtà abbiamo bisogno anche di dati di validazione, non utilizzati nella fase di addestramento. Per capirci un certo numero di foto di gatti dovremmo tenerli da parte per usarli come verifica del trining. Generiamo giusto per test questi ipotetici dati:

 
# generazione dei dati di input di validazione composto da 500 vettori di 20 elementi 
x_test = np.random.random((500, 20)) 

# generazione dei dati di out di validazione  
# composto da 500 valori casuali possibili: 0 / 1 ( non è un gatto , è un gatto)
y_test = np.random.randint(2, size=(100, 1))

a questo punto non ci resta che avviare la fase di training e decidiamo di  fermare il training dopo 30 epoche con batches di 128 elementi per volta.

 model.fit(x_train, y_train,
          epochs=30,
          batch_size=128, verbose=1)

Il risultato dell’addestramento ovviamente non ha molto senso ma la procedura invece da il senso di quello che si deve fare per addestrare una rete.

Epoch 1/30
5000/5000 [==============================] - 0s 9us/step - loss: 0.7076 - accuracy: 0.5084
Epoch 2/30
5000/5000 [==============================] - 0s 8us/step - loss: 0.7067 - accuracy: 0.5084
Epoch 3/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.7060 - accuracy: 0.5088
Epoch 4/30
5000/5000 [==============================] - 0s 9us/step - loss: 0.7053 - accuracy: 0.5078
Epoch 5/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.7045 - accuracy: 0.5094
Epoch 6/30
5000/5000 [==============================] - 0s 8us/step - loss: 0.7038 - accuracy: 0.5088
Epoch 7/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.7031 - accuracy: 0.5086
Epoch 8/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.7023 - accuracy: 0.5102
Epoch 9/30
5000/5000 [==============================] - 0s 8us/step - loss: 0.7020 - accuracy: 0.5108
Epoch 10/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.7013 - accuracy: 0.5098
Epoch 11/30
5000/5000 [==============================] - 0s 9us/step - loss: 0.7006 - accuracy: 0.5104
Epoch 12/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.7003 - accuracy: 0.5070
Epoch 13/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.7000 - accuracy: 0.5096
Epoch 14/30
5000/5000 [==============================] - 0s 9us/step - loss: 0.6996 - accuracy: 0.5104
Epoch 15/30
5000/5000 [==============================] - 0s 6us/step - loss: 0.6990 - accuracy: 0.5098
Epoch 16/30
5000/5000 [==============================] - 0s 9us/step - loss: 0.6986 - accuracy: 0.5080
Epoch 17/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.6982 - accuracy: 0.5088
Epoch 18/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.6978 - accuracy: 0.5078
Epoch 19/30
5000/5000 [==============================] - 0s 10us/step - loss: 0.6974 - accuracy: 0.5092
Epoch 20/30
5000/5000 [==============================] - 0s 6us/step - loss: 0.6971 - accuracy: 0.5104
Epoch 21/30
5000/5000 [==============================] - 0s 9us/step - loss: 0.6969 - accuracy: 0.5088
Epoch 22/30
5000/5000 [==============================] - 0s 8us/step - loss: 0.6965 - accuracy: 0.5058
Epoch 23/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.6963 - accuracy: 0.5098
Epoch 24/30
5000/5000 [==============================] - 0s 10us/step - loss: 0.6960 - accuracy: 0.5054
Epoch 25/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.6958 - accuracy: 0.5090
Epoch 26/30
5000/5000 [==============================] - 0s 11us/step - loss: 0.6956 - accuracy: 0.5136
Epoch 27/30
5000/5000 [==============================] - 0s 8us/step - loss: 0.6952 - accuracy: 0.5060
Epoch 28/30
5000/5000 [==============================] - 0s 10us/step - loss: 0.6950 - accuracy: 0.5066
Epoch 29/30
5000/5000 [==============================] - 0s 7us/step - loss: 0.6948 - accuracy: 0.5082
Epoch 30/30
5000/5000 [==============================] - 0s 9us/step - loss: 0.6945 - accuracy: 0.5090

A questo punto possiamo misurare l’accuratezza usando il  dataset di test

score = model.evaluate(x_test, y_test, batch_size=128)
print(score)

500/500 [==============================] - 0s 49us/step
[0.6922782578468323, 0.515999972820282]

<< prima lezione

terza lezione >>