L'intelligenza artificiale (AI) ha guadagnato una notevole popolarità negli ultimi anni.
Se sei un ingegnere del software, uno scienziato informatico o un appassionato di scienza dei dati in generale, probabilmente sei incuriosito dalle straordinarie applicazioni di elaborazione delle immagini, riconoscimento di modelli e rilevamento di oggetti fornite da questo campo.
Il sottocampo più importante dell'IA di cui probabilmente hai sentito parlare è il Deep Learning. Questo campo si concentra su potenti algoritmi (istruzioni di programmi per computer) modellati sulla funzionalità del cervello umano nota come Reti neurali.
In questo articolo, esamineremo il concetto di reti neurali e come costruire, compilare, adattare e valutare questi modelli utilizzando Python.
Reti neurali
Le reti neurali, o NN, sono una serie di algoritmi modellati sull'attività biologica del cervello umano. Le reti neurali sono costituite da nodi, chiamati anche neuroni.
Un insieme di nodi verticali è noto come livelli. Il modello è costituito da un input, un output e un numero di livelli nascosti. Ogni strato è costituito da nodi, detti anche neuroni, dove avvengono i calcoli.
Nel diagramma seguente, i cerchi rappresentano i nodi e la raccolta verticale di nodi rappresenta i livelli. Ci sono tre strati in questo modello.
I nodi di uno strato sono collegati allo strato successivo tramite linee di trasmissione come mostrato di seguito.
Il nostro set di dati è costituito da dati etichettati. Ciò significa che a ciascuna entità di dati è stato assegnato un determinato valore del nome.
Quindi per un set di dati di classificazione degli animali avremo immagini di cani e gatti come dati, con "gatto" e "cane" come etichette.
È importante notare che le etichette devono essere convertite in valori numerici affinché il nostro modello possa dare loro un senso, quindi le nostre etichette degli animali diventano "0" per il gatto e "1" per il cane. Sia i dati che le etichette vengono passati attraverso il modello.
Formazione
I dati vengono inviati al modello un'entità alla volta. Questi dati vengono suddivisi in blocchi e passati attraverso ogni nodo del modello. I nodi eseguono operazioni matematiche su questi blocchi.
Non è necessario conoscere le funzioni matematiche oi calcoli per questo tutorial, ma è importante avere un'idea generale di come funzionano questi modelli. Dopo una serie di calcoli in un livello, i dati vengono passati al livello successivo e così via.
Una volta completato, il nostro modello prevede l'etichetta dei dati sul livello di output (ad esempio, in un problema di classificazione degli animali otteniamo una previsione "0" per un gatto).
Il modello procede quindi a confrontare questo valore previsto con quello del valore effettivo dell'etichetta.
Se i valori corrispondono, il nostro modello prenderà l'input successivo, ma se i valori differiscono, il modello calcolerà la differenza tra entrambi i valori, chiamata perdita, e regolerà i calcoli dei nodi per produrre etichette corrispondenti la prossima volta.
Framework di apprendimento profondo
Per creare reti neurali nel codice, è necessario importare Quadri di apprendimento profondo note come librerie che utilizzano il nostro ambiente di sviluppo integrato (IDE).
Questi framework sono una raccolta di funzioni pre-scritte che ci aiuteranno in questo tutorial. Useremo il framework Keras per costruire il nostro modello.
Keras è una libreria Python che utilizza un backend di deep learning e intelligenza artificiale chiamato tensorflow per creare facilmente NN sotto forma di semplici modelli sequenziali.
Keras viene fornito anche con i propri modelli preesistenti che potrebbero essere utilizzati. Per questo tutorial, creeremo il nostro modello usando Keras.
Puoi saperne di più su questo framework di Deep Learning da Sito web di Keras.
Costruire una rete neurale (esercitazione)
Passiamo alla costruzione di una rete neurale usando Python.
Dichiarazione problema
Le reti neurali sono un tipo di soluzione ai problemi basati sull'intelligenza artificiale. Per questo tutorial esamineremo i dati sul diabete degli indiani Pima, che sono disponibili qui.
UCI Machine Learning ha compilato questo set di dati e contiene una cartella clinica di pazienti indiani. Il nostro modello deve prevedere se il paziente ha un inizio di diabete entro 5 anni o meno.
Caricamento set di dati
Il nostro set di dati è un unico file CSV chiamato "diabetes.csv" che può essere facilmente manipolato utilizzando Microsoft Excel.
Prima di creare il nostro modello, dobbiamo importare il nostro set di dati. Usando il seguente codice puoi farlo:
importare i panda come pd
data = pd.read_csv('diabetes.csv')
x = data.drop ("Risultato")
y = dati[“Risultato”]
Qui stiamo usando il Pandas libreria per poter manipolare i dati del nostro file CSV, read_csv() è una funzione integrata di Pandas che ci consente di memorizzare i valori nel nostro file in una variabile chiamata 'data'.
La variabile x contiene il nostro set di dati senza i dati sui risultati (etichette). Otteniamo questo con la funzione data.drop() che rimuove le etichette per x, mentre y contiene solo i dati del risultato (etichetta).
Modello sequenziale di costruzione
Passaggio 1: importazione di librerie
Innanzitutto, dobbiamo importare TensorFlow e Keras, insieme ad alcuni parametri richiesti per il nostro modello. Il codice seguente ci consente di farlo:
importa tensorflow come tf
da tensorflow import keras
da tensorflow.keras.models import Sequential
da tensorflow.keras.layers import Activation, Dense
da tensorflow.keras.optimizers importa Adam
da tensorflow.keras.metrics import categorical_crossentropy
Per il nostro modello stiamo importando strati densi. Questi sono livelli completamente collegati; cioè, ogni nodo in un livello è completamente connesso con un altro nodo nel livello successivo.
Stiamo anche importando un attivazione funzione necessaria per ridimensionare i dati inviati ai nodi. ottimizzatori sono stati anche importati per ridurre al minimo le perdite.
Adam è un ottimizzatore di fama che rende più efficienti i calcoli dei nostri nodi di aggiornamento del modello, insieme a categorical_crossentropy che è il tipo di funzione di perdita (calcola la differenza tra i valori dell'etichetta effettivi e previsti) che utilizzeremo.
Passaggio 2: progettare il nostro modello
Il modello che sto creando ha un livello di input (con 16 unità), uno nascosto (con 32 unità) e un livello di output (con 2 unità). Questi numeri non sono fissi e dipenderanno interamente dal problema indicato.
L'impostazione del giusto numero di unità e livelli è un processo che può essere migliorato nel tempo attraverso la pratica. L'attivazione corrisponde al tipo di ridimensionamento che eseguiremo sui nostri dati prima di passarli attraverso un nodo.
Relu e Softmax sono rinomate funzioni di attivazione per questo compito.
modello = Sequenziale([
Denso(unità = 16, forma_input = (1,), attivazione = 'relu'),
Denso(unità = 32, attivazione = 'relu'),
Denso(unità = 2, attivazione = 'softmax')
])
Ecco come dovrebbe essere il riepilogo del modello:
Formazione del modello
Il nostro modello verrà addestrato in due passaggi, il primo è la compilazione del modello (mettendo insieme il modello) e il successivo è l'adattamento del modello su un determinato set di dati.
Questo può essere fatto usando la funzione model.compile() seguita dalla funzione model.fit().
model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'binary_crossentropy', metrics = ['accuratezza'])
model.fit(x, y, epoche = 30, batch_size = 10)
Specificare la metrica "accuratezza" ci consente di osservare l'accuratezza del nostro modello durante l'allenamento.
Poiché le nostre etichette sono sotto forma di 1 e 0, utilizzeremo una funzione di perdita binaria per calcolare la differenza tra etichette effettive e previste.
Il set di dati viene anche suddiviso in lotti di 10 (batch_size) e verrà passato attraverso il modello 30 volte (epoche). Per un dato set di dati, x sarebbero i dati e y sarebbero le etichette corrispondenti ai dati.
Modello di test utilizzando le previsioni
Per valutare il nostro modello, facciamo previsioni sui dati del test utilizzando la funzione predict().
previsioni = model.predict(x)
E questo è tutto!
Ora dovresti avere una buona comprensione del Deep Learning applicazione, reti neurali, come funzionano in generale e come costruire, addestrare e testare un modello in codice Python.
Spero che questo tutorial ti dia la spinta per creare e distribuire i tuoi modelli di Deep Learning.
Fateci sapere nei commenti se l'articolo è stato utile.
Lascia un Commento