Addestramento rete neurale
Detto così sembra chissà quale complicazione debba essere invece!
In futuro spero di riuscire a pensare a una rete neurale realmente utile che vi invogli ad approfondire l’argomento. Per esempio una rete neurale in grado di identificare dei pezzi difettosi prodotti da una macchina. Oppure se vostro figlio adolescente si è innamorato!
Rete neurale che dimezza l’input ricevuto
Un esempio banale, vogliamo una rete che sappia dimezzare gli input che gli sottoponiamo.
In questo caso è facile creare un set di addestramento, dovremmo usare molte più righe ma ci accontentiamo.
Dati di addestramento
4, 2,
5, 2.5,
18, 9,
7, 3.5,
10, 5,
2, 1,
12, 6,
Il codice python (che mi sono fatto scrivere da GPT) è in fondo, qui vediamo l’esecuzione
La formula è : z=x⋅w+b con w parametro di partenza scelto a caso + un bias.
Ad ogni ciclo (che vengono chiamati epoche) ci si avvicina all’output desiderato.
Loss (perdita) è la differenza fra l’ouput ottenuto e quello atteso.
Il log mostra l’avanzamento ma non i valori di w e b utilizzati.
In fondo viene spiegato perché ogni tanto invece di avvicinarsi si allontana.
Esecuzione:
Epoch 1, Loss: 6.227310998181788
Epoch 2, Loss: 4.2116145943639296e-05
Epoch 3, Loss: 7.195056907187796e-05
Epoch 4, Loss: 6.765318020060395e-05
Epoch 5, Loss: 6.385329050508612e-05
Epoch 6, Loss: 6.026611729702987e-05
Epoch 7, Loss: 5.688046770575314e-05
Epoch 8, Loss: 5.36850182351593e-05
Epoch 9, Loss: 5.0669083767353316e-05
Epoch 10, Loss: 4.7822579449979105e-05
Epoch 11, Loss: 4.5135986980733416e-05
Epoch 12, Loss: 4.260032277964672e-05
Epoch 13, Loss: 4.0207107949257094e-05
Epoch 14, Loss: 3.79483399223227e-05
Epoch 15, Loss: 3.5816465702468136e-05
Epoch 16, Loss: 3.3804356608038865e-05
Epoch 17, Loss: 3.1905284434662266e-05
Epoch 18, Loss: 3.0112898957404222e-05
Epoch 19, Loss: 2.842120669620724e-05
Epoch 20, Loss: 2.6824550874744654e-05
Epoch 21, Loss: 2.531759250485431e-05
Epoch 22, Loss: 2.389529253388356e-05
Epoch 23, Loss: 2.255289499468077e-05
…
Epoch 80, Loss: 8.354668661494883e-07
Epoch 81, Loss: 7.885317359941818e-07
Epoch 82, Loss: 7.442333428894388e-07
Epoch 83, Loss: 7.024235593629253e-07
Epoch 84, Loss: 6.629625794983267e-07
Epoch 85, Loss: 6.257184514343455e-07
Epoch 86, Loss: 5.905666361434807e-07
Epoch 94, Loss: 3.7186771701331693e-07
Epoch 95, Loss: 3.5097681109486934e-07
Epoch 96, Loss: 3.312595213051599e-07
Epoch 97, Loss: 3.1264991585277926e-07
Epoch 98, Loss: 2.9508576688341076e-07
Epoch 99, Loss: 2.7850834240928134e-07
Epoch 100, Loss: 2.628622098922849e-07
Final weights: [0.49998114], Final bias: 0.0002775894448815529
Predicted output for 1200: 599.9776494067913
Con un set di addestramento più accurato avremmo ottenuto:
Final weights: [0.5], Final bias: 0.0
Predicted output for 1200: 600
La perdita (Loss) che ondeggia può essere un segnale che il tasso di apprendimento è troppo alto (learning_rate = 0.01) . Un tasso di apprendimento troppo alto può causare oscillazioni nella funzione di perdita poiché gli aggiornamenti dei pesi e del bias sono troppo grandi e possono superare il punto ottimale, causando un effetto di “bouncing”.
Si può usare un learning rate più basso ma in questo caso è necessario aumentare le epoche.
Spiegazione del Codice
- Inizializzazione: Partiamo con un peso iniziale di 0.3 e un bias di 0.0 per mostrare il miglioramento ad ogni epoca.
- Dati di Addestramento: Utilizziamo una serie di coppie di dati per l’addestramento della rete neurale.
- Funzione di Attivazione Lineare: Utilizziamo una funzione di attivazione lineare semplice.
- Forward Propagation: Calcoliamo l’output della rete neurale per ogni dato di addestramento.
- Calcolo della Perdita: Utilizziamo l’errore quadratico medio (MSE) come funzione di perdita.
- Backpropagation: Calcoliamo i gradienti della perdita rispetto ai pesi e al bias e li aggiorniamo utilizzando il tasso di apprendimento.
- Predizione: Usiamo i pesi e il bias finali per predire un nuovo dato (1200).
Ho riportato lo script python solo per mostrare che bastano poche righe di codice che comunque io mi faccio scrivere da GPT.
dimezzaInput.py
import numpy as np
-
Dati di addestramento
training_data = [
(np.array([4]), 2),
(np.array([5]), 2.5),
(np.array([18]), 9),
(np.array([7]), 3.5),
(np.array([10]), 5),
(np.array([2]), 1),
(np.array([12]), 6),
] -
Inizializzazione dei pesi e del bias
w = np.array([0.3])
b = 0.0
learning_rate = 0.01 -
Funzione di attivazione lineare (identità)
def linear(x):
return x -
Derivata della funzione di attivazione lineare
def linear_derivative(x):
return 1 -
Addestramento
for epoch in range(100): # Numero di epoche
total_loss = 0
for x, y in training_data:
* Forward propagation
z = np.dot(w, x) + b
a = linear(z)* Calcolo della perdita loss = 0.5 * (a - y) ** 2 total_loss += loss * Backpropagation dz = (a - y) * linear_derivative(z) dw = dz * x db = dz * Aggiornamento dei pesi e del bias w -= learning_rate * dw b -= learning_rate * dbprint(f’Epoch {epoch+1}, Loss: {total_loss}')
print(f’Final weights: {w}, Final bias: {b}')
-
Funzione per fare predizioni
def predict(x, w, b):
z = np.dot(w, x) + b
a = linear(z)
return a -
Nuovo dato
new_data = np.array([1200])
prediction = predict(new_data, w, b)
print(f’Predicted output for {new_data[0]}: {prediction}')
