top of page

Il tuo primo Programma di Deep Learning in Python con Keras Step-By-Step


In questo articolo andremo a vedere passo passo come creare il tuo primo programma o progetto di deep learning, utilizzando Python e la libreria Keras.



Il tuo primo Programma di Deep Learning in Python con Keras Step-By-Step
Il tuo primo Programma di Deep Learning in Python con Keras Step-By-Step


Panoramica della guida per la creazione di un programma di apprendimento profondo

Non è richiesto molto codice, lo vedremo lentamente in modo che tu sappia come creare i tuoi modelli in futuro. Consigliamo sempre di salvare il post e rileggerlo più volte.


I passaggi che vedremo in questo tutorial sono i seguenti:

  1. Caricare dati.

  2. Definire il modello Keras.

  3. Compilare il modello Keras.

  4. Allenare il modello Keras.

  5. Valutare il modello Keras.

  6. Legare tutto insieme.

  7. Fare previsioni

Questo tutorial Keras ha alcuni requisiti:


Sei pronto ? Iniziamo !


Crea un nuovo file chiamato prima_rete_neurale_con_IAITALIA.py e digita o copia e incolla il codice nel file mentre procedi.




1. Carica dati

Il primo passo è definire le funzioni e le classi che intendiamo utilizzare in questo tutorial.

Useremo la libreria NumPy per caricare il nostro set di dati e useremo due classi della libreria Keras per definire il nostro modello.

Le importazioni richieste sono elencate di seguito.



# Prima rete neurale con Python e keras
from numpy import loadtxt
from keras.models import Sequential
from keras.layers import Dense

Ora possiamo caricare il nostro set di dati.

In questo tutorial su Keras, utilizzeremo il set di dati sull'inizio del diabete degli indiani Pima. Questo è un set di dati di machine learning standard dal repository UCI Machine Learning. Descrive i dati delle cartelle cliniche dei pazienti per gli indiani Pima e se hanno avuto un'insorgenza di diabete entro cinque anni.


In quanto tale, è un problema di classificazione binaria (inizio del diabete come 1 o non come 0). Tutte le variabili di input che descrivono ciascun paziente sono numeriche. Ciò lo rende facile da usare direttamente con le reti neurali che prevedono valori di input e output numerici e ideali per la nostra prima rete neurale in Keras.


Il dataset è disponibile nella sezione progetti, insieme al codice dell'articolo. ma se vuoi scaricarlo singolarmente ecco a te il link


Scarica il set di dati e inseriscilo nella tua directory di lavoro locale, nella stessa posizione del tuo file python.


Salvalo con il nome del file:


pima-indians-diabetes.csv



Dai un'occhiata all'interno del file, dovresti vedere righe di dati come le seguenti:



6,148,72,35,0,33.6,0.627,50,1
1,85,66,29,0,26.6,0.351,31,0
8,183,64,0,0,23.3,0.672,32,1
1,89,66,23,94,28.1,0.167,21,0
0,137,40,35,168,43.1,2.288,33,1

Ora possiamo caricare il file come matrice di numeri usando la funzione NumPy loadtxt() .

Sono disponibili otto variabili di input e una variabile di output (l'ultima colonna).


Impareremo un modello per mappare righe di variabili di input (X) su una variabile di output (y), che spesso riassumiamo come y = f(X) .


Le variabili possono essere così riassunte:

Variabili di ingresso (X):

  1. Numero di volte incinta

  2. Concentrazione di glucosio plasmatico a 2 ore in un test di tolleranza al glucosio orale

  3. Pressione diastolica (mm Hg)

  4. Spessore della piega cutanea del tricipite (mm)

  5. Insulina sierica di 2 ore (mu U/ml)

  6. Indice di massa corporea (peso in kg/(altezza in m)^2)

  7. Funzione genealogica del diabete

  8. Età (anni)

Variabili di uscita (y):

  1. Classe variabile (0 o 1)

Una volta che il file CSV è stato caricato in memoria, possiamo dividere le colonne di dati in variabili di input e output.


I dati verranno archiviati in un array 2D in cui la prima dimensione è righe e la seconda dimensione è colonne, ad esempio [righe, colonne].

Possiamo dividere l'array in due array selezionando sottoinsiemi di colonne usando l' operatore di NumPy ":" Possiamo selezionare le prime 8 colonne dall'indice 0 all'indice 7 tramite l'espressione 0:8. Possiamo quindi selezionare la colonna di output (la 9a variabile) tramite l'indice 8. ( Perchè ricordiamo che gli indici partono da zero non da 1 )



# Carichiamo il Dataset
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=',')
# dividiamo le variabili in input (X) e output (y) 
X = dataset[:,0:8]
y = dataset[:,8]



