AI con Python - Reti neurali

Le reti neurali sono dispositivi di calcolo parallelo che tentano di creare un modello computerizzato del cervello. L'obiettivo principale è quello di sviluppare un sistema per eseguire vari compiti computazionali più velocemente dei sistemi tradizionali. Queste attività includono il riconoscimento e la classificazione dei modelli, l'approssimazione, l'ottimizzazione e il raggruppamento dei dati.

Che cosa sono le reti neurali artificiali (ANN)

La rete neurale artificiale (ANN) è un sistema di calcolo efficiente il cui tema centrale è preso in prestito dall'analogia delle reti neurali biologiche. Le ANN sono anche denominate Sistemi neurali artificiali, Sistemi di elaborazione distribuita parallela e Sistemi connessionisti. ANN acquisisce un'ampia raccolta di unità che sono interconnesse in un modello per consentire le comunicazioni tra di loro. Queste unità, denominate anchenodes o neurons, sono semplici processori che operano in parallelo.

Ogni neurone è connesso con un altro neurone tramite a connection link. Ogni link di connessione è associato a un peso contenente le informazioni sul segnale in ingresso. Questa è l'informazione più utile per i neuroni per risolvere un problema particolare perché il fileweightdi solito eccita o inibisce il segnale che viene comunicato. Ogni neurone sta avendo il suo stato interno che viene chiamatoactivation signal. I segnali di uscita, che vengono prodotti dopo aver combinato i segnali di ingresso e la regola di attivazione, possono essere inviati ad altre unità.

Se vuoi studiare in dettaglio le reti neurali, puoi seguire il link - Rete neurale artificiale .

Installazione di pacchetti utili

Per creare reti neurali in Python, possiamo utilizzare un potente pacchetto per reti neurali chiamato NeuroLab. È una libreria di algoritmi di reti neurali di base con configurazioni di rete flessibili e algoritmi di apprendimento per Python. È possibile installare questo pacchetto con l'aiuto del seguente comando sul prompt dei comandi:

pip install NeuroLab

Se stai usando l'ambiente Anaconda, usa il seguente comando per installare NeuroLab -

conda install -c labfabulous neurolab

Costruire reti neurali

In questa sezione, costruiamo alcune reti neurali in Python utilizzando il pacchetto NeuroLab.

Classificatore basato su Perceptron

I perceptrons sono gli elementi costitutivi di ANN. Se vuoi saperne di più su Perceptron, puoi seguire il link - artificial_neural_network

Di seguito è riportata un'esecuzione graduale del codice Python per la creazione di un semplice classificatore basato su perceptron di rete neurale:

Importa i pacchetti necessari come mostrato -

import matplotlib.pyplot as plt
import neurolab as nl

Immettere i valori di input. Nota che è un esempio di apprendimento supervisionato, quindi dovrai fornire anche i valori target.

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]

Crea la rete con 2 ingressi e 1 neurone -

net = nl.net.newp([[0, 1],[0, 1]], 1)

Ora allena la rete. Qui stiamo usando la regola delta per l'addestramento.

error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)

Ora visualizza l'output e traccia il grafico -

plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()

È possibile vedere il grafico seguente che mostra l'avanzamento dell'allenamento utilizzando la metrica di errore:

Reti neurali a strato singolo

In questo esempio, stiamo creando una rete neurale a livello singolo che consiste di neuroni indipendenti che agiscono sui dati di input per produrre l'output. Nota che stiamo usando il file di testo denominatoneural_simple.txt come nostro input.

Importa i pacchetti utili come mostrato -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Carica il set di dati come segue:

input_data = np.loadtxt(“/Users/admin/neural_simple.txt')

Di seguito sono riportati i dati che utilizzeremo. Nota che in questi dati, le prime due colonne sono le caratteristiche e le ultime due colonne sono le etichette.

array([[2. , 4. , 0. , 0. ],
      [1.5, 3.9, 0. , 0. ],
      [2.2, 4.1, 0. , 0. ],
      [1.9, 4.7, 0. , 0. ],
      [5.4, 2.2, 0. , 1. ],
      [4.3, 7.1, 0. , 1. ],
      [5.8, 4.9, 0. , 1. ],
      [6.5, 3.2, 0. , 1. ],
      [3. , 2. , 1. , 0. ],
      [2.5, 0.5, 1. , 0. ],
      [3.5, 2.1, 1. , 0. ],
      [2.9, 0.3, 1. , 0. ],
      [6.5, 8.3, 1. , 1. ],
      [3.2, 6.2, 1. , 1. ],
      [4.9, 7.8, 1. , 1. ],
      [2.1, 4.8, 1. , 1. ]])

Ora, separa queste quattro colonne in 2 colonne di dati e 2 etichette:

data = input_data[:, 0:2]
labels = input_data[:, 2:]

Tracciare i dati di input utilizzando i seguenti comandi:

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')

Ora, definisci i valori minimo e massimo per ciascuna dimensione come mostrato qui -

dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()

Successivamente, definisci il numero di neuroni nel livello di output come segue:

nn_output_layer = labels.shape[1]

Ora, definisci una rete neurale a strato singolo -

dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)

Addestra la rete neurale con il numero di epoche e la velocità di apprendimento come mostrato -

error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)

Ora, visualizza e traccia il progresso dell'allenamento utilizzando i seguenti comandi:

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()

Ora, usa i punti dati di prova nel classificatore sopra -

print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
   print(item, '-->', neural_net.sim([item])[0])

Puoi trovare i risultati del test come mostrato qui -

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

Puoi vedere i seguenti grafici come output del codice discusso fino ad ora -

Reti neurali multistrato

In questo esempio, stiamo creando una rete neurale multistrato composta da più di un livello per estrarre i modelli sottostanti nei dati di addestramento. Questa rete neurale multistrato funzionerà come un regressore. Genereremo alcuni punti dati in base all'equazione: y = 2x ² +8.

Importa i pacchetti necessari come mostrato -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Genera un punto dati basato sull'equazione sopra menzionata -

min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

Ora rimodella questo set di dati come segue:

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)

Visualizza e traccia il set di dati di input utilizzando i seguenti comandi:

plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')

Ora, crea la rete neurale con due livelli nascosti con neurolab con ten neuroni nel primo strato nascosto, six nel secondo strato nascosto e one nel livello di output.

neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])

Ora usa l'algoritmo di addestramento del gradiente -

neural_net.trainf = nl.train.train_gd

Ora addestra la rete con l'obiettivo di apprendere sui dati generati sopra -

error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)

Ora, esegui le reti neurali sui punti dati di addestramento -

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

Ora attività di trama e visualizzazione -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')

Ora tracceremo l'output effettivo rispetto a quello previsto -

x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()

Come risultato dei comandi precedenti, è possibile osservare i grafici come mostrato di seguito: