Keras è una libreria open source per la creazione di ap­pli­ca­zio­ni di ap­pren­di­men­to profondo (chiamato anche deep learning). Keras utilizza il lin­guag­gio Python e offre un’in­ter­fac­cia unitaria per i vari back end di deep learning come Ten­sor­Flow e Theano. L’ap­pren­di­men­to profondo è una branca dell’ap­pren­di­men­to au­to­ma­ti­co basata sulle reti neurali ar­ti­fi­cia­li.

Keras punta a sem­pli­fi­ca­re il primo approccio col deep learning. In questo tutorial su Keras vi il­lu­stre­re­mo il fun­zio­na­men­to di Keras aiu­tan­do­ci con un semplice ma pratico esempio.

Cloud Backup powered by Acronis
Riduci i tempi di inat­ti­vi­tà e proteggi i carichi di lavoro
  • Backup au­to­ma­ti­ci e recupero dei dati
  • Pia­ni­fi­ca­zio­ne e gestione intuitive delle attività
  • Pro­te­zio­ne dalle minacce basata sul­l'in­tel­li­gen­za ar­ti­fi­cia­le

Preparare il vostro sistema per l’utilizzo di Keras

Preparate al meglio il vostro sistema per l’utilizzo di Keras in­stal­lan­do il pacchetto software Anaconda, una piat­ta­for­ma gratuita per il data science (scienza dei dati). Al suo interno sono contenute librerie e strumenti utili, corredati da un’in­stal­la­zio­ne di Python3.

In­stal­la­re Anaconda e Python

La seguente spie­ga­zio­ne e il codice da uti­liz­za­re fanno ri­fe­ri­men­to al sistema operativo macOS. In linea teorica, il codice vale anche per altri sistemi. Tuttavia, può darsi che sia ne­ces­sa­rio adottare alcuni ac­cor­gi­men­ti, in par­ti­co­la­re su Windows. Se vi sentite sicuri nell’uso della riga di comando e se avete il gestore di pacchetti Homebrew già in­stal­la­to sul vostro Mac, uti­liz­za­te­li per in­stal­la­re Anaconda. Per farlo, aprite la riga di comando (Terminal.app su Mac), copiate il seguente codice nel terminale e premete invio.

brew cask install anaconda

Se non doveste avere a di­spo­si­zio­ne Homebrew o se de­si­de­ra­te in­stal­la­re Anaconda in Windows o Linux, scaricate il pacchetto di in­stal­la­zio­ne cor­ri­spon­den­te dalla pagina seguente: Anaconda In­di­vi­dual Edition.

Ve­ri­fi­ca­re l’in­stal­la­zio­ne di Anaconda e Python

Per as­si­cu­rar­vi che Anaconda e Python siano stati in­stal­la­ti cor­ret­ta­men­te, eseguite i seguenti comandi sul terminale.

Per vi­sua­liz­za­re la versione del gestore di pacchetti Conda

conda –version

Per vi­sua­liz­za­re la versione dell’in­ter­pre­te Python

python --version

Se eseguendo questi codici ricevete il messaggio d’errore “Comando non trovato”, indicate il percorso al file binario Anaconda. Leggete il prossimo paragrafo per scoprire come fare. Se, invece, il test ha fun­zio­na­to potete saltare il passaggio seguente.

Definire il percorso al file binario Anaconda

La variabile d’ambiente PATH contiene in­for­ma­zio­ni riguardo dove trovare de­ter­mi­na­ti programmi d’as­si­sten­za nel file system. I singoli percorsi all’interno di una variabile d’ambiente vengono separati dai due punti. Potete ag­giun­ge­re ulteriori percorsi a quello mostrato qui di seguito per la versione 3 di Anaconda:

export PATH=/usr/local/anaconda3/bin:"$PATH"

Per far sì che il percorso diventi ef­fet­ti­va­men­te attivo, dovete me­mo­riz­za­re questa riga di codice nel sistema. In base al sistema e alla shell uti­liz­za­ti (Bash, zsh, ecc.) varia il file nel quale devono essere applicate le modifiche. Vi mostriamo un esempio per Bash con macOS.

Eseguite i seguenti codici nella riga di comando per adattare la variabile percorso nel file bash_profile:

Variabile percorso per espandere l’in­stal­la­zio­ne di Anaconda

echo -n 'export PATH=/usr/local/anaconda3/bin:"$PATH"' >> "$HOME/.bash_profile"

Caricare il file .bash_profile

source "$HOME/.bash_profile"
Consiglio

Usate il comando 'cat "$HOME/.bash_profile"' nel terminale per vi­sua­liz­za­re il file .bash_profile esistente.

Quindi ripetete i test:

Vi­sua­liz­za­re la versione del gestore di pacchetti Conda

conda –version

Vi­sua­liz­za­re la versione dell’in­ter­pre­te Python

python --version

A questo punto vi dovrebbe essere mostrato il numero della versione. Se ciò accade potete pro­se­gui­re con i passaggi suc­ces­si­vi.

Ag­gior­na­re le in­stal­la­zio­ni di Anaconda e Python

Prima di avviare un nuovo progetto, è con­si­glia­bi­le ag­gior­na­re le librerie. La piat­ta­for­ma Anaconda porta con sé il gestore di pacchetti “conda”. Uti­liz­za­te i seguenti comandi Conda per accedere agli ag­gior­na­men­ti di­spo­ni­bi­li:

Per in­stal­la­re gli ag­gior­na­men­ti per il gestore di pacchetti Conda

conda update conda

Per in­stal­la­re gli ag­gior­na­men­ti di Anaconda

conda update anaconda

Ve­ri­fi­ca­re il numero di versione del pacchetto Keras in­stal­la­to

Come già men­zio­na­to, Keras è scritto in lin­guag­gio Python e si basa su una mol­ti­tu­di­ne di altri moduli Python. Eseguite il seguente blocco di codici nella riga di comando per vi­sua­liz­za­re il numero della versione del pacchetto di Keras più co­mu­ne­men­te uti­liz­za­to per l’ap­pren­di­men­to profondo:

python << EOF
print()
# scipy
import scipy
print('scipy: %s' % scipy.__version__)
# numpy
import numpy
print('numpy: %s' % numpy.__version__)
# matplotlib
import matplotlib
print('matplotlib: %s' % matplotlib.__version__)
# pandas
import pandas
print('pandas: %s' % pandas.__version__)
# statsmodels
import statsmodels
print('statsmodels: %s' % statsmodels.__version__)
# scikit-learn
import sklearn
print('sklearn: %s' % sklearn.__version__)
print()
EOF

In­stal­la­re Keras sul vostro sistema

Dopo aver cor­ret­ta­men­te preparato il sistema è giunta l’ora di procedere con l’in­stal­la­zio­ne di Keras. Tutto ciò che dovete fare è eseguire il seguente codice nella riga di comando:

In­stal­la­re Ten­sor­Flow

pip install tensorflow

In­stal­la­re Keras

pip install keras

Come da con­sue­tu­di­ne, ve­ri­fi­ca­te a questo punto la versione Keras in­stal­la­ta. Per farlo uti­liz­za­te:

python -c "import keras; print(keras.__version__)"

Se l’in­stal­la­zio­ne di Keras non è suf­fi­cien­te­men­te recente, la prima cosa da fare è cercare e in­stal­la­re gli ag­gior­na­men­ti di­spo­ni­bi­li, ed è proprio a questo che serve il seguente codice. Copiatelo ed ese­gui­te­lo nella riga di comando:

pip install --upgrade keras

Esempio di deep learning facile con Keras

Il team di Keras rilascia una lista di esempi rea­liz­za­ti con Keras ac­ces­si­bi­li con una licenza libera su GitHub. Qui trat­te­re­mo l’esempio mnist_cnn.py. Il relativo codice serve a creare una Con­vo­lu­tio­nal Neural Network (CNN o ConvNet) e ad ad­de­strar­la con i relativi dati di ap­pren­di­men­to.

Come dati di ap­pren­di­men­to e testing, lo script di questo esempio con Keras utilizza i record MNIST. Questi con­si­sto­no in una grande raccolta di piccole immagini, ognuna delle di­men­sio­ni di 28 x 28 pixel. Ogni immagine contiene un numero scritto a mano. Il record MNIST è lo standard per il ri­co­no­sci­men­to dei modelli e viene fornito di­ret­ta­men­te assieme a Keras.

Se siete curiosi potete vi­sua­liz­za­re i dati di al­le­na­men­to e di test, copiando ed eseguendo il seguente blocco di codici nella riga di comando. A ogni ese­cu­zio­ne vi viene mostrata un’immagine di al­le­na­men­to.