Siamo ora pronti per definire il nostro modello di rete neurale.

Nota , il set di dati ha 9 colonne e l'intervallo 0:8 selezionerà le colonne da 0 a 7, fermandosi prima dell'indice 8.


2. Definire il modello Keras

I modelli in Keras sono definiti come una sequenza di livelli.


Creiamo un modello sequenziale e aggiungiamo livelli uno alla volta finché non siamo soddisfatti della nostra architettura di rete.


La prima cosa da fare è assicurarsi che il livello di input abbia il giusto numero di funzioni di input. Questo può essere specificato quando si crea il primo livello con l' argomento input_dim e lo si imposta su 8 per le 8 variabili di input.


Come facciamo a sapere il numero di strati e i loro tipi?


Questa è una domanda molto difficile.


In questo esempio, utilizzeremo una struttura di rete completamente connessa con tre livelli.

I livelli completamente connessi vengono definiti utilizzando la classe Dense . Possiamo specificare il numero di neuroni o nodi nel livello come primo argomento e specificare la funzione di attivazione utilizzando l' argomento di attivazione .


Useremo la funzione di attivazione dell'unità lineare rettificata denominata ReLU sui primi due strati e la funzione Sigmoid nello strato di output.


In passato le funzioni di attivazione Sigmoid e Tanh erano preferite per tutti i livelli. Al giorno d'oggi, si ottengono prestazioni migliori utilizzando la funzione di attivazione ReLU. Usiamo un sigmoid sul livello di output per garantire che il nostro output di rete sia compreso tra 0 e 1 e sia facile da mappare su una probabilità di classe 1 o agganciare a una classificazione rigida di una delle classi con una soglia predefinita di 0,5.

Possiamo mettere insieme il tutto aggiungendo ogni strato:

  • Il modello prevede righe di dati con 8 variabili (l' argomento input_dim=8 )

  • Il primo livello nascosto ha 12 nodi e utilizza la funzione di attivazione di relu.

  • Il secondo livello nascosto ha 8 nodi e utilizza la funzione di attivazione relu.

  • Il livello di output ha un nodo e utilizza la funzione di attivazione sigmoidea.



# Definiamo il modello di keras
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))



Nota , la cosa più confusa qui è che la forma dell'input nel modello è definita come un argomento sul primo livello nascosto. Ciò significa che la riga di codice che aggiunge il primo livello Denso sta facendo 2 cose, definendo il livello di input o visibile e il primo livello nascosto.


3. Compila il modello Keras

Ora che il modello è definito, possiamo compilarlo .


La compilazione del modello utilizza le efficienti librerie numeriche sotto le coperte (i cosiddetti backend) come Theano o TensorFlow. Il backend sceglie automaticamente il modo migliore per rappresentare la rete per l'addestramento e fare previsioni da eseguire sul tuo hardware, come CPU o GPU .


Durante la compilazione, è necessario specificare alcune proprietà aggiuntive richieste durante l'addestramento della rete. Ricorda che addestrare una rete significa trovare il miglior set di pesi per mappare gli input sugli output nel nostro set di dati.


Dobbiamo specificare la funzione di perdita da utilizzare per valutare un insieme di pesi, l'ottimizzatore viene utilizzato per cercare diversi pesi per la rete ed eventuali metriche facoltative che vorremmo raccogliere e segnalare durante l'allenamento.


In questo caso, useremo l'entropia incrociata come argomento di perdita . Questa perdita è per problemi di classificazione binaria ed è definita in Keras come " binary_crossentropy ".


Definiremo l' ottimizzatore come l'efficiente algoritmo di discesa del gradiente stocastico “ adam ”. Questa è una versione popolare della discesa in pendenza perché si sintonizza automaticamente e dà buoni risultati in un'ampia gamma di problemi.


Infine, poiché si tratta di un problema di classificazione, raccoglieremo e riporteremo l'accuratezza della classificazione, definita tramite l' argomento delle metriche .



# compiliamo il modello
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])


4. Alleniamo il modello di deep learning

Abbiamo definito il nostro modello e lo abbiamo compilato pronto per un calcolo efficiente.

Ora è il momento di eseguire il modello su alcuni dati.

Possiamo addestrare o adattare il nostro modello ai nostri dati caricati chiamando la funzione fit() sul modello.


L'addestramento avviene in epoche e ogni epoca è suddivisa in lotti.

  • Epoch : un passaggio attraverso tutte le righe nel set di dati di addestramento.

  • batch_size : uno o più campioni considerati dal modello entro un'epoch prima dell'aggiornamento dei pesi.

Un'epoch è composta da uno o più lotti in , in base alla batch_size del lotto scelta e il modello è adatto per molte epoch.


Il processo di addestramento verrà eseguito per un numero fisso di iterazioni attraverso il set di dati chiamato epochs, che dobbiamo specificare utilizzando l' argomento epochs . Dobbiamo anche impostare il numero di righe del set di dati che vengono considerate prima che i pesi del modello vengano aggiornati all'interno di ogni epoca, chiamata dimensione batch e impostata utilizzando l' argomento batch_size .


Per questo problema, eseguiremo un numero limitato di epochh (150) e utilizzeremo una dimensione batch relativamente piccola di 10.


Queste configurazioni possono essere scelte sperimentalmente per tentativi ed errori. Vogliamo addestrare il modello a sufficienza in modo che apprenda una buona (o abbastanza buona) mappatura di righe di dati di input alla classificazione di output. Il modello avrà sempre qualche errore, ma la quantità di errore si livellerà dopo un certo punto per una determinata configurazione del modello. Questo si chiama convergenza del modello.



# Alleniamo la nostra rete
model.fit(X, y, epochs=150, batch_size=10)


È qui che avviene il lavoro sulla tua CPU o GPU



5. Valuta il modello Keras

Abbiamo addestrato la nostra rete neurale sull'intero set di dati e possiamo valutare le prestazioni della rete sullo stesso set di dati.


Questo ci darà solo un'idea di quanto bene abbiamo modellato il set di dati (es. precisione del treno), ma non abbiamo idea di quanto bene l'algoritmo potrebbe funzionare su nuovi dati. Lo abbiamo fatto per semplicità, ma idealmente potresti separare i tuoi dati in set di dati di training e test per il training e la valutazione del tuo modello.


Puoi valutare il tuo modello sul tuo set di dati di addestramento usando la funzione Evaluation() sul tuo modello e passargli lo stesso input e output usati per addestrare il modello.


Questo genererà una previsione per ogni coppia di input e output e raccoglierà i punteggi, inclusa la perdita media e tutte le metriche che hai configurato, come l'accuratezza.

La funzione di evaluate() restituirà un elenco con due valori. Il primo sarà la perdita del modello sul set di dati e il secondo sarà l'accuratezza del modello sul set di dati. Siamo interessati solo a riportare l'accuratezza, quindi ignoreremo il valore della perdita.


# Valutiamo le prestazioni della nostra rete
_, accuracy = model.evaluate(X, y)
print('Accuratezza: %.2f' % (accuracy*100))


6. Mettiamo tutto insieme

Hai appena visto come creare facilmente il tuo primo modello di rete neurale in Keras.

Leghiamo tutto insieme in un esempio di codice completo.



# la mia prima rete neurale
from numpy import loadtxt
from keras.models import Sequential
from keras.layers import Dense

# lCarichiamo il Dataset
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=',')
# Dividiamo le variabili in input e output
X = dataset[:,0:8]
y = dataset[:,8]
# definiamo 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'))
# Compiliamo il modello
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Alleniamo il modello sul dataset
model.fit(X, y, epochs=150, batch_size=10)
#Vediamo come se la cava
_, accuracy = model.evaluate(X, y)
print('Accuratezza: %.2f' % (accuracy*100))

Puoi copiare tutto il codice nel tuo file Python e salvarlo come " prima_rete_neurale_con_IAITALIA.py " nella stessa directory del tuo file di dati " pima-indians-diabetes.csv ". È quindi possibile eseguire il file Python come script dalla riga di comando (prompt dei comandi) come segue:

python3 prima_rete_neurale_con_IAITALIA.py


Eseguendo questo esempio, dovresti vedere un messaggio per ciascuna delle 150 epoche che stampa la perdita e l'accuratezza, seguito dalla valutazione finale del modello addestrato sul set di dati di addestramento.


Ci vogliono circa 10 secondi per l'esecuzione sulla mia workstation in esecuzione sulla CPU.

Idealmente, vorremmo che la perdita andasse a zero e la precisione andasse a 1,0 (ad es. 100%). Questo non è possibile per nessuno ma per i più banali problemi di apprendimento automatico. Invece, avremo sempre qualche errore nel nostro modello. L'obiettivo è scegliere una configurazione del modello e una configurazione di addestramento che ottengano la perdita più bassa e la massima precisione possibile per un determinato set di dati.



768/768 [==============================] - 0s 63us/step - loss: 0.4817 - acc: 0.7708
Epoch 147/150
768/768 [==============================] - 0s 63us/step - loss: 0.4764 - acc: 0.7747
Epoch 148/150
768/768 [==============================] - 0s 63us/step - loss: 0.4737 - acc: 0.7682
Epoch 149/150
768/768 [==============================] - 0s 64us/step - loss: 0.4730 - acc: 0.7747
Epoch 150/150
768/768 [==============================] - 0s 63us/step - loss: 0.4754 - acc: 0.7799
768/768 [==============================] - 0s 38us/step
Accuracy: 76.56



Nota, se provi a eseguire questo esempio in un notebook IPython o Jupyter potresti ricevere un errore.


Il motivo sono le barre di avanzamento dell'output durante l'allenamento. Puoi facilmente disattivarli impostando verbose=0 nella chiamata alle funzioni fit() e Evaluation() , ad esempio:



# Allenare il modello senza quelle barre di avanzamento fighissime
model.fit(X, y, epochs=150, batch_size=10, verbose=0)
# evaluate the keras model
_, accuracy = model.evaluate(X, y, verbose=0)


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.


Che punteggio hai ottenuto? Pubblica i tuoi risultati nei commenti qui sotto.

Le reti neurali sono un algoritmo stocastico, il che significa che lo stesso algoritmo sugli stessi dati può addestrare un modello diverso con abilità diverse ogni volta che viene eseguito il codice.


La varianza nelle prestazioni del modello significa che per ottenere un'approssimazione ragionevole delle prestazioni del modello, potrebbe essere necessario adattarlo più volte e calcolare la media dei punteggi di precisione.


Ad esempio, di seguito sono riportati i punteggi di precisione della ripetizione dell'esempio 5 volte:

Accuracy: 75.00 Accuracy: 77.73 Accuracy: 77.60 Accuracy: 78.12 Accuracy: 76.17


Possiamo vedere che tutti i punteggi di precisione sono intorno al 77% e la media è del 76,924%.



7. Come Fare previsioni dopo aver allenato il modello

La domanda numero uno che ci viene fatta è:

Dopo aver addestrato il mio modello, come posso usarlo per fare previsioni su nuovi dati?

Ottima domanda.


Possiamo adattare l'esempio sopra e usarlo per generare previsioni sul set di dati di addestramento, fingendo che sia un nuovo set di dati che non abbiamo mai visto prima.

Fare previsioni è facile come chiamare la funzione predict() sul modello. Stiamo utilizzando una funzione di attivazione sigmoide sul livello di output, quindi le previsioni saranno una probabilità compresa tra 0 e 1. Possiamo facilmente convertirle in una previsione binaria nitida per questa attività di classificazione arrotondandole.

Per esempio:



# Facciamo previsioni usando il set di dati X
predictions = model.predict(X)
# round predictions 
rounded = [round(x[0]) for x in predictions]

In alternativa, possiamo convertire la probabilità in 0 o 1 per prevedere direttamente classi nitide, ad esempio:



# Creiamo una classe di previsione, che non fa altro di arrotondare a 1 (quindi paziente malato) se la previsione è maggiore allo 0.5 che corrisponde al 50%
predictions = (model.predict(X) > 0.5).astype(int)


L'esempio completo seguente effettua previsioni per ogni esempio nel set di dati, quindi stampa i dati di input, la classe prevista e la classe prevista per i primi 5 esempi nel set di dati.



# la mia prima rete neurale
from numpy import loadtxt
from keras.models import Sequential
from keras.layers import Dense

# lCarichiamo il Dataset
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=',')
# Dividiamo le variabili in input e output
X = dataset[:,0:8]
y = dataset[:,8]
# definiamo 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'))
# Compiliamo il modello
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Alleniamo il modello sul dataset
model.fit(X, y, epochs=150, batch_size=10)
#Vediamo come se la cava
_, accuracy = model.evaluate(X, y)
print('Accuratezza: %.2f' % (accuracy*100))
# Facciamo un previsione sul set di dati di X
predictions = (model.predict(X) > 0.5).astype(int)
# Stampiamo le prime 5
for i in range(5):
	print('%s => %d (expected %d)' % (X[i].tolist(), predictions[i], y[i]))


L'esecuzione dell'esempio non mostra la barra di avanzamento come prima poiché abbiamo impostato l'argomento dettagliato su 0.

Dopo che il modello è stato adattato, vengono effettuate previsioni per tutti gli esempi nel set di dati e le righe di input e il valore della classe previsto per i primi 5 esempi vengono stampati e confrontati con il valore della classe previsto.

Possiamo vedere che la maggior parte delle righe sono previste correttamente. In effetti, ci aspetteremmo che circa il 76,9% delle righe fosse previsto correttamente in base alle prestazioni stimate del modello nella sezione precedente.

[6.0, 148.0, 72.0, 35.0, 0.0, 33.6, 0.627, 50.0] => 0 (expected 1) [1.0, 85.0, 66.0, 29.0, 0.0, 26.6, 0.351, 31.0] => 0 (expected 0) [8.0, 183.0, 64.0, 0.0, 0.0, 23.3, 0.672, 32.0] => 1 (expected 1) [1.0, 89.0, 66.0, 23.0, 94.0, 28.1, 0.167, 21.0] => 0 (expected 0) [0.0, 137.0, 40.0, 35.0, 168.0, 43.1, 2.288, 33.0] => 1 (expected 1)



Riepilogo tutorial Keras

In questo post, hai scoperto come creare il tuo primo modello di rete neurale utilizzando la potente libreria Keras Python per il deep learning.

In particolare, hai appreso i sei passaggi chiave nell'utilizzo di Keras per creare una rete neurale o un modello di deep learning, passo dopo passo tra cui:

  1. Come caricare i dati.

  2. Come definire una rete neurale in Keras.

  3. Come compilare un modello Keras utilizzando l'efficiente backend numerico.

  4. Come addestrare un modello sui dati.

  5. Come valutare un modello sui dati.

  6. Come fare previsioni con il modello.

Hai domande su Keras o su questo tutorial? Fai la tua domanda nei commenti e faremo del nostro meglio per rispondere.


Estensioni del tutorial di Keras

Ben fatto, hai sviluppato con successo la tua prima rete neurale utilizzando la libreria di deep learning Keras in Python.

Questa sezione fornisce alcune estensioni a questo tutorial che potresti voler esplorare.

  • Accorda il modello. Modificare la configurazione del modello o il processo di addestramento e vedere se è possibile migliorare le prestazioni del modello, ad esempio ottenere una precisione superiore al 76%.

  • Salva il modello . Aggiorna il tutorial per salvare il modello su file, quindi caricalo in un secondo momento e utilizzalo per fare previsioni

  • Set di dati di treno e test separati . Suddividi il set di dati caricato in un treno e un set di test (diviso in base alle righe) e usa un set per addestrare il modello e l'altro per stimare le prestazioni del modello sui nuovi dati.

  • Curve di apprendimento della trama . La funzione fit() restituisce un oggetto cronologia che riassume la perdita e l'accuratezza alla fine di ogni epoca. Crea grafici lineari di questi dati, chiamati curve di apprendimento.

  • Scopri un nuovo set di dati . Aggiorna il tutorial per utilizzare un set di dati tabulare diverso, magari dall'UCI Machine Learning Repository .


Grazie per la lettura, qui sotto potrai lasciare commenti o leggere post correlati.