Impara Sfida: Addestramento del Percettrone

Sezione 1. Capitolo 17

single

Scorri per mostrare il menu

Prima di procedere con l'addestramento del percettrone, è importante ricordare che utilizza la funzione di perdita di entropia incrociata binaria discussa in precedenza. L'ultimo concetto chiave prima di implementare la retropropagazione è la formula per la derivata di questa funzione di perdita rispetto alle attivazioni di output, $a^n$. Di seguito sono riportate le formule per la funzione di perdita e la sua derivata:

\begin{aligned} L &= -(y \log(\hat{y}) + (1-y) \log(1 - \hat{y}))\\ da^n &= \frac {\hat{y} - y} {\hat{y}(1 - \hat{y})} \end{aligned}

dove $a^n = \hat{y}$

Per verificare che il percettrone si stia addestrando correttamente, il metodo fit() stampa anche la perdita media a ogni epoca. Questa viene calcolata facendo la media della perdita su tutti gli esempi di addestramento in quell'epoca:

for epoch in range(epochs):
    loss = 0

    for i in range(training_data.shape[0]):
        loss += -(target * np.log(output) + (1 - target) * np.log(1 - output))

average_loss = loss[0, 0] / training_data.shape[0]
print(f'Loss at epoch {epoch + 1}: {average_loss:.3f}')

L = -\frac1N \sum_{i=1}^N (y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i))

Infine, le formule per il calcolo dei gradienti in ciascun livello sono le seguenti:

\begin{aligned} dz^l &= da^l \odot f'^l(z^l)\\ dW^l &= dz^l \cdot (a^{l-1})^T\\ db^l &= dz^l\\ da^{l-1} &= (W^l)^T \cdot dz^l \end{aligned}

Dettagli di implementazione da ricordare

Durante la traduzione di queste formule in codice Python per il metodo backward(), ricordare le operazioni NumPy discusse nei capitoli precedenti:

L'operatore $\odot$ indica la moltiplicazione elemento per elemento, che si esegue con l'operatore * standard in Python.
L'operatore $\cdot$ indica il prodotto scalare, implementato tramite la funzione np.dot().
L'apice $T$ indica la trasposizione di una matrice, gestita tramite l'attributo .T.
Per calcolare $f'^l(z^l)$ , è possibile chiamare dinamicamente la derivata della funzione di attivazione del livello tramite self.activation.derivative(self.outputs).

Questo rende la struttura generale del metodo backward() simile alla seguente:

def backward(self, da, learning_rate):
    dz = ... # using da and self.activation.derivative()
    d_weights = ... # using np.dot() and .T
    d_biases = ...
    da_prev = ...

    self.weights -= learning_rate * d_weights
    self.biases -= learning_rate * d_biases

    return da_prev

Analogamente, quando si integra tutto nel metodo fit(), è importante ricordare che occorre iterare attraverso la rete all'indietro per propagare l'errore. La struttura generale è la seguente:

def fit(self, training_data, labels, epochs, learning_rate):
    # ... (Epoch loop and data shuffling) ...
            # Forward propagation
            output = ...

            # Computing the gradient of the loss function w.r.t. output (da^n)
            da = ...

            # Backward propagation through all layers
            for layer in self.layers[::-1]:
                da = ... # Call the backward() method of the layer

I dati di addestramento di esempio (X_train) insieme alle etichette corrispondenti (y_train) sono memorizzati come array NumPy nel file utils.py. Inoltre, anche le istanze delle funzioni di attivazione sono definite lì:

relu = ReLU()
sigmoid = Sigmoid()

Compito

Scorri per iniziare a programmare

L'obiettivo è completare il processo di addestramento per un percettrone multistrato implementando la retropropagazione e aggiornando i parametri del modello.

Seguire attentamente questi passaggi:

Implementazione del metodo backward() nella classe Layer:

Calcolare i seguenti gradienti:
- dz: derivata della funzione di perdita rispetto ai valori di pre-attivazione, utilizzando la derivata della funzione di attivazione;
d_weights: gradiente della perdita rispetto ai pesi, calcolato come prodotto scalare tra dz e il vettore di input trasposto;
d_biases: gradiente della perdita rispetto ai bias, uguale a dz;
da_prev: gradiente della perdita rispetto alle attivazioni dello strato precedente, ottenuto moltiplicando la matrice dei pesi trasposta per dz.
Aggiornare pesi e bias utilizzando il learning rate.

Completamento del metodo fit() nella classe Perceptron:

Calcolare l'output del modello chiamando il metodo forward();
Calcolare la perdita utilizzando la formula dell'entropia incrociata;
Calcolare $da^n$ — la derivata della perdita rispetto alle attivazioni di output;
Scorrere all'indietro tra gli strati, eseguendo la retropropagazione chiamando il metodo backward() di ciascun layer.

Verifica del comportamento dell'addestramento:

Se tutto è implementato correttamente, la perdita dovrebbe diminuire costantemente a ogni epoca utilizzando un learning rate di 0.01.

Soluzione

Cambia al desktop per esercitarti nel mondo realeContinua da dove ti trovi utilizzando una delle opzioni seguenti

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 17

single

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione