Tutorial su Keras: esempi di apprendimento profondo con Keras e Python

Keras è una libreria open source per la creazione di applicazioni di apprendimento profondo (chiamato anche deep learning). Keras utilizza il linguaggio Python e offre un’interfaccia unitaria per i vari back end di deep learning come TensorFlow e Theano. L’apprendimento profondo è una branca dell’apprendimento automatico basata sulle reti neurali artificiali.

Keras punta a semplificare il primo approccio col deep learning. In questo tutorial su Keras vi illustreremo il funzionamento di Keras aiutandoci con un semplice ma pratico esempio.

Cloud Backup di IONOS

Evita costosi downtime! Facile soluzione di backup per il tuo business.

Semplice
Sicuro
Integrato

Preparare il vostro sistema per l’utilizzo di Keras

Preparate al meglio il vostro sistema per l’utilizzo di Keras installando il pacchetto softwareAnaconda, una piattaforma gratuita per il data science (scienza dei dati). Al suo interno sono contenute librerie e strumenti utili, corredati da un’installazione di Python3.

Installare Anaconda e Python

La seguente spiegazione e il codice da utilizzare fanno riferimento al sistema operativo macOS. In linea teorica, il codice vale anche per altri sistemi. Tuttavia, può darsi che sia necessario adottare alcuni accorgimenti, in particolare su Windows. Se vi sentite sicuri nell’uso della riga di comando e se avete il gestore di pacchetti Homebrew già installato sul vostro Mac, utilizzateli per installare 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 disposizione Homebrew o se desiderate installare Anaconda in Windows o Linux, scaricate il pacchetto di installazione corrispondente dalla pagina seguente: Anaconda Individual Edition.

Verificare l’installazione di Anaconda e Python

Per assicurarvi che Anaconda e Python siano stati installati correttamente, eseguite i seguenti comandi sul terminale.

Per visualizzare la versione del gestore di pacchetti Conda

conda –version

Per visualizzare la versione dell’interprete 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 funzionato potete saltare il passaggio seguente.

Definire il percorso al file binario Anaconda

La variabile d’ambiente PATH contiene informazioni riguardo dove trovare determinati programmi d’assistenza nel file system. I singoli percorsi all’interno di una variabile d’ambiente vengono separati dai due punti. Potete aggiungere 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 effettivamente attivo, dovete memorizzare questa riga di codice nel sistema. In base al sistema e alla shell utilizzati (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’installazione 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 visualizzare il file .bash_profile esistente.

Quindi ripetete i test:

Visualizzare la versione del gestore di pacchetti Conda

conda –version

Visualizzare la versione dell’interprete Python

python --version

A questo punto vi dovrebbe essere mostrato il numero della versione. Se ciò accade potete proseguire con i passaggi successivi.

Aggiornare le installazioni di Anaconda e Python

Prima di avviare un nuovo progetto, è consigliabile aggiornare le librerie. La piattaforma Anaconda porta con sé il gestore di pacchetti “conda”. Utilizzate i seguenti comandi Conda per accedere agli aggiornamenti disponibili:

Per installare gli aggiornamenti per il gestore di pacchetti Conda

conda update conda

Per installare gli aggiornamenti di Anaconda

conda update anaconda

Verificare il numero di versione del pacchetto Keras installato

Come già menzionato, Keras è scritto in linguaggio Python e si basa su una moltitudine di altri moduli Python. Eseguite il seguente blocco di codici nella riga di comando per visualizzare il numero della versione del pacchetto di Keras più comunemente utilizzato per l’apprendimento 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

Installare Keras sul vostro sistema

Dopo aver correttamente preparato il sistema è giunta l’ora di procedere con l’installazione di Keras. Tutto ciò che dovete fare è eseguire il seguente codice nella riga di comando:

Installare TensorFlow

pip install tensorflow

Installare Keras

pip install keras

Come da consuetudine, verificate a questo punto la versione Keras installata. Per farlo utilizzate:

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

Se l’installazione di Keras non è sufficientemente recente, la prima cosa da fare è cercare e installare gli aggiornamenti disponibili, ed è proprio a questo che serve il seguente codice. Copiatelo ed eseguitelo nella riga di comando:

pip install --upgrade keras

Esempio di deep learning facile con Keras

Il team di Keras rilascia una lista di esempi realizzati con Keras accessibili con una licenza libera su GitHub. Qui tratteremo l’esempio mnist_cnn.py. Il relativo codice serve a creare una Convolutional Neural Network (CNN o ConvNet) e ad addestrarla con i relativi dati di apprendimento.

Come dati di apprendimento e testing, lo script di questo esempio con Keras utilizza i record MNIST. Questi consistono in una grande raccolta di piccole immagini, ognuna delle dimensioni di 28 x 28 pixel. Ogni immagine contiene un numero scritto a mano. Il record MNIST è lo standard per il riconoscimento dei modelli e viene fornito direttamente assieme a Keras.

Se siete curiosi potete visualizzare i dati di allenamento e di test, copiando ed eseguendo il seguente blocco di codici nella riga di comando. A ogni esecuzione vi viene mostrata un’immagine di allenamento.

 

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 insegneremo alla rete neurale a mettere nella sequenza corretta le cifre scritte a mano. L’allenamento della rete richiede una capacità di calcolo significativa. Non c’è da stupirsi dunque se il vostro computer dovesse bloccarsi o subire dei rallentamenti. Nel caso in cui stiate usando un dispositivo mobile, fate attenzione che la batteria sia sufficientemente carica o altrimenti collegate il dispositivo all’alimentazione.

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 inseritelo 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’interprete Python, scrivete le seguenti righe di codice nel terminale e confermate:

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

In cambio dovreste visualizzare alcune informazioni di stato. Dopodiché lo script dovrebbe avviare l’apprendimento della ConvNet, mostrandovi l’andamento in tempo reale delle varie fasi. Dopo la conclusione dello script la ConvNet è addestrata e pronta a classificare le cifre scritte a mano.

N.B.

Per salvare il codice utilizzate esclusivamente un editor di codice o plain text. Non adoperate mai a questo scopo i software di elaborazione testi come Word, OpenOffice o LibreOffice.

# 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])

Abbiamo una proposta per te:
Web hosting a partire da 1 €/mese!

Dominio gratis
Certificato SSL Wildcard incluso
Assistenza clienti 24/7
A partire da 1 €/mese IVA escl. per un anno,
poi 8 €/ mese IVA escl.