Perceptron è il nome della rete neurale più semplice, composta da un solo neurone. Tuttavia, per poter risolvere problemi più complessi, creeremo un modello chiamato perceptron multistrato (MLP). Un perceptron multistrato è costituito da uno o più strati nascosti. La struttura di un perceptron multistrato è la seguente:

1. Strato di input: riceve i dati di input;
2. Strati nascosti: questi strati elaborano i dati ed estraggono schemi.
3. Strato di output: produce la previsione o classificazione finale.

In generale, ogni strato è composto da più neuroni, e l'output di uno strato diventa l'input per lo strato successivo.

Pesi e Bias degli Strati

Prima di implementare uno strato, è importante comprendere come memorizzare i pesi e i bias di ciascun neurone al suo interno. Nel capitolo precedente, hai imparato come memorizzare i pesi di un singolo neurone come vettore e il suo bias come scalare (singolo numero).

Poiché uno strato è composto da più neuroni, è naturale rappresentare i pesi come una matrice, dove ogni riga corrisponde ai pesi di un neurone specifico. Di conseguenza, i bias possono essere rappresentati come un vettore, la cui lunghezza è uguale al numero di neuroni.

Dato uno strato con $3$ input e $2$ neuroni, i suoi pesi saranno memorizzati in una matrice $2 \times 3$ $W$ e i suoi bias saranno memorizzati in un vettore $2 \times 1$ $b$, che sono così rappresentati:

Qui, l'elemento $W_{ij}$ rappresenta il peso del $j$-esimo input verso il $i$-esimo neurone, quindi la prima riga contiene i pesi del primo neurone e la seconda riga contiene i pesi del secondo neurone. L'elemento $b_i$ rappresenta il bias del $i$-esimo neurone (due neuroni – due bias).

Propagazione in avanti

Eseguire la propagazione in avanti per ciascun livello significa attivare ciascun suo neurone calcolando la somma pesata degli input, aggiungendo il bias e applicando la funzione di attivazione.

In precedenza, per un singolo neurone, hai implementato la somma pesata degli input calcolando un prodotto scalare tra il vettore di input e il vettore dei pesi, aggiungendo il bias.

Poiché ogni riga della matrice dei pesi contiene il vettore dei pesi per un particolare neurone, tutto ciò che devi fare ora è semplicemente eseguire un prodotto scalare tra ogni riga della matrice e il vettore di input. Fortunatamente, questo è esattamente ciò che fa la moltiplicazione di matrici:

Per aggiungere i bias agli output dei rispettivi neuroni, deve essere aggiunto anche un vettore di bias:

Infine, la funzione di attivazione viene applicata al risultato — sigmoid o ReLU, nel nostro caso. La formula risultante per la propagazione in avanti nel livello è la seguente:

dove $a$ è il vettore delle attivazioni (output) dei neuroni.

Classe Layer

I componenti fondamentali del perceptron sono i suoi strati (layers), pertanto è opportuno creare una classe Layer separata. I suoi attributi includono:

• inputs: un vettore di input (n_inputs è il numero di input);
• outputs: un vettore di valori di output grezzi (prima dell'applicazione della funzione di attivazione) dei neuroni (n_neurons è il numero di neuroni);
• weights: una matrice dei pesi;
• biases: un vettore dei bias;
• activation_function: la funzione di attivazione utilizzata nello strato.

Come nell'implementazione del singolo neurone, weights e biases saranno inizializzati con valori casuali compresi tra -1 e 1 estratti da una distribuzione uniforme.

class Layer:
    def __init__(self, n_inputs, n_neurons, activation_function):
        self.inputs = np.zeros((n_inputs, 1))
        self.outputs = np.zeros((n_neurons, 1))
        self.weights = ...
        self.biases = ...
        self.activation = activation_function

Gli attributi inputs e outputs verranno utilizzati successivamente nella retropropagazione, quindi è opportuno inizializzarli come array NumPy di zeri.

La propagazione in avanti può essere implementata nel metodo forward(), dove gli outputs vengono calcolati in base al vettore inputs utilizzando NumPy, seguendo la formula sopra:

def forward(self, inputs):
    self.inputs = np.array(inputs).reshape(-1, 1)
    # Raw outputs
    self.outputs = ...
    # Applying the activation function
    return ...