Valutare le prestazioni dei modelli di Deep Learning

Il deep learning è un campo in continua evoluzione e in costante miglioramento nel consentire alle aziende di fare previsioni ancora più accurate. L'intelligenza artificiale non è solo per le grandi aziende con budget elevati, perché richiede molti dati, è anche uno strumento che può essere utilizzato da aziende di qualsiasi dimensione.

Nel post del blog di oggi illustreremo come valutare le prestazioni dei modelli di deep learning.

piu' nel particolare vedremo un esempio reale con python e keras.

Keras è una libreria Python potente e facile da usare per il deep learning.

Ci sono molte decisioni da prendere durante la progettazione e la configurazione dei modelli di deep learning. La maggior parte di queste decisioni deve essere risolta empiricamente attraverso tentativi ed errori e valutandole su dati reali.

Pertanto, è di fondamentale importanza disporre di un modo solido per valutare le prestazioni delle reti neurali e dei modelli di deep learning.

È necessario prendere una miriade di decisioni durante la progettazione e la configurazione dei modelli di deep learning.

Molte di queste decisioni possono essere risolte copiando la struttura delle reti di altre persone. In definitiva, la tecnica migliore è progettare effettivamente piccoli esperimenti e valutare empiricamente i problemi utilizzando dati reali.

Ciò include decisioni di alto livello come il numero, la dimensione e il tipo di livelli nella tua rete. Include anche le decisioni di livello inferiore come la scelta della funzione di perdita, le funzioni di attivazione, la procedura di ottimizzazione e il numero di epoche .

Il deep learning viene spesso utilizzato su problemi con set di dati molto grandi. Sono decine di migliaia o centinaia di migliaia di istanze.

Pertanto, è necessario disporre di un solido test che consenta di stimare le prestazioni di una determinata configurazione su dati invisibili e confrontare in modo affidabile le prestazioni con altre configurazioni.

La grande quantità di dati e la complessità dei modelli richiedono tempi di training molto lunghi. Pertanto, è tipico separare i dati in set di dati di addestramento e test o set di dati di addestramento e convalida.

Keras offre due modi convenienti per valutare i tuoi algoritmi di deep learning in questo modo:

Keras può separare una parte dei tuoi dati di addestramento in un set di dati di convalida e valutare le prestazioni del tuo modello su quel set di dati di convalida in ogni epoca.

Puoi farlo impostando l' argomento validation_split sulla funzione fit() su una percentuale della dimensione del tuo set di dati di addestramento.

Ad esempio, un valore ragionevole potrebbe essere 0,2 o 0,33 per il 20% o il 33% dei dati di addestramento trattenuti per la convalida.

L'esempio seguente mostra l'uso di un set di dati di convalida automatica su un piccolo problema di classificazione binaria. Tutti gli esempi in questo post utilizzano il set di dati sull'inizio del diabete . Puoi scaricarlo dall'UCI Machine Learning Repository e salvare il file di dati nella tua directory di lavoro corrente con il nome del file diabetes.csv (aggiornamento: scarica da qui ).

# Creiamo un modello che poi valuteremo insieme
 from tensorflow.keras.models import Sequential
 from tensorflow.keras.layers import Dense
 import numpy
 # Fissiamo un seme così avremo gli stessi risultati
 numpy.random.seed(7)
 # carichiamo il dataset
 dataset = numpy.loadtxt("diabetes.csv", delimiter=",")
 # input (X) e output (Y)
 X = dataset[:,0:8]
 Y = dataset[:,8]
 # definiamo il nostro modello
 model = Sequential()
 model.add(Dense(12, input_dim=8, activation='relu'))
 model.add(Dense(8, activation='relu'))
 model.add(Dense(1, activation='sigmoid'))
 # Compiliamo il modello
 model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
 # Alleniamolo
 model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10)

Eseguendo l'esempio, puoi vedere che l'output dettagliato su ogni epoca mostra la perdita e l'accuratezza sia sul set di dati di addestramento che sul set di dati di convalida.

