Perceptron si riferisce al tipo più semplice di rete neurale, che consiste di un solo neurone. Per affrontare problemi più complessi, si utilizza un modello noto come perceptron multistrato (MLP). Un perceptron multistrato contiene uno o più strati nascosti che permettono alla rete di apprendere schemi complessi nei dati.

La struttura di un perceptron multistrato include:

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

Ogni strato è composto da più neuroni, e l'output di uno strato funge da 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 appreso 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 appaiono come segue:

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, la somma pesata degli input veniva implementata 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, ora basta semplicemente eseguire un prodotto scalare tra ogni riga della matrice e il vettore di input. Fortunatamente, è 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 layer; 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 nel layer.

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 ...