Neural Network, Introduzione e Forward Propagation

Cos’è una Rete Neurale?

Una Rete Neurale è un modello computazionale progettato per risolvere problemi complessi di riconoscimento di pattern, presenti nel dataset di input. Essa è costituita da unità interconnesse, chiamate nodi o neuroni, dove ogni nodo agisce come un’unità computazionale, il cui comportamento è simile a quello di un modello di Regressione Logistica. I nodi sono organizzati in layer: un layer di input, uno o più hidden layer, e un layer di output. In sostanza, ogni nodo è una funzione che elabora i dati in ingresso eseguendo operazioni matematiche, in genere moltiplicando gli input per i pesi associati, aggiungendo bias, e applicando funzioni di attivazione. Questi calcoli permettono alle reti neurali di identificare le strutture sottostanti in grandi insiemi di dati, consentendo di svolgere compiti quali il riconoscimento delle immagini, l’elaborazione del linguaggio naturale, e la modellazione predittiva.

Per fare un confronto, la Regressione Logistica utilizza una funzione di attivazione non-lineare (il sigmoide), ma, per limiti architetturali, tale modello può produrre solo regioni decisionali lineari. Di contro, le Reti Neurali hanno in genere una capacità di modellazione molto più alta, che deriva dalla composizione di più funzioni di attivazione non-lineari, su più layer, dove ogni layer aggiuntivo applica una trasformazione non-lineare all’output del layer precedente. La composizione di queste trasformazioni consente alle Reti Neurali di creare confini decisionali non-lineari complessi, che consentono di classificare dati che non sono linearmente separabili nella loro forma originaria. Con un numero sufficiente di layer e di nodi, le Reti Neurali possono approssimare virtualmente qualsiasi funzione, illustrando in tal modo la loro capacità di gestire problemi sofisticati.

Forward Propagation e Backpropagation

Nelle Reti Neurali, il processo di apprendimento prevede due fasi fondamentali: Forward Propagation e Backpropagation (o “Forward Phase” e “Backward Phase”).

Nella fase di Forward Propagation, i dati in ingresso vengono immessi nella rete, e si spostano in avanti attraverso ogni layer, fino a raggiungere il layer di output. Alla fine, per una data osservazione, la rete ritorna le probabilità di appartenenza alle classi, calcolate sui nodi degli hidden layer, e su quelli dell’output layer. Questi valori possono essere utilizzati per fare previsioni finali, o per ottimizzare ulteriormente i parametri del modello durante l’addestramento della rete (richiamando la Backpropagation).

Nella fase di Backpropagation, la rete calcola la sensibilità dell’errore (loss) alle variazioni dei parametri del layer di output. Quindi, il processo “propaga l’errore all’indietro”, calcolando come la funzione di costo sia influenzata dai parametri di ciascuno dei layer precedenti. L’obiettivo è determinare i gradienti (le derivate parziali) della funzione di costo, rispetto a ogni parametro della rete. Questi valori verranno poi utilizzati per regolare i parametri del modello, e migliorare le sue previsioni.

Forward Propagation

La fase Forward Propagation è il processo con cui i dati si muovono attraverso la Rete Neurale, dal layer di input a quello di output, layer per layer, per calcolare le previsioni di output. Per capire come funziona questo processo, iniziamo a considerare il funzionamento interno di una singola unità del modello di Regressione Logistica. Essa è costituita da un input layer e da un output layer, che compongono una semplice struttura, illustrata da Figura 1:

Per una data osservazione in ingresso, $\mathbf{x}^{(i)}$, il layer di input definisce un nodo per ciascuna delle sue $n$ feature, $x^{(i)}_j$. A ogni nodo di tipo feature è associato un proprio peso, $w_j$. Nel layer di output abbiamo un solo nodo, che calcola il valore logit $z^{(i)}$, combinando linearmente le feature in ingresso, $x^{(i)}_j$, con i pesi associati, $w_j$, insieme a un termine di bias, $b$. Il bias ci permette di costruire modelli lineari la cui funzione di ipotesi non è fissata nell’origine dello spazio delle feature. Il valore reale risultante, $z^{(i)}$, viene passato come parametro alla funzione di attivazione sigmoide, $\sigma$, per produrre un valore di output che corrisponde alla previsione del modello, ovvero alla probabilità che l’osservazione corrente appartenga alla label di classe positiva, $p$:

Ecco un esempio che utilizza solo tre feature, $x_1$, $x_2$ e $x_3$:

Quando passiamo la combinazione lineare degli input, più il bias $b$, come parametro della funzione sigmoide, $\sigma$, indichiamo questo processo come funzione di attivazione. La funzione sigmoide limita il valore del logit, $z^{(i)}$, nell’intervallo di probabilità $\left[0, 1\right]$.

Classificazione Multi-Classe

Il modello precedente è in grado di effettuare solo una classificazione binaria. Tuttavia, ricordiamo che possiamo eseguire una classificazione multiclasse costruendo un insieme di modelli di Regressione Logistica, dove ogni modello restituisce in uscita la probabilità che l’osservazione di input appartenga ad una specifica label di classe. Estendiamo la nostra Rete Neurale per rappresentare questo aspetto. Consideriamo la seguente immagine, con un layer di output con due nodi, $a_1$ e $a_2$, che rappresentano due funzioni di attivazione distinte (stiamo ancora effettuando una classificazione binaria):

Generalizzando, un layer di output con $n_o$ nodi $a_1, a_2, \cdots, a_{n_o}$ permette di avere un classificatore multiclasse per $n_o$ classi distinte. Ognuno di questi nodi ha un proprio set di pesi, e un singolo bias. Indichiamo con $w_{t,s}$ il peso associato alla connessione che va dal nodo di destinazione $t$ nel layer corrente, al nodo sorgente $s$ nel layer precedente. Considerando un’osservazione $\mathbf{x}$, con $n$ feature di input (non usando la notazione “superscript”, per migliorare la leggibilità delle formule), abbiamo:

In relazione all’immagine precedente, la notazione $w_{2,3}$ indica il peso della connessione che va dal secondo nodo del layer di output, $a_2$, al terzo nodo del layer di input, $x_3$. Per questa semplice rete, abbiamo:

dove $a_1$ è la probabilità che l’esempio in ingresso, $\mathbf{x}$, appartenga all’etichetta di classe “$0$”, e $a_2$ è la probabilità che $\mathbf{x}$ appartenga all’etichetta di classe “$1$”. Possiamo codificare queste operazioni utilizzando la seguente notazione matriciale:

dove $\mathbf{W}$ è una matrice di dimensione $n_o \times n$ che, per ogni $j$-ma riga, definisce il set di pesi associato al $j$-mo nodo dell’output layer. L’uso delle matrici per codificare i calcoli delle reti neurali fornisce un modo efficiente e scalabile per rappresentare ed eseguire operazioni matematiche complesse. Le operazioni matriciali possono sfruttare l’hardware di elaborazione dati in parallelo (come le GPU), e questo accelera notevolmente l’addestramento e l’inferenza del modello. Inoltre, le rappresentazioni matriciali sono facilmente scalabili per reti di grandi dimensioni: aggiungere altri nodi o layer significa semplicemente espandere le matrici, anziché creare numerose equazioni individuali.

L’equazione della matrice precedente, $\eqref{sigma-matrix-1}$, mostra il caso della classificazione multiclasse applicata su un singolo esempio, $\mathbf{x}$. Possiamo estendere la nostra matrice di input per classificare più osservazioni in un colpo solo. Reintroducendo la notazione “superscript”, abbiamo:

La matrice risultante, $\mathbf{A}$, ha $m$ righe e $n_o$ colonne. Ogni $i$-ma riga definisce i $n_o$ valori di probabilità che l’osservazione $\mathbf{x}^{(i)}$ appartenga a una di queste $n_o$ classi. Ad esempio, $a^{(1)}_1$ indica la probabilità che $\mathbf{x}^{(1)}$ appartenga alla classe “$0$”, $a^{(1)}_2$ indica la probabilità che $\mathbf{x}^{(1)}$ appartenga alla classe “$1$”, e così via.

Uso degli Hidden Layer

Finora ci siamo occupati esclusivamente di reti a due strati; inseriamo le informazioni nel layer di input, e osserviamo i risultati nel layer di output. La vera potenza delle Reti Neurali emerge quando si aggiungono altri layer alla rete. Ogni layer che si trova tra il layer di input e quello di output è noto come “hidden layer”. L’esempio seguente presenta una semplice Rete Neurale con uno layer di input, un hidden layer, e un layer output:

Per semplicità, il diagramma precedente contiene due nodi per ogni layer, ma layer diversi possono contenere un numero diverso di nodi. Indicando con $n$ il numero di nodi feature dell’input layer, possiamo calcolare l’output del $j$-esimo nodo di attivazione nell’hidden layer come:

Ad esempio, considerando il diagramma precedente, per calcolare l’output del primo nodo di attivazione dell’hidden layer, $a^h_1$, abbiamo:

Indicando con $n_h$ il numero di nodi dell’hidden layer, possiamo calcolare l’output del $j$-esimo nodo di attivazione dell’output layer come:

Ad esempio, per calcolare l’output del secondo nodo di attivazione dell’output layer, $a^o_2$, abbiamo:

Più in generale, possiamo calcolare l’output del $j$-esimo nodo di attivazione, nel layer $l$, come:

dove:

• $w^l_{t,s}$ è il peso associato alla connessione che va dal nodo di destinazione $t$, nel layer corrente $l$, al nodo sorgente $s$ nel layer precedente $(l-1)$.
• $b^l_t$ è il bias associato al nodo $t$ nel layer corrente, $l$.
• $a^l_q$ è il $q$-esimo nodo di attivazione, nel layer corrente, $l$.
• il pedice $n_l$ indica il numero di nodi del layer $l$.

Per accelerare i calcoli, possiamo usare le operazioni matriciali, considerando che:

Avendo un’unica osservazioni di input, $\mathbf{x}$, possiamo calcolare $\mathbf{a}^{l}$ come:

Avendo $m$ osservazioni di input, $\mathbf{x}^{(i)}$, possiamo calcolare la matrice $\mathbf{A}^l$, di dimensioni $m \times n_l$, dove ogni $i$-ma riga definisce gli $n_l$ nodi di attivazione $a^{l(i)}_j$, calcolati per l’osservazione corrente. In questo caso, consideriamo che:

dove $a^{l(i)}_j$ indica l’output del $j$-mo nodo di attivazione del layer $l$, per l’$i$-ma osservazione di input.

Implementazione di Forward Propagation

La classe MLPClassifier

Dopo aver definito le equazioni vettoriali che ci permettono di calcolare l’output dei nodi di attivazione in un dato layer, implementiamo un semplice modello di Rete Neurale con un singolo hidden layer. Visto che per ora non sappiamo come eseguire il training del modello, usiamo valori dei parametri già ottimizzati, che carichiamo da alcuni files.

Nel costruttore della classe, utilizziamo i parametri num_features, num_hidden, num_classes per inizializzare la matrice dei pesi, e il vettore bias per l’hidden layer e per l’output layer. Per un dato layer $l$, la matrice $\mathbf{W}^l$ ha un numero di righe uguale al numero di nodi del layer corrente, e un numero di colonne uguale al numero di nodi del layer precedente. Inoltre, il vettore $\mathbf{b}^l$ ha un numero di elementi uguale al numero di nodi del layer corrente. Per l’hidden layer:

• la matrice dei pesi, self.weight_h, ha dimensione (num_hidden, num_features)
• il vettore bias, self.bias_h ha dimensione (num_hidden, )

Per l’output layer:

• self.weight_out ha dimensione (num_classes, num_hidden).
• self.bias_out ha dimensione (num_classes, ).

Quando inizializziamo una matrice dei pesi, dobbiamo evitare di usare un valore costante, come $0$, perché questo può interrompere il processo di apprendimento della rete. Approfondiremo questo problema dopo aver appreso il funzionamento del processo di Backpropagation. Per ora ci basti sapere che, se tutti i nodi di un layer vengono configurati con gli stessi pesi, per gli stessi valori di input, essi calcoleranno lo stesso valore di output, e durante l’addestramento, si aggiorneranno allo stesso modo. Di conseguenza, rimarranno sempre identici, senza riuscire ad apprendere le diverse feature del dataset. Una strategia per risolvere questo problema è quella di usare il metodo Generator.normal per inizializzare entrambe le matrici con una distribuzione normale, con media $0$, e deviazione standard di $0.1$:

import numpy as np

class MLPClassifier:
    """A Multi Layer Perceptron (MLP) with a single Hidden Layer."""
    def __init__(self, num_features, num_hidden, num_classes, random_state=123):
        """
        Initialize the weight matrices and bias vectors for the hidden and output layers.

        Parameters
        ----------
        num_features: int
            the number of dataset features.
        num_hidden : int
            the number of nodes for the hidden layer.
        num_classes : int
            the number of nodes for the output layer.
        """
        self.num_classes = num_classes
        self.rng = np.random.default_rng(random_state)

        # initialize hidden layer
        self.weight_h = self.rng.normal(loc=0.0, scale=0.1, size=(num_hidden, num_features))
        self.bias_h = np.zeros(num_hidden).reshape(1, -1)

        # initialize output layer
        self.weight_o = self.rng.normal(loc=0.0, scale=0.1, size=(num_classes, num_hidden))
        self.bias_o = np.zeros(num_classes).reshape(1, -1)

Il Metodo Fit

Per ora, non sapendo come eseguire l’addestramento del modello, limitiamoci a caricare i valori ottimizzati di tutti i parametri da alcuni file:

    def fit(self, X, y):
        """
        Fit the data, computing the optimal values for the model parameters.
        For now, just read the fitted parameters from some files.
        """
        self.__load_params()

    def __load_params(self, data_dir="data"):
        self.weight_h = np.load(data_dir + "/weight_h.npy")
        self.weight_o = np.load(data_dir + "/weight_out.npy")
        self.bias_h   = np.load(data_dir + "/bias_h.npy")
        self.bias_o   = np.load(data_dir + "/bias_out.npy")

Il Metodo Predict

Il metodo predict chiama __forward per calcolare i valori di output della rete, che sono one-hot encoded, e li converte in formato “umanamente leggibile”:

    def predict(self, X: np.ndarray) -> np.ndarray:
        """
        Classify the input examples.

        Parameters
        ----------
        X : ndarray with shape (n_examples, n_features)
            the examples to classify.

        Returns
        -------
        ndarray with shape (n_examples, )
            an array containing the target class label for each example.
        """
        # convert the one-hot encoded labels to human-readable values
        _, out = self.__forward(X)       # shape: (n_examples, n_classes)
        y_hat = np.argmax(out, axis=1)   # shape: (n_examples, )
        return y_hat

Il Metodo di Forward Propagation

Il metodo __forward definisce la fase di Forward Propagation, implementando l’equazione $\eqref{A^l}$ per calcolare la matrice di attivazione per l’hidden layer, A_h, e quella per l’output layer, A_out. Ricordiamoci che, per ogni osservazione $\mathbf{x}^{(i)}$ passata alla rete, la matrice di attivazione associata ad un dato layer, contiene la probabilità di classe restituita da ogni nodo di tale layer. Per l’hidden layer, la matrice A_h ha dimensione (n_examples, n_hidden), mentre per l’output layer, la matrice A_out ha dimensione (n_examples, n_out), dove n_hidden e n_out sono, rispettivamente, il numero di nodi dell’hidden e dell’output layer:

    def __forward(self, X):
        """
        Take in one or more training examples, and for each one of them,
        get the class-membership probabilities returned from the hidden and output layers.

        Parameters
        ----------
        X : ndarray with shape (n_examples, n_features)
            the examples to classify.

        Returns
        -------
        A_h : ndarray with shape (n_examples, n_hidden)
            hidden layer's activation matrix.
            For each example, it contains the class probability returned by every node of the layer.
        A_o : ndarray with shape (n_examples, n_classes)
            output layer's activation matrix.
            For each example, it contains the class probability returned by every node of the layer.
        """
        # Hidden Layer:
        #   Z^(h) = X @ W^(h)^t + b^(h)
        #   A^(h) = σ(Z^(h))
        Z_h = (X @ self.weight_h.T) + self.bias_h    # shape: (n_examples, n_hidden)
        A_h = self.__sigmoid(Z_h)                    # shape: (n_examples, n_hidden)

        # Output Layer:
        #   Z^(o) = A^(h) @ W^(o)^t + b^(o)
        #   A^(o) = σ(Z^(o))
        Z_o = (A_h @ self.weight_o.T) + self.bias_o  # shape: (n_examples, n_classes)
        A_o = self.__sigmoid(Z_o)                    # shape: (n_examples, n_classes)

        return A_h, A_o

    def __sigmoid(self, z):
        return 1. / (1. + np.exp(-z))

Esempi di Classificazione

Proviamo a confrontare i risultati di classificazione ottenuti da un Regressore Logistico, con la nostra implementazione MLPClassifier, utilizzando un hidden layer con $6$ nodi:

from sklearn.datasets import make_moons
from sklearn.linear_model import LogisticRegression

# config
num_hidden = 6

# get data from a non-linear dataset
X, y = make_moons(n_samples=100, noise=0.05, random_state=42)

# instance and train the models
log_reg = LogisticRegression(random_state=42)
log_reg.fit(X, y)
mlpc = MLPClassifier(num_features=2, num_hidden=num_hidden, num_classes=2)
mlpc.fit(X, y)

# plot the decision regions and the models' losses
classifiers = [log_reg, mlpc]
classifiers_name = ["Logistic Regression", "Multi-Layer Perceptron"]
plot_decision_regions_2D(X, y, classifiers, classifiers_name)

Dal grafico precedente possiamo vedere come MLPClassifier, con un singolo hidden layer, sia in grado di adattarsi molto bene a un dataset non-lineare . Vediamo ora cosa accade se ripetiamo lo stesso processo, con sei diverse istanze, ognuna delle quali utilizza un hidden layer con un numero crescente di nodi:

Possiamo notare come, con un hidden layer con un singolo neurone, otteniamo lo stesso risultato precedentemente avuto con un Regressore Logistico. Con $3$ nodi cominciamo a vedere come il confine della regione decisionale del classificatore cominci a seguire il perimetro delle due “mezze lune” formate dalle osservazioni del dataset. Con $5$ nodi, il classificatore si adatta alla distribuzione dei dati, e l’errore di classificazione scende a $0$.

La Rete Neurale come Approssimatore Universale di Funzioni

L’Hidden Layer

Consideriamo una rete con un hidden layer con un singolo nodo. Il suo output è calcolato come:

La stessa rete, con un hidden layer con due nodi, ritorna:

Se invece abbiamo un hidden layer con tre nodi:

Possiamo generalizzare le equazioni $\eqref{hlo-1}$, $\eqref{hlo-2}$ e $\eqref{hlo-3}$ come:

dove $n_h$ è il numero di nodi dell’hidden layer.

Le Funzioni Base

Riguardando il grafico di Figura 6, notiamo come al crescere dei nodi $a^h_j$, la rete neurale aumenti la propria capacità di rappresentare funzioni complesse. Ognuno dei nodi $a^h_j$ calcola come suo valore di output, una trasformazione non-lineare dei suoi input, con i propri pesi e bias. Queste trasformazioni possono essere viste come funzioni base $\phi_j$ (phi), ovvero elementi che possono essere linearmente combinati assieme per approssimare o definire altre funzioni più complesse.

Questa idea deriva dall’algebra lineare, dove i vettori base sono un insieme di vettori linearmente indipendenti che attraversano lo spazio vettoriale, e qualsiasi punto in tale spazio può sempre essere rappresentato come una combinazione lineare dei suoi vettori base, con pesi scalari. In uno spazio bidimensionale, possiamo definire i vettori base $\mathbf{e}_1 = (1, 0)$, $\mathbf{e}_2 = (0, 1)$, ed ogni vettore $\mathbf{v} = (x, y)$ può essere rappresentato come $\mathbf{v} = x\mathbf{e}_1 + y\mathbf{e}_2$. Ad esempio, possiamo visualizzare $\mathbf{v} = 2\mathbf{e}_1 + 1.5\mathbf{e}_2$ come:

Negli spazi di funzioni, facciamo la stessa cosa, ma invece di usare vettori come $(1, 0)$ o $(0, 1)$, usiamo delle funzioni base. Ad esempio, possiamo usare delle funzioni base polinomiali come:

Rimanendo in uno spazio 2D, possiamo definire una curva tramite la combinazione lineare delle funzioni base $\phi_1$ e $\phi_2$, come $f(x) = 3\phi_1(x) - 2\phi_2(x)$:

Dal grafico precedente, possiamo notare come queste semplici curve possano essere combinate — ciascuna scalata dal proprio peso — per formare una forma più complessa. È esattamente lo stesso concetto che le reti neurali utilizzano quando combinano funzioni base non-lineari, come le attivazioni sigmoidi, per costruire modelli espressivi. Ritornando alla nostra rete neurale, possiamo usare $\eqref{a^h_1}$, $\eqref{a^h_2}$, e $\eqref{a^h_3}$ per definire le seguenti funzioni base:

e riscrivere $\eqref{hlo-3}$ come una combinazione lineare delle stesse, dove ognuna è scalata dal suo peso $w^o_{1,j}$:

Generalizzando:

L’Output Layer

In una rete neurale con un singolo hidden layer, l’output di ciascun nodo nascosto $a^h_j$ può essere interpretato come una funzione base non-lineare delle feature di input. L’output layer apprende quindi a combinare queste funzioni base per approssimare la funzione target, a noi sconosciuta.

Dopo la trasformazione non-lineare operata dall’hidden layer, le osservazioni vengono rappresentate in un nuovo spazio delle feature latenti¹, $\pmb{\phi} = (\phi_1, \dots, \phi_{n_h})$. In questo spazio, il $j$-esimo nodo dell’output layer calcola la combinazione lineare:

L’equazione $z^o_j = 0$ definisce un iperpiano nello spazio delle feature latenti, che separa le osservazioni in due regioni: quelle per cui $z^o_j > 0$ e quelle per cui $z^o_j < 0$. L’applicazione della funzione di attivazione sigmoide, $\sigma(z^o_j)$, introduce una non-linearità finale, comprimendo l’output nell’intervallo $[0, 1]$. Il valore ottenuto può essere interpretato come la probabilità che l’osservazione di input appartenga alla classe “$j$”.

Riprendiamo l’esempio già visto nel contesto delle feature polinomiali, in cui consideriamo un dataset monodimensionale (1D) che non è linearmente separabile:

In questo caso, la trasformazione operata dalle funzioni base genera un nuovo spazio delle feature bidimensionale (2D), nel quale le osservazioni diventano linearmente separabili:

Ne consegue che una rete neurale con un singolo hidden layer è, in teoria, un approssimatore universale di funzioni: dato un numero sufficiente di neuroni, essa può approssimare arbitrariamente bene qualsiasi funzione continua e quindi qualsiasi confine decisionale. All’aumentare del numero di neuroni nell’hidden layer, aumenta anche il numero di parametri apprendibili dalla rete, accrescendone la capacità espressiva. Questo consente al modello di catturare strutture sempre più complesse nei dati, e di adattare il confine decisionale alla loro distribuzione.