Keras Tutorial : Python per il Deep Learning

La libreria Python per il Deep Learning

Keras è l’API as alto livello per l’implementazione di algoritmi basati su reti neurali artificiali. Keras è stato scritto nel linguaggio Python facendo da interfaccia a Tensorflow, Theano o CNTK.

Lo scopo di keras è quello di darti la possibilità di sviluppare e sperimentare velocemente nell’ambito del deep leanring e machine learning.

Con Keras puoi passare dall’idea all’implementazione in un lampo.

La difficoltà nell’apprendere i meccanismi di implementazione su Keras sono ridotti al minimo e la documentazione è chiara e arricchita di numerosi esempi con le più famose e usate configurazioni Deep Learning.

A questo link accedi alla pagina ufficiale di Keras https://keras.io/

In quest’ altro link trovi il repository con gli esempi di Keras https://github.com/keras-team/keras/tree/master/examples

E qui trovi una perfetta guida introduttiva al mondo degli algoritmi in python con l’utilizzo di Keras e non solo.

Non buttare tempo prezioso a “raccattare” informazioni qui e lì nel mare infinito del web.
Non è vero che il tempo è denaro : il tempo vale molto, molto di più!
Velocizza il tuo apprendimento e dai uno sprint alla tua formazione di Data Scientist .

Investi il denaro e non il tuo tempo!

Acquista un ottima guida.

In ogni caso continua a seguire l’articolo, ti spiegherò come implementare da zero il tuo primo modello intelligente con Keras.

Ma prima ti dico, se non lo conosci già, che cosa è Keras.

Se hai bisogno di una libreria per il Deep Learning
allora Keras è ciò che fa per te!

Ti permetterà di prototipare le tue idee in maniera veloce con uno stile di codice modulare ed estendibile.
Supporta le più recenti scoperte nell’ambito del Deep Learning come le CNNs (Convolutional Neural Networks) e RNNs( Reccurent Neural Networks) compreso la combinazione di entrambe le tecnologie.
Ovviamente supporta CPU e GPU (Graphic Processor Unit) per il calcolo veloce su matrici.

Caratteristiche e vantaggi

Semplice Velocità

Rispetto ad altre API, Keras basa la propria forza sulla semplicità e sulla velocità di implementazione.
In poche parole con un numero minimo di righe di codice possiamo creare modelli complessi e mantenendo comunque chiarezza nello sviluppo e codice robusto.
Quindi, nonostante la tecnologia si basi su concetti e meccanismi complessi il team di sviluppo di Keras è riuscito a mantenere al centro dell’attenzione l’esperienza dello sviluppatore finale. Un API consistente e semplice che minimizza il numero di azioni richieste per i casi d’uso più comuni.

Modularità

La modularità è un altro dei punti forti di Keras. Un modello è inteso come una sequenza o un grafo di singoli, compatti, completamente configurabili moduli che possono essere assemblati insieme con il minimo numero di restrizioni possibili: questa è la vera potenza e valore aggiunto nell’utilizzo di Keras.
Nello specifico, reti neurali, funzioni di costo, ottimizzatori, schemi di inizializzazione, funzioni di attivazione, schemi di regolarizzazione son tutti moduli standalone che tu puoi combinare tra loro per creare nuovi moduli che ovviamente compartecipano alla creazione di nuovi moduli e così via.

Facile estensibilità.

I nuovi moduli sono semplici da aggiungere (ad esempio classi e funzioni) ed inoltre per i moduli esistenti forniscono ampi esempi. Ti renderà capace di creare nuovi moduli permettendoti di esprimerti liberamente e facendo di Keras lo strumento perfetto per la ricerca avanzata nell’ambito del Deep Learning

Ed ora il tutorial

Per capire tutti i vantaggi di questa libreria ho preparato un velocissimo tutorial per realizzare un semplice modello basato sullo schema del Multi Layer Perceptron ossia la più semplice forma di modello a reti neurali MLP.

