keras: Deep Learning in R

Come ormai saprai, il machine learning è una sottoarea dell’Informatica (CS). Il deep learning, a sua volta, è una sottoarea del machine learning: un insieme di algoritmi ispirati alla struttura e al funzionamento del cervello, di solito chiamati Reti Neurali Artificiali (ANN). Il deep learning è una delle tendenze più calde del machine learning in questo momento e dà ottimi risultati in molti ambiti, come la robotica, il riconoscimento di immagini e l’Intelligenza Artificiale (AI).

Il tutorial di oggi ti darà una breve introduzione al deep learning in R con Keras tramite il pacchetto keras:

# Load in the keras package
library(keras)

# Install TensorFlow
install_tensorflow()

Caricare i dati

Ora che il processo di installazione è chiaro e il tuo workspace è pronto, puoi iniziare a caricare i tuoi dati! A questo punto hai tre grandi opzioni: puoi usare uno dei dataset integrati che arrivano con il pacchetto keras, puoi caricare un tuo dataset da, per esempio, file CSV, oppure puoi creare dei dati fittizi.

Qualunque sia la situazione, vedrai che riuscirai a iniziare rapidamente con il pacchetto. Questa sezione passerà rapidamente in rassegna le tre opzioni e spiegherà come puoi caricare (o creare) i dati di cui hai bisogno per metterti all’opera!

# Read in MNIST data
mnist <- dataset_mnist()

# Read in CIFAR10 data
cifar10 <- dataset_cifar10()

# Read in IMDB data
imdb <- dataset_imdb()

Esplorazione dei dati

Per questo tutorial, continuerai a lavorare con il famoso dataset iris che hai importato con la funzione read.csv().

Per chi non ha le conoscenze di biologia necessarie per lavorare con questi dati, ecco qualche informazione di base: tutti i fiori hanno un sepalo e un petalo. Il sepalo racchiude i petali ed è tipicamente verde e simile a una foglia, mentre i petali sono generalmente foglie colorate. Per i fiori di iris, è solo un po’ diverso, come puoi vedere nella figura seguente:

Potresti aver già notato nella sezione precedente che il data frame iris non aveva nomi di colonna dopo l’import. Per il resto del tutorial, questo non è troppo importante: anche se la funzione read.csv() ti restituisce i dati in un data.frame, i dati che dovrai passare alla funzione fit() devono essere una matrice o un array.

Alcune cose da tenere a mente su queste due strutture dati appena menzionate: - Le matrici e gli array non hanno nomi di colonna; - Le matrici sono oggetti bidimensionali di un unico tipo di dato; - Gli array sono oggetti multidimensionali di un unico tipo di dato;

Consiglio: guarda questo video se vuoi un ripasso delle strutture dati in R!

Il data frame, invece, è un tipo speciale di lista nominata in cui tutti gli elementi hanno la stessa lunghezza. È un oggetto multidimensionale che può contenere più tipi di dato. Lo hai già visto quando hai controllato la struttura del data frame iris nella sezione precedente. Sapendo questo e considerando che dovrai arrivare a un oggetto bi- o multidimensionale di un unico tipo di dato, dovresti già prepararti a fare un po’ di preprocessing prima di iniziare a costruire la tua rete neurale!

Per ora, i nomi di colonna possono essere utili per l’esplorazione, e faciliteranno la comprensione dei dati, quindi aggiungiamo alcuni nomi di colonna con l’aiuto della funzione names(). Poi puoi usare subito la variabile iris nella tua esplorazione! Traccia, ad esempio, come la lunghezza e la larghezza del petalo correlano con la funzione plot().

Nota che usi la funzione unclass() per convertire i nomi delle specie, cioè “setosa, versicolor” e “virginica”, nei numeri 1, 2 e 3.

Ora guarda più da vicino il risultato della funzione di plotting:

Il grafico indica una correlazione positiva tra Petal.Length e Petal.Width per le diverse specie dei fiori di iris. Tuttavia, probabilmente vorrai verificarlo con la funzione cor(), che ti darà la correlazione complessiva tra tutti gli attributi inclusi nel dataset:

Inoltre, puoi usare il pacchetto corrplot insieme alla funzione cor() per tracciare le correlazioni tra gli attributi dei tuoi dati; in questo caso, calcoli la correlazione complessiva per tutti gli attributi del data frame iris. Memorizzi il risultato di questo calcolo in una variabile M e lo passi alla funzione corrplot().

Non dimenticare anche di specificare l’argomento method per indicare come vuoi che i dati vengano rappresentati!

Puoi fare altre prove con il metodo di visualizzazione nel riquadro DataCamp Light qui sotto:

Usa la console di R per esplorare ulteriormente i tuoi dati.

Se vuoi creare grafici per questi dati con il pacchetto ggvis, che è la grammar of graphics interattiva, dai un’occhiata al tutorial di DataCamp Machine Learning in R For Beginners o segui il corso ggvis di DataCamp.

Preprocessing dei dati

Prima di poter costruire il tuo modello, devi anche assicurarti che i tuoi dati siano puliti, normalizzati (se applicabile) e divisi in training set e test set. Poiché il dataset proviene dall’UCI Machine Learning Repository, puoi aspettarti che sia già piuttosto pulito, ma verifichiamo comunque la qualità dei tuoi dati.

A prima vista, quando hai ispezionato i dati con head(), non hai visto nulla di strano, giusto? Usiamo summary() e str() per ricapitolare brevemente cosa hai imparato quando hai verificato se l’import dei tuoi dati era riuscito:

Ora che sei sicuro che i dati siano sufficientemente puliti, puoi iniziare verificando se la normalizzazione è necessaria per qualcuno dei dati con cui stai lavorando in questo tutorial.

x_train <- imdb$train$x
y_train <- imdb$train$y
x_test <- imdb$test$x
y_test <- imdb$test$y

Costruire il modello

Per iniziare a costruire un modello, dovresti prima inizializzare un modello sequenziale con l’aiuto della funzione keras_model_sequential(). Poi sei pronto per cominciare a modellare.

Tuttavia, prima di iniziare, è una buona idea riprendere la tua domanda originale su questo dataset: puoi predire la specie di un determinato fiore di Iris? È più facile lavorare con dati numerici, e hai preprocessato i dati e fatto la one hot encoding dei valori della variabile target: un fiore è di tipo versicolor, setosa o virginica e questo è riflesso da valori binari 1 e 0.

Un tipo di rete che si comporta bene su un problema del genere è un perceptron multistrato. Questo tipo di rete neurale è spesso fully connected. Ciò significa che vuoi costruire uno stack relativamente semplice di layer completamente connessi per risolvere questo problema. Per quanto riguarda le funzioni di attivazione che userai, è meglio ricorrere a una delle più comuni per prendere confidenza con Keras e le reti neurali, ovvero la funzione di attivazione relu. Questa funzione di attivazione rettificatrice è usata in un layer nascosto, il che in generale è una buona pratica.

Inoltre, vedi anche che la funzione di attivazione softmax è usata nel layer di output. Lo fai perché vuoi assicurarti che i valori in uscita siano nell’intervallo tra 0 e 1 e possano essere usati come probabilità previste:

Nota come il layer di output crea 3 valori di output, uno per ciascuna classe di Iris (versicolor, virginica o setosa). Il primo layer, che contiene 8 unità nascoste, invece, ha un input_shape pari a 4. Questo perché i tuoi dati di training iris.training hanno 4 colonne.

Puoi ispezionare ulteriormente il tuo modello con le seguenti funzioni:

• puoi usare la funzione summary() per stampare una rappresentazione sintetica del modello;
• get_config() restituirà un elenco che contiene la configurazione del modello;
• get_layer() restituirà la configurazione del layer;
• l'attributo layers può essere usato per recuperare un elenco piatto dei layer del modello;
• per elencare i tensori di input, puoi usare l'attributo inputs; e
• infine, per recuperare i tensori di output, puoi usare l'attributo outputs.

Compila e adatta il modello

Ora che hai impostato l'architettura del modello, è il momento di compilarlo e adattarlo ai dati. Per compilare il modello, configuralo con l'ottimizzatore adam e la funzione di perdita categorical_crossentropy. Inoltre, durante l'addestramento monitora anche l'accuratezza passando 'accuracy' all'argomento metrics.

L'ottimizzatore e la perdita sono due argomenti obbligatori se vuoi compilare il modello.

Alcuni degli algoritmi di ottimizzazione più popolari sono lo Stochastic Gradient Descent (SGD), ADAM e RMSprop. A seconda dell'algoritmo che scegli, dovrai tarare alcuni parametri, come il learning rate o il momentum. La scelta della funzione di perdita dipende dal compito: per esempio, per un problema di regressione userai di solito la Mean Squared Error (MSE).

Come vedi in questo esempio, hai usato la funzione di perdita categorical_crossentropy per il problema di classificazione multiclasse che determina se un'iris è di tipo versicolor, virginica o setosa. Nota però che, se avessi avuto un problema di classificazione binaria, avresti dovuto usare la funzione di perdita binary_crossentropy.

Successivamente, puoi anche adattare il modello ai tuoi dati; in questo caso, addestri il modello per 200 epoche o iterazioni su tutti i campioni in iris.training e iris.trainLabels, in batch da 5 campioni.

Dritta: se vuoi, puoi anche specificare l'argomento verbose nella funzione fit(). Impostandolo a 1, indichi che vuoi vedere il log con la barra di avanzamento.

Con il codice qui sopra stai addestrando il modello per un numero specifico di epoche o passaggi sul dataset di training. Un'epoca è un singolo passaggio su tutto il training set, seguito dal test sul set di validazione. La dimensione del batch che specifichi nel codice definisce il numero di campioni che verranno propagati attraverso la rete. Inoltre, in questo modo ottimizzi l'efficienza perché ti assicuri di non caricare in memoria troppi pattern di input contemporaneamente.

Visualizza la cronologia dell'addestramento del modello

È anche utile sapere che puoi visualizzare il fitting se assegni le righe di codice nel riquadro DataCamp Light qui sopra a una variabile. Puoi poi passare la variabile alla funzione plot(), come vedi in questo blocco di codice!

Assicurati di studiare il grafico più nel dettaglio.

A prima vista, non stupisce che sembri un po' caotico. Potresti non sapere esattamente cosa stai guardando, giusto?

Una cosa utile da sapere è che loss e acc indicano rispettivamente la perdita e l'accuratezza del modello sui dati di training, mentre val_loss e val_acc sono le stesse metriche, perdita e accuratezza, sui dati di test o di validazione.

Ma, anche sapendolo, non è facile interpretare questi due grafici. Proviamo a spezzare il tutto in parti più semplici da capire! Dividerai questi due grafici e ne farai due separati: uno per la perdita del modello e un altro per l'accuratezza. Per fortuna, puoi usare facilmente l'operatore $ per accedere ai dati e tracciarli passo dopo passo.

Dai un'occhiata al riquadro DataCamp Light qui sotto per vedere come fare:

In questo primo grafico, hai tracciato la perdita del modello sui dati di training e di test. Ora è il momento di fare lo stesso anche per l'accuratezza del modello:

Alcune cose da tenere a mente qui sono le seguenti:

• se l'accuratezza sui dati di training continua a migliorare mentre quella sui dati di validazione peggiora, probabilmente stai overfittando: il modello inizia a memorizzare i dati invece di imparare da essi;
• se la tendenza dell'accuratezza su entrambi i dataset è ancora in crescita nelle ultime epoche, è chiaro che il modello non ha ancora sovraimparato il dataset di training.

Predici le etichette di nuovi dati

Ora che il modello è stato creato, compilato e adattato ai dati, è il momento di usarlo per predire le etichette del set di test iris.test. Come ti aspettavi, puoi usare la funzione predict() per farlo. Dopo, puoi stampare la matrice di confusione per verificare le predizioni e le etichette reali dei dati iris.test con l'aiuto della funzione table().

Cosa ne pensi dei risultati? A prima vista, questo modello che hai creato fa le previsioni giuste?

Valutare il tuo modello

Anche se hai già un'idea di come ha performato il modello guardando le etichette predette per iris.test, è comunque importante prenderti il tempo per valutarlo. Usa la funzione evaluate() per farlo: passa i dati di test iris.test, le etichette di test iris.testLabels e definisci la dimensione del batch. Salva il risultato in una variabile score, come nell'esempio di codice qui sotto:

Stampando score, otterrai il valore della perdita e quello della metrica (in questo caso 'accuracy').

Fine-tuning del tuo modello

Il fine-tuning del modello è probabilmente qualcosa che farai spesso, soprattutto all'inizio, perché non tutti i problemi di classificazione e regressione sono semplici come quello che hai visto nella prima parte di questo tutorial. Come hai letto sopra, ci sono già due decisioni chiave che probabilmente vorrai modificare: quante layer usare e quante "unità nascoste" scegliere per ciascun layer.

All'inizio sarà davvero un bel percorso.

Oltre a giocare con il numero di epoche o con la dimensione del batch, ci sono altri modi per ritoccare il modello nella speranza che renda meglio: aggiungendo layer, aumentando il numero di unità nascoste e passando parametri di ottimizzazione personalizzati alla funzione compile(). Questa sezione coprirà queste tre opzioni.

Salvataggio, caricamento o esportazione del tuo modello

C’è un’ultima cosa che resta nel tuo percorso con il pacchetto keras: salvare o esportare il modello in modo da poterlo ricaricare in un altro momento.

• Per prima cosa, puoi facilmente usare le funzioni save_model_hdf5() e load_model_hdf5() per salvare e caricare il modello nel tuo workspace:

save_model_hdf5(model, "my_model.h5")
model <- load_model_hdf5("my_model.h5")

• Inoltre, puoi anche salvare e caricare i pesi del modello con le funzioni save_model_weights_hdf5() e load_model_weights_hdf5():

save_model_weights_hdf5("my_model_weights.h5")
model %>% load_model_weights_hdf5("my_model_weights.h5")

• Infine, è utile sapere che puoi anche esportare la configurazione del modello in JSON o YAML. Qui ti vengono in aiuto le funzioni model_to_json() e model_to_yaml(). Per ricaricare le configurazioni nel tuo workspace, puoi semplicemente usare le funzioni model_from_json() e model_from yaml():

json_string <- model_to_json(model)
model <- model_from_json(json_string)

yaml_string <- model_to_yaml(model)
model <- model_from_yaml(yaml_string)