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

Propagazione in avanti e funzioni di perdita in Python

Una rete neurale è fatta di strati di neuroni. Nella propagazione in avanti l'input attraversa ogni strato per produrre una previsione, e una funzione di perdita valuta quanto quella previsione è lontana dalla risposta giusta.

Il concetto in parole semplici

Una rete neurale è fatta di strati di neuroni. Nella propagazione in avanti l'input attraversa ogni strato per produrre una previsione, e una funzione di perdita valuta quanto quella previsione è lontana dalla risposta giusta.

Fai passare gli input strato per strato in una piccola rete neurale, poi misura l'errore con l'errore quadratico e la cross-entropy.

Idee chiave

  • Uno strato denso collega ogni input a ogni neurone dello strato.
  • L'output di uno strato è l'input del successivo.
  • La perdita è un solo numero, e più è bassa, migliori sono le previsioni.
  • Usa l'errore quadratico per i numeri e la cross-entropy per probabilità e classi.

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

Cambia gli input e l'obiettivo. Segui i valori attraverso lo strato nascosto e guarda come reagiscono le due perdite alla previsione.

Codice di esempio

Esegui codice →
main.py
import math

def dense(inputs, weights, biases, activation):
    # Each row of weights belongs to one neuron in the layer.
    return [activation(sum(x * w for x, w in zip(inputs, row)) + b) for row, b in zip(weights, biases)]

relu = lambda z: max(0.0, z)
sigmoid = lambda z: 1 / (1 + math.exp(-z))

x = [1.0, 2.0]
hidden = dense(x, [[0.5, -0.2], [0.3, 0.8]], [0.0, -0.5], relu)
output = dense(hidden, [[1.0, -1.0]], [0.2], sigmoid)
print("hidden layer:", [round(h, 3) for h in hidden])
print("prediction:", round(output[0], 3))

# A loss function measures how wrong the prediction is.
target = 1.0
mse = (output[0] - target) ** 2
bce = -(target * math.log(output[0]) + (1 - target) * math.log(1 - output[0]))
print("squared error:", round(mse, 3))
print("cross-entropy:", round(bce, 3))

Output previsto

hidden layer: [0.1, 1.4]
prediction: 0.25
squared error: 0.563
cross-entropy: 1.387

Come funziona

dense() calcola uno strato, in cui ogni riga di pesi è un neurone. Lo strato nascosto usa ReLU e quello di output usa sigmoid per dare una probabilità. L'errore quadratico e la cross-entropy misurano entrambi la distanza tra la previsione 0.25 e l'obiettivo 1.0; l'addestramento cerca di ridurli.

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