Epoch 145/150
 514/514 [==============================] - 0s - loss: 0.5252 - acc: 0.7335 - val_loss: 0.5489 - val_acc: 0.7244
 Epoch 146/150
 514/514 [==============================] - 0s - loss: 0.5198 - acc: 0.7296 - val_loss: 0.5918 - val_acc: 0.7244
 Epoch 147/150
 514/514 [==============================] - 0s - loss: 0.5175 - acc: 0.7335 - val_loss: 0.5365 - val_acc: 0.7441
 Epoch 148/150
 514/514 [==============================] - 0s - loss: 0.5219 - acc: 0.7354 - val_loss: 0.5414 - val_acc: 0.7520
 Epoch 149/150
 514/514 [==============================] - 0s - loss: 0.5089 - acc: 0.7432 - val_loss: 0.5417 - val_acc: 0.7520
 Epoch 150/150
 514/514 [==============================] - 0s - loss: 0.5148 - acc: 0.7490 - val_loss: 0.5549 - val_acc: 0.7520

Keras consente inoltre di specificare manualmente il set di dati da utilizzare per la convalida durante l'addestramento.

In questo esempio, puoi utilizzare la pratica funzione train_test_split () della libreria di apprendimento automatico scikit-learn di Python per separare i tuoi dati in un set di dati di addestramento e test. Utilizzare il 67% per la formazione e il restante 33% dei dati per la convalida.

Il set di dati di convalida può essere specificato nella fit() funzione in Keras validation_datadall'argomento. Richiede una tupla dei set di dati di input e output.

# Creiamo un modello che poi valuteremo insieme
 from tensorflow.keras.models import Sequential
 from tensorflow.keras.layers import Dense
 import numpy
 # Fissiamo un seme così avremo gli stessi risultati
 numpy.random.seed(7)
 # carichiamo il dataset
 dataset = numpy.loadtxt("diabetes.csv", delimiter=",")
 # dividiamo in 67% per l'allenamento e il 33% per il test
 X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=seed)
 # creiamo il modello
 model = Sequential()
 model.add(Dense(12, input_dim=8, activation='relu'))
 model.add(Dense(8, activation='relu'))
 model.add(Dense(1, activation='sigmoid'))
 # Compiliamolo
 model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
 # Alleniamolo
 model.fit(X_train, y_train, validation_data=(X_test,y_test), epochs=150, batch_size=10)

Come prima, l'esecuzione dell'esempio fornisce un output dettagliato dell'addestramento che include la perdita e l'accuratezza del modello sui set di dati di addestramento e convalida per ogni epoca.

 Epoch 145/150
 514/514 [==============================] - 0s - loss: 0.4847 - acc: 0.7704 - val_loss: 0.5668 - val_acc: 0.7323
 Epoch 146/150
 514/514 [==============================] - 0s - loss: 0.4853 - acc: 0.7549 - val_loss: 0.5768 - val_acc: 0.7087
 Epoch 147/150
 514/514 [==============================] - 0s - loss: 0.4864 - acc: 0.7743 - val_loss: 0.5604 - val_acc: 0.7244
 Epoch 148/150
 514/514 [==============================] - 0s - loss: 0.4831 - acc: 0.7665 - val_loss: 0.5589 - val_acc: 0.7126
 Epoch 149/150
 514/514 [==============================] - 0s - loss: 0.4961 - acc: 0.7782 - val_loss: 0.5663 - val_acc: 0.7126
 Epoch 150/150
 514/514 [==============================] - 0s - loss: 0.4967 - acc: 0.7588 - val_loss: 0.5810 - val_acc: 0.6929

Il gold standard per la valutazione del modello di apprendimento automatico è la convalida incrociata k-fold .

Fornisce una stima affidabile delle prestazioni di un modello su dati invisibili. Lo fa suddividendo il set di dati di addestramento in k sottoinsiemi, alternando i modelli di addestramento su tutti i sottoinsiemi tranne uno, che è trattenuto, e valutando le prestazioni del modello sul set di dati di convalida trattenuto. Il processo viene ripetuto fino a quando a tutti i sottoinsiemi viene data l'opportunità di essere il set di convalida sospeso. La misura delle prestazioni viene quindi calcolata in media su tutti i modelli creati.