In questo sito, nella sezione tutorial Keras trovi altri esempi come LSTM e CNN

Per approfondire l’uso e tutte le potenzialità di Keras io ti consiglio di dare un occhiata a questo.

Ora vedremo un piccolo esempio su come usare Keras.

Inanzi tutto le righe per importare le strutture e le classi che ci interessano.

import numpy as np
from keras.models import Sequential
from keras.layers import Dense

in queste tre righe abbiamo importato numpy (libreria di supporto di calcolo vettoriale e operazioni su matrici)
dal package keras.models abbiamo importato la classe fondamentale che rappresenta la sequenza di Layers del nostro modello.
Il notro modello ossia l’insieme dei “pezzi” che andranno a comporre l’algoritmo o come in questo caso la rete neurale artificiale sarà composto come sequenza lineare di Layers.
Avremmo quindi uno strato di input, n strati intermedi (hidden) e uno strato di output.
La sequenza comprende questi tre elementi.
Il modello che andremo a creare sarà composto da una semplice sequenza ma con keras è possibile creare modelli composti da più sequenze.
Sequential è appunto la classe che ci permette di aggiungere via via Layer dopo Layer dall’ input all’output della sequenza.

In questo passaggio abbiamo importato anche le classi dei layers che ci interessano.
La classe Dense: rappresenta un normale layer composto da n neuroni, in pratica il classico schema della rete neurale artificiale in cui gli input vengono pesati e assieme al bias vengono trasferiti atraverso la funzione di attivazione all’output.

Con questi 2 elementi Sequential e Dense andiamo a creare il nostro semplicissimo primo prototipo di rete neurale artificiale.

 
model = Sequential() # istanza di Sequential 
model.add(Dense(64, input_dim=20, activation='relu')) #strato di input + hidden 
model.add(Dense(1, activation='sigmoid')) #strato di output

queste 4 righe di codice rappresentano il semplice modello MLP con 20 input un layer intermedio di 64 neuroni con attivazione reLU e 1 uscita con funzione di trasferimento sigmoide.

aggiungiamo il codice per indicare quale metodo verrà utilizzato per determinare il calcolo del costo e la metrica per valutare lo stato di apprendimento della rete e l’algoritmo di ottimizzazione.
Lo facciamo utilizzando la funzione “compile” del modello stesso

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

A questo punto la struttura del modello è pronta e ci mancano solo i dati di input e infine sarà sufficiente lanciare la fase di apprendimento.
Creiamo i dati, ovviamente per questa prima prova saranno randomici.
per fare ciò utilizzeremo la libreria numpy

 
#dati input di apprendimento composto da mille vettori di 20 float
random x_train = np.random.random((1000, 20))  #dati di out di apprendimento (train) composto da mille scalari random da 0 a 1 
y_train = np.random.randint(2, size=(1000, 1))   #dati input di validazione composto da 100 vettori di 20 float random 
x_test = np.random.random((100, 20))    #dati di out di validazione (test) composto da mille scalari random da 0 a 1 
y_test = np.random.randint(2, size=(100, 1))
 

e infine lanciamo 20 epoche di apprendimento con mini batches di 128 elementi

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

facilissimo!

Ovviamente i dati sono casuali e quindi avremo dopo un migliaio di epoche oltre il 90% di accuratezza sui dati di apprendimento ma ovvie ragioni non potremmo aspettarci alcun risultato nei dati di validazione.

Epoch 1/10
1000/1000 [==============================] - 0s 164us/step - loss: 0.6989 - acc: 0.5190
Epoch 2/10
1000/1000 [==============================] - 0s 16us/step - loss: 0.6943 - acc: 0.5070
Epoch 3/10
1000/1000 [==============================] - 0s 14us/step - loss: 0.6922 - acc: 0.5160
Epoch 4/10
1000/1000 [==============================] - 0s 17us/step - loss: 0.6905 - acc: 0.5190
Epoch 5/10
1000/1000 [==============================] - 0s 14us/step - loss: 0.6906 - acc: 0.5180
Epoch 6/10
1000/1000 [==============================] - 0s 15us/step - loss: 0.6892 - acc: 0.5300
Epoch 7/10
1000/1000 [==============================] - 0s 13us/step - loss: 0.6870 - acc: 0.5310
Epoch 8/10
1000/1000 [==============================] - 0s 14us/step - loss: 0.6864 - acc: 0.5440
Epoch 9/10
1000/1000 [==============================] - 0s 14us/step - loss: 0.6856 - acc: 0.5480
Epoch 10/10
1000/1000 [==============================] - 0s 16us/step - loss: 0.6852 - acc: 0.5410

Ora misuriamo testiamo l’accuratezza nel dataset di test


score = model.evaluate(x_test, y_test, batch_size=128)
print(score)
 
100/100 [==============================] - 0s 377us/step
[0.7096503973007202, 0.3799999952316284]

Se vuoi veramente imparare il deep learning sfruttando le potenzialità di python e Keras non perdere tempo a cercare gli argomenti nel web: investi in un buon libro e velocizza il tuo l’apprendimento.
Ti ricordo che il tempo che tu perdi tra un forum e l’altro, tra un blog e l’altro, lo potresti impiegare per studiare seriamente un buon manuale sull’argomento.

Ad esempio quello che ti propongo qui sotto.
Ovviamente, se tu lo acquisti io ci guadagno qualcosa e tu ci guadagni in formazione 🙂

Possiamo applicare questo modello a dati reali?

Utilizzeremo un famosissimo dataset e lo potete scaricare direttamente dal sito di UCI Machine Learning Repository a questo indirizzo

https://archive.ics.uci.edu/ml/datasets/Wine

Il dataset è composto dai i dati di tre categorie di vini e per la precisione abbiamo i seguenti dati organolettici

1) Alcohol
2) Acido malico
3) Ceneri
4) Alcalinità delle ceneri
5) Magnesio
6) Fenoli totali
7) Flavonoidi
8) Fenoli non flavonoidi
9) Proantocianine
10)Intensità del colore
11)Colorazione
12)OD280/OD315 di vini diluiti
13)Prolina

In [0]:
import numpy as np 
import pandas as pd
from keras.models import Sequential 
from keras.layers import Dense,Dropout
from sklearn.model_selection import train_test_split
from keras.utils import to_categorical
In [1]:
model = Sequential() # istanza di Sequential 
model.add(Dense(10, input_dim=13, activation='relu',name='hidde1')) #strato di input + hidden 
model.add(Dropout(0.5) )
model.add(Dense(1, activation='tanh',name='outLayer')) #strato di output
model.compile(loss='mean_squared_error', optimizer='rmsprop', metrics=['accuracy'])
model.summary()
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hidde1 (Dense)               (None, 10)                140       
_________________________________________________________________
dropout_4 (Dropout)          (None, 10)                0         
_________________________________________________________________
outLayer (Dense)             (None, 1)                 11        
=================================================================
Total params: 151
Trainable params: 151
Non-trainable params: 0
_________________________________________________________________
In [2]:
wine_data = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data',header=None)


np_wine_data = np.asarray(wine_data,dtype=np.float32)

for i in range(1,14):
  minx = np.min( np_wine_data[:,i] )
  maxx = np.max( np_wine_data[:,i])
  np_wine_data[:,i] = (np_wine_data[:,i]-minx)/(maxx-minx )
  



train, train_val = train_test_split(np_wine_data)



x_train = train[0:,1:]
y_train = train[0:,:1]-2

x_test = train_val[0:,1:]
y_test = train_val[0:,:1]-2 

#print(  np_wine_data[:,1]   )
In [3]:
model.fit(x_train, y_train, validation_data=(x_test,y_test),epochs=500, batch_size=64,verbose=0)
model.fit(x_train, y_train, validation_data=(x_test,y_test),epochs=20, batch_size=64,verbose=1)
Train on 133 samples, validate on 45 samples
Epoch 1/20
133/133 [==============================] - 0s 85us/step - loss: 0.1267 - acc: 0.8571 - val_loss: 0.0584 - val_acc: 0.9556
Epoch 2/20
133/133 [==============================] - 0s 66us/step - loss: 0.1263 - acc: 0.8421 - val_loss: 0.0583 - val_acc: 0.9556
Epoch 3/20
133/133 [==============================] - 0s 56us/step - loss: 0.1100 - acc: 0.9098 - val_loss: 0.0580 - val_acc: 0.9778
Epoch 4/20
133/133 [==============================] - 0s 56us/step - loss: 0.1597 - acc: 0.8271 - val_loss: 0.0574 - val_acc: 0.9778
Epoch 5/20
133/133 [==============================] - 0s 64us/step - loss: 0.1074 - acc: 0.9098 - val_loss: 0.0575 - val_acc: 0.9778
Epoch 6/20
133/133 [==============================] - 0s 63us/step - loss: 0.1387 - acc: 0.8722 - val_loss: 0.0573 - val_acc: 0.9778
Epoch 7/20
133/133 [==============================] - 0s 57us/step - loss: 0.1510 - acc: 0.8571 - val_loss: 0.0574 - val_acc: 0.9778
Epoch 8/20
133/133 [==============================] - 0s 71us/step - loss: 0.1341 - acc: 0.8797 - val_loss: 0.0572 - val_acc: 0.9778
Epoch 9/20
133/133 [==============================] - 0s 64us/step - loss: 0.1235 - acc: 0.8722 - val_loss: 0.0574 - val_acc: 0.9778
Epoch 10/20
133/133 [==============================] - 0s 57us/step - loss: 0.1279 - acc: 0.8496 - val_loss: 0.0567 - val_acc: 0.9556
Epoch 11/20
133/133 [==============================] - 0s 61us/step - loss: 0.1682 - acc: 0.8271 - val_loss: 0.0566 - val_acc: 0.9778
Epoch 12/20
133/133 [==============================] - 0s 61us/step - loss: 0.1764 - acc: 0.8120 - val_loss: 0.0562 - val_acc: 0.9556
Epoch 13/20
133/133 [==============================] - 0s 68us/step - loss: 0.1245 - acc: 0.8872 - val_loss: 0.0554 - val_acc: 0.9778
Epoch 14/20
133/133 [==============================] - 0s 70us/step - loss: 0.1154 - acc: 0.8797 - val_loss: 0.0556 - val_acc: 0.9778
Epoch 15/20
133/133 [==============================] - 0s 69us/step - loss: 0.1624 - acc: 0.8346 - val_loss: 0.0547 - val_acc: 0.9778
Epoch 16/20
133/133 [==============================] - 0s 51us/step - loss: 0.1447 - acc: 0.8496 - val_loss: 0.0546 - val_acc: 0.9778
Epoch 17/20
133/133 [==============================] - 0s 67us/step - loss: 0.1392 - acc: 0.8647 - val_loss: 0.0545 - val_acc: 0.9778
Epoch 18/20
133/133 [==============================] - 0s 75us/step - loss: 0.1533 - acc: 0.8421 - val_loss: 0.0548 - val_acc: 0.9778
Epoch 19/20
133/133 [==============================] - 0s 80us/step - loss: 0.1510 - acc: 0.8496 - val_loss: 0.0549 - val_acc: 0.9778
Epoch 20/20
133/133 [==============================] - 0s 75us/step - loss: 0.1399 - acc: 0.8722 - val_loss: 0.0551 - val_acc: 0.9778


Per ora ci fermiamo qui.

Se ti è piaciuto condividi su social.
Se hai suggerimenti, domande, critiche, non ti è chiaro qualcosa oppure vorresti altre informazioni o approfondimenti lascia un commento qui sotto.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Articolo precedente

Tensor Processing Units