Deeplearning4j Tutorial: Java per il Deep Learning

 

 

 

La libreria Java per il Deep Learning

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

Caratteristiche e vantaggi

Breve 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.

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]

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

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Articolo precedente

Il Percettrone

Articolo successivo

Keras LSTM Tutorial