È importante capire che la convalida incrociata significa stimare un modello di progettazione (ad esempio, rete neurale a 3 strati rispetto a 4 strati) piuttosto che uno specifico modello adattato. Non si desidera utilizzare un set di dati specifico per adattare i modelli e confrontare il risultato poiché ciò potrebbe essere dovuto a quel particolare set di dati che si adatta meglio a un progetto di modello. Invece, si desidera utilizzare più set di dati per adattarsi, ottenendo più modelli adattati dello stesso design, prendendo la misura delle prestazioni medie per il confronto.

La convalida incrociata spesso non viene utilizzata per valutare i modelli di deep learning a causa della maggiore spesa computazionale. Ad esempio, la convalida incrociata k-fold viene spesso utilizzata con 5 o 10 volte. Pertanto, è necessario costruire e valutare 5 o 10 modelli, aumentando significativamente il tempo di valutazione di un modello.

Tuttavia, quando il problema è sufficientemente piccolo o se si dispone di risorse di calcolo sufficienti, la convalida incrociata k-fold può fornire una stima meno distorta delle prestazioni del modello.

Nell'esempio seguente, utilizzerai la pratica classe StratifiedKFold della libreria di apprendimento automatico Python scikit-learn per dividere il set di dati di addestramento in 10 pieghe. Le pieghe sono stratificate, il che significa che l'algoritmo tenta di bilanciare il numero di istanze di ciascuna classe in ciascuna piega.

L'esempio crea e valuta 10 modelli utilizzando le 10 suddivisioni dei dati e raccoglie tutti i punteggi. L'output dettagliato per ogni epoca viene disattivato passando verbose=0alle funzioni fit() e evaluate() sul modello.

La performance viene stampata per ciascun modello e memorizzata. La media e la deviazione standard delle prestazioni del modello vengono quindi stampate alla fine della corsa per fornire una stima attendibile dell'accuratezza del modello.

# Convalidiamo con un 10-fold cross validation
 from tensorflow.keras.models import Sequential
 from tensorflow.keras.layers import Dense
 from sklearn.model_selection import StratifiedKFold
 import numpy as np
 # fissiamo il seed
 seed = 7
 np.random.seed(seed)
 # carichiamo il dataset
 dataset = np.loadtxt("pima-indians-diabetes.csv", delimiter=",")
 # input (X) e output (Y)
 X = dataset[:,0:8]
 Y = dataset[:,8]
 # definiamo il 10-fold cross validation
 kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
 cvscores = []
 for train, test in kfold.split(X, Y):
  #creiamo il modello
  model = Sequential()
  model.add(Dense(12, input_dim=8, activation='relu'))
  model.add(Dense(8, activation='relu'))
  model.add(Dense(1, activation='sigmoid'))
  # Compiliamolo
  model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
  # Alleniamolo
  model.fit(X[train], Y[train], epochs=150, batch_size=10, verbose=0)
  # valutiamolo
  scores = model.evaluate(X[test], Y[test], verbose=0)
  print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
  cvscores.append(scores[1] * 100)
 
 print("%.2f%% (+/- %.2f%%)" % (np.mean(cvscores), np.std(cvscores)))

Nota : i risultati possono variare a causa della natura stocastica dell'algoritmo o della procedura di valutazione, o delle differenze nella precisione numerica. Considera di eseguire l'esempio alcune volte e confrontare il risultato medio.

L'esecuzione dell'esempio richiederà meno di un minuto e produrrà il seguente output:

acc: 77.92%
 acc: 68.83%
 acc: 72.73%
 acc: 64.94%
 acc: 77.92%
 acc: 35.06%
 acc: 74.03%
 acc: 68.83%
 acc: 34.21%
 acc: 72.37%
 64.68% (+/- 15.50%)

In questo post, hai scoperto l'importanza di disporre di un modo affidabile per stimare le prestazioni dei tuoi modelli di deep learning su dati invisibili.

Hai scoperto tre modi per stimare le prestazioni dei tuoi modelli di deep learning in Python utilizzando la libreria Keras: