CodeUtility
Facilitiamo la vita agli sviluppatori!
Concetti di IA in Python

Discesa del gradiente e backpropagation in Python

Addestrare significa regolare i pesi per ridurre la perdita. Il gradiente indica la direzione in cui la perdita cresce, quindi la discesa del gradiente fa piccoli passi nella direzione opposta. La backpropagation usa la regola della catena per calcolare quel gradiente per ogni peso.

Il concetto in parole semplici

Addestrare significa regolare i pesi per ridurre la perdita. Il gradiente indica la direzione in cui la perdita cresce, quindi la discesa del gradiente fa piccoli passi nella direzione opposta. La backpropagation usa la regola della catena per calcolare quel gradiente per ogni peso.

Addestra un neurone con la discesa del gradiente: usa la regola della catena per capire come ogni peso influenza la perdita, poi scendi lungo la pendenza.

Idee chiave

  • Il gradiente è la pendenza della perdita rispetto a ogni peso.
  • Il learning rate stabilisce la lunghezza del passo: troppo grande supera il minimo, troppo piccolo è lento.
  • La backpropagation applica la regola della catena dall'output fino al primo strato.
  • Un'epoca è un passaggio completo su tutti i dati di addestramento.

Quando si usa?

  • Capire cosa succede dentro le reti neurali e le librerie di IA.
  • Imparare l'idea prima di implementarla nelle sfide corrispondenti.
  • Prepararti a corsi di machine learning, colloqui e progetti.

Guardalo in azione

Premi Avvia per addestrare. La retta si avvicina ai punti mentre il percorso arancione scende lungo il paesaggio della perdita fino al punto più basso.

Codice di esempio

Esegui codice →
main.py
# Train one neuron y = w * x + b to fit points on the line y = 2x + 1.
data = [(0, 1), (1, 3), (2, 5), (3, 7)]
w, b = 0.0, 0.0
learning_rate = 0.05

for epoch in range(1, 201):
    grad_w = grad_b = 0.0
    for x, y in data:
        error = (w * x + b) - y          # prediction minus target
        # Chain rule: d(error²)/dw = 2 * error * x, d(error²)/db = 2 * error
        grad_w += 2 * error * x
        grad_b += 2 * error
    # Step against the gradient to make the loss smaller.
    w -= learning_rate * grad_w / len(data)
    b -= learning_rate * grad_b / len(data)
    if epoch in (1, 10, 50, 200):
        loss = sum(((w * x + b) - y) ** 2 for x, y in data) / len(data)
        print(f"epoch {epoch:>3}: w={w:.3f} b={b:.3f} loss={loss:.4f}")

Output previsto

epoch   1: w=0.850 b=0.400 loss=7.0587
epoch  10: w=2.009 b=0.958 loss=0.0009
epoch  50: w=2.005 b=0.989 loss=0.0000
epoch 200: w=2.000 b=1.000 loss=0.0000

Come funziona

Per ogni punto l'errore è la previsione meno l'obiettivo. La regola della catena dà il gradiente dell'errore quadratico, 2·error·x per w e 2·error per b. Facendo la media sui dati e avanzando contro il gradiente, w e b si avvicinano a 2 e 1 e la perdita scende quasi a 0.

Modifica i valori ed esegui il programma nel compilatore Python online CodeUtility senza installare Python.

Esercizi pratici

Modifica gli input e verifica i casi limite prima di usare dataset più grandi.

  1. Cambia gli input o i pesi e prevedi l'output prima di eseguire.
  2. Stampa i valori intermedi per seguire ogni passo del calcolo.
  3. Risolvi le sfide collegate qui sotto per implementare l'idea da solo.
Esegui nell’IDE Python →

Esercitati con una sfida

Usa ciò che questa lezione spiega per risolvere un problema reale. Ogni sfida gira nel browser, con test immediati e una revisione dell'IA.

Tutte le sfide