python << EOF
# caricare Keras
import keras
# caricare gli input di dati di apprendimento e di test MNIST
from keras.datasets import mnist
# caricare la libreria per la visualizzazione
import matplotlib.pyplot as plt
# caricare la funzione per la scelta casuale dell’immagine
from random import randint
# caricare i record
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# mostrare l’immagine
plt.figure()
plt.imshow(train_images[randint(1, len(train_images) - 1)])
plt.grid(False)
plt.show()
EOF

Ora in­se­gne­re­mo alla rete neurale a mettere nella sequenza corretta le cifre scritte a mano. L’al­le­na­men­to della rete richiede una capacità di calcolo si­gni­fi­ca­ti­va. Non c’è da stupirsi dunque se il vostro computer dovesse bloccarsi o subire dei ral­len­ta­men­ti. Nel caso in cui stiate usando un di­spo­si­ti­vo mobile, fate at­ten­zio­ne che la batteria sia suf­fi­cien­te­men­te carica o al­tri­men­ti collegate il di­spo­si­ti­vo all’ali­men­ta­zio­ne.

Per prima cosa creeremo una cartella di prova sul desktop, passeremo alla cartella e creeremo al suo interno uno script Python vuoto. Usate il seguente codice:

Per creare una cartella “keras-test” sul desktop

mkdir "$HOME/Desktop/keras-test/" && cd "$HOME/Desktop/keras-test/"

Per creare uno script Python vuoto

touch keras-test.py

Dopodiché dovete copiare lo script nel file keras-test.py e salvare.

Dopo aver creato la cartella di prova, passate alla creazione dello script di prova con Keras. Copiate il codice alla fine di questo articolo e in­se­ri­te­lo in un documento di testo vuoto. Salvate il documento nel file ancora vuoto kera-test.py all’interno della cartella keras-test appena creata sul desktop. Per eseguire lo script d’esempio con Keras usando l’in­ter­pre­te Python, scrivete le seguenti righe di codice nel terminale e con­fer­ma­te:

cd "$HOME/Desktop/keras-test/" && python keras-test.py

In cambio dovreste vi­sua­liz­za­re alcune in­for­ma­zio­ni di stato. Dopodiché lo script dovrebbe avviare l’ap­pren­di­men­to della ConvNet, mo­stran­do­vi l’andamento in tempo reale delle varie fasi. Dopo la con­clu­sio­ne dello script la ConvNet è ad­de­stra­ta e pronta a clas­si­fi­ca­re le cifre scritte a mano.

N.B.

Per salvare il codice uti­liz­za­te esclu­si­va­men­te un editor di codice o plain text. Non adoperate mai a questo scopo i software di ela­bo­ra­zio­ne testi come Word, Ope­nOf­fi­ce o Li­breOf­fi­ce.

# Salvare il codice nel file keras-test.py all’interno della cartella keras-test
from __future__ import print_function
# caricare Keras
import keras
# caricare gli input di dati di apprendimento e di test MNIST
from keras.datasets import mnist
# caricare il modello sequenziale
from keras.models import Sequential
# caricare i livelli della rete neurale
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
# numero delle diverse caratteristiche dei dati: cifre 0–9
num_classes = 10
# numero delle sedute di apprendimento della rete neurale
epochs = 12
# numero dei dati utilizzati durante una seduta
batch_size = 128
# dimensioni delle immagini di input (28 x 28 pixel per immagine)
img_rows, img_cols = 28, 28
# caricare i dati di apprendimento e di test
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
if K.image_data_format() == 'channels_first':
    train_images = train_images.reshape(train_images.shape[0], 1, img_rows, img_cols)
    test_images = test_images.reshape(test_images.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)
else:
    train_images = train_images.reshape(train_images.shape[0], img_rows, img_cols, 1)
    test_images = test_images.reshape(test_images.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)
# definire i tipi di dati con numero in virgola mobile
train_images = train_images.astype('float32')
test_images = test_images.astype('float32')
# normalizzare i dati dell’immagine
train_images /= 255
test_images /= 255
print('train_images shape:', train_images.shape)
print(train_images.shape[0], 'train samples')
print(test_images.shape[0], 'test samples')
# convertire le classi vettore in classi matrice binarie
train_labels = keras.utils.to_categorical(train_labels, num_classes)
test_labels = keras.utils.to_categorical(test_labels, num_classes)
# generare il modello
model = Sequential()
# aggiungere livelli al modello
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
# compilare il modello
model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy'])
# allenare il modello
model.fit(train_images, train_labels,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1,
          validation_data=(test_images, test_labels))
# valutare il modello
score = model.evaluate(test_images, test_labels, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
Vai al menu prin­ci­pa­le