Il Neurone Artificiale Adaline: Introduzione

Cos’è un Neurone Artificiale

Adaline (Adaptive Linear Neuron) è uno dei primi modelli di neurone artificiale, sviluppato da Bernard Widrow e Ted Hoff nel 1960. Adaline nasce pochi anni dopo il Percettrone, sviluppato da Frank Rosenblatt alla fine degli anni ‘50, e introduce un’importante innovazione nel modo in cui vengono appresi i parametri del modello. Le origini del concetto di neurone artificiale risalgono però ancora più indietro: nel 1943 Warren McCulloch e Walter Pitts proposero uno dei primi modelli matematici di neurone artificiale, ponendo alcune delle basi teoriche per lo sviluppo delle successive reti neurali.

Un neurone artificiale è una singola unità di calcolo che combina i valori delle feature di input attraverso una somma pesata:

e utilizza il risultato per produrre un output. Nel caso di Adaline, il modello può essere utilizzato per svolgere compiti di classificazione binaria, nei quali le osservazioni vengono assegnate, ad esempio, alla classe $-1$ oppure alla classe $1$ (o, a seconda dell’implementazione, alle classi $0$ e $1$). Una singola unità come Adaline costituisce un modello estremamente semplice, ma il principio di combinare input pesati e apprendere i pesi dai dati è alla base di modelli molto più complessi¹. Possiamo quindi pensare ad Adaline come a uno dei precursori dei moderni classificatori e delle reti neurali: un modello semplice e con importanti limitazioni, ma storicamente e didatticamente molto significativo.

Adaline fu sviluppato in un periodo nel quale le risorse di calcolo erano estremamente limitate e molti degli strumenti oggi comunemente associati alle reti neurali non erano ancora utilizzati nella loro forma moderna. La semplicità computazionale del modello era quindi estremamente importante. Per questo motivo, useremo Adaline come strumento didattico per comprendere alcuni dei meccanismi fondamentali dell’apprendimento supervisionato: la somma pesata degli input, la funzione di costo, l’aggiornamento dei parametri e la Discesa del Gradiente. Successivamente passeremo a modelli di classificazione più moderni e funzionali, come la Regressione Logistica.

L’Algoritmo di Classificazione

Adaline estende l’implementazione del nostro modello di regressione lineare, riutilizzando molti concetti che già conosciamo, come la funzione di ipotesi, la funzione di costo e il training iterativo del modello, e aggiungendo alcune nuove funzionalità che vedremo di seguito. Il diagramma delle sue componenti è mostrato nell’immagine seguente:

In dettaglio, Adaline è definito dai seguenti componenti:

Le Feature di Input

Adaline riceve in input una o più variabili indipendenti, o feature, $x^{(i)}_1$, …, $x^{(i)}_n$, che descrivono l’$i$-esima osservazione del dataset.

I Pesi

A ogni variabile indipendente $x^{(i)}_j$ è associato un peso $w_j$ che, tramite la somma pesata (weighted sum), determina il contributo di tale feature al valore di output del neurone.

I pesi sono parametri regolabili, che l’algoritmo di apprendimento modifica durante la fase di training. A parità delle altre feature, un peso positivo indica che all’aumentare della feature corrispondente aumenta il valore della somma pesata, mentre un peso negativo produce l’effetto opposto. Il valore assoluto del peso determina invece quanto una variazione della feature influenza la somma pesata: maggiore è $|w_j|$, maggiore è l’effetto prodotto da una variazione di $x_j$. Bisogna tuttavia ricordare che la grandezza dei pesi dipende anche dalla scala delle feature. Per questo motivo, i valori assoluti dei pesi di feature misurate su scale diverse non possono essere confrontati direttamente per determinarne l’importanza.

Il Bias

Adaline utilizza inoltre un termine di bias, $b$, anch’esso regolato durante il processo di training. Il bias permette di traslare la funzione lineare rispetto all’origine e consente quindi al modello di adattarsi a dati per i quali la relazione da apprendere non passa necessariamente per l’origine dello spazio.

La Somma Pesata

La somma pesata delle feature di input, $\eqref{wsum}$, definisce la funzione di ipotesi² del modello, $h\left(\textbf{x}^{(i)}\right)$, che produce un valore continuo:

A livello geometrico, come abbiamo già visto, la funzione di ipotesi può essere rappresentata come un iperpiano in uno spazio di $n+1$ dimensioni, dove $n$ è il numero di feature e la dimensione aggiuntiva rappresenta l’output $h$. Ad esempio, con due feature $x_1$ e $x_2$, possiamo rappresentare $\eqref{hypo}$ nello spazio tridimensionale $(x_1,x_2,h)$ come un piano. Durante il training, i parametri $\mathbf{w}$ e $b$ vengono modificati in modo che questo piano approssimi il più possibile i valori del dataset di training, secondo la funzione di costo utilizzata dal modello, come mostrato in Figura 2:

La Funzione di Attivazione

La somma pesata $z^{(i)}$ viene passata in input a una funzione di attivazione $\sigma$ (sigma) per produrre il valore di uscita del neurone associato al vettore delle feature $\textbf{x}^{(i)}$:

In una moderna rete neurale multi-layer, la funzione di attivazione svolge un ruolo fondamentale: riceve in input la somma pesata calcolata dal neurone e, generalmente, applica a essa una trasformazione non lineare. Questa non-linearità è essenziale perché, senza di essa, la composizione di più layer lineari rimane comunque una trasformazione lineare. Le funzioni di attivazione non lineari permettono invece alla rete di apprendere relazioni e pattern complessi nei dati, rendendo possibile affrontare problemi di classificazione o regressione caratterizzati da relazioni non lineari.

Ad esempio, la funzione di attivazione sigmoide applica una trasformazione non lineare che permette di mappare un valore reale arbitrario appartenente all’intervallo $\left(-\infty,\infty\right)$ in un valore compreso nell’intervallo $\left(0,1\right)$. Nel contesto della classificazione binaria, questo valore può essere interpretato come una probabilità.

Nel modello Adaline, invece, la funzione di attivazione non introduce alcuna non-linearità. Si tratta infatti di una semplice funzione identità, che restituisce in output il valore di ingresso $z^{(i)}$ senza applicare alcuna trasformazione:

Adaline produce quindi un output reale e continuo. Questa caratteristica è particolarmente importante durante il training. A differenza del Percettrone, che aggiorna i propri parametri sulla base dell’output discreto prodotto da una Step function, Adaline calcola la funzione di costo direttamente sull’output lineare continuo $\text{out}^{(i)}$. È quindi possibile utilizzare come funzione di costo l’errore quadratico medio, MSE, e ottimizzare i parametri mediante la discesa del gradiente.

L’output della funzione di attivazione può essere interpretato anche geometricamente. Per un qualsiasi vettore di feature $\mathbf{x}^{(i)}$, il modello produce il valore:

Il punto $\left(\mathbf{x}^{(i)},\text{out}^{(i)}\right)$ giace quindi sull’iperpiano definito dalla funzione di ipotesi $\eqref{hypo}$. Ad esempio:

La Funzione di Soglia

La funzione di soglia permette di trasformare l’output continuo prodotto dalla funzione di attivazione $\eqref{identity}$ in una classe, utilizzata come previsione finale del classificatore. Dato un valore di soglia $\theta$ (theta), possiamo definire:

La funzione $\eqref{threshold_1}$ indica che, se l’output continuo $z^{(i)}$ è maggiore o uguale alla soglia $\theta$, l’osservazione viene assegnata alla classe $\text{ClassA}$; altrimenti viene assegnata alla classe $\text{ClassB}$.

Adaline viene tradizionalmente formulato utilizzando le label $-1$ e $+1$ e una soglia $\theta=0$. È tuttavia possibile utilizzare anche label $0$ e $1$. Se il modello viene addestrato utilizzando questi valori come target, possiamo ad esempio scegliere $\theta=0.5$ e definire:

È importante ricordare che, in Adaline, $z^{(i)}$ non rappresenta una probabilità. La soglia $0.5$ rappresenta semplicemente il valore scelto per separare le due classi quando queste sono codificate come $0$ e $1$. In relazione al grafico sottostante, Figura 4, la funzione di soglia assegna alla classe $1$ le osservazioni per le quali $z^{(i)} \ge 0.5$, e alla classe $0$ quelle per le quali $z^{(i)} < 0.5$. La soglia determina quindi due regioni decisionali nello spazio delle feature: una nella quale il modello predice $\hat{y}=0$ e l’altra nella quale predice $\hat{y}=1$. La superficie che separa queste due regioni prende il nome di confine decisionale (decision boundary).

Nel caso di Adaline, il confine decisionale è lineare. Infatti, poiché:

il passaggio da una classe all’altra avviene quando:

e quindi:

Questa equazione definisce un iperpiano nello spazio delle feature. Con due feature $x_1$ e $x_2$, ad esempio, il confine decisionale è una retta.

Ritornando a Figura 4, per un dato vettore di feature $\mathbf{x}^{(i)}=\left(x^{(i)}_1,x^{(i)}_2\right)$, i punti verdi trasparenti

rappresentano gli output continui prodotti dalla funzione di attivazione, mentre i punti rossi e blu

rappresentano le corrispondenti classi prodotte dalla funzione di soglia. In questo esempio, le osservazioni appartenenti alla regione decisionale “rossa” vengono assegnate alla classe $0$, mentre quelle appartenenti alla regione decisionale “blu” vengono assegnate alla classe $1$:

La Funzione di Costo

Adaline utilizza la stessa funzione di costo che abbiamo già incontrato nella regressione lineare: la Mean Squared Error (MSE), o errore quadratico medio. Durante il training, la MSE misura la differenza quadratica media tra i valori target $y^{(i)}$ e gli output continui $\text{out}^{(i)}$ prodotti dalla funzione di attivazione. Per Adaline, invece di indicare l’output continuo con $\hat{y}^{(i)}$, utilizziamo il termine $\text{out}^{(i)}$, in modo da distinguerlo dalla previsione di classe $\hat{y}^{(i)}$ prodotta successivamente dalla funzione di soglia:

La funzione di costo viene quindi calcolata sull’output continuo del modello, prima dell’applicazione della funzione di soglia.

L’Algoritmo di Training

Anche per il training, Adaline utilizza lo stesso algoritmo che abbiamo già incontrato nella regressione lineare: la Discesa del Gradiente (Gradient Descent, GD). Dopo aver inizializzato i parametri $\mathbf{w}$ e $b$, a ogni iterazione del Gradient Descent viene calcolato il gradiente della funzione di costo rispetto ai pesi e al bias:

dove $\mathbf{g}_w$ è il vettore delle derivate parziali rispetto ai pesi $w_1,\ldots,w_n$, mentre $g_b$ è la derivata parziale rispetto al bias. I parametri vengono quindi aggiornati nella direzione opposta al gradiente:

dove $\eta$ è il learning rate, che determina l’ampiezza degli aggiornamenti effettuati a ogni iterazione. Ripetendo questo procedimento, il Gradient Descent modifica progressivamente $\mathbf{w}$ e $b$ con l’obiettivo di ridurre la MSE e avvicinarsi al minimo della funzione di costo.

Implementazione del Modello

Vediamo ora com’è possibile implementare il modello Adaline in Python. Il codice seguente, rispetto agli esempi precedenti, utilizza il paradigma della programmazione orientata agli oggetti (OOP). Andremo a creare la classe Python AdalineGD che implementi il comportamento di Adaline, ed useremo una sua istanza per testarne la capacità di classificazione. Questo moderato aumento della complessità nella scrittura del codice porta alcuni vantaggi. In particolare:

• OOP consente la creazione di codice modulare, in cui i diversi modelli ML possono essere incapsulati in classi, le quali possono essere riutilizzate in progetti diversi. Questo riduce la ridondanza del codice e i relativi tempi di sviluppo. L’incapsulamento del codice garantisce inoltre che lo stato interno di un oggetto sia “nascosto” al codice esterno alla classe, rendendo il codice più robusto e più facile da mantenere.

• è possibile definire modelli con la stessa interfaccia, rendendo più facile cambiare un modello con un altro, tenendo costante il codice di training e valutazione delle metriche di performance. Questo fatto ci tornerà utile quando cominceremo a confrontare alcuni dei nostri modelli “giocattolo” con quelli messi a disposizione dalla libreria Scikit-Learn.

• possiamo identificare i metodi privati dando loro un nome che inizi con doppio carattere underscore __, come ad esempio __gradient, oppure __loss. L’interfaccia pubblica utilizzabile dal codice client sarà quindi definita da tutti gli altri metodi, come ad esempio: fit, predict, predict_regression.

Il Costruttore della Classe

Il costruttore della classe, definito dal metodo __init__, definisce lo stato dell’istanza di classe, e consente di settare i seguenti parametri:

• eta: il tasso di apprendimento, o “learning rate”, utilizzato nella fase di training, che controlla la grandezza dei “passi” compiuti dalla discesa del gradiente verso il minimo della funzione di costo. La scelta del giusto valore di “eta” è cruciale, in quanto esso controlla quanto i pesi del modello vengano aggiustati rispetto al gradiente della funzione di costo. Un valore di “eta” troppo basso può rallentare la convergenza³ del modello verso la soluzione ottimale, mentre un valore troppo alto può muovere il processo di training lontano dal minimo della funzione di costo.

• epochs: il numero di iterazioni usate dalla funzione di training. Avendo scelto un valore corretto per eta, più è alto il valore di epochs, migliori saranno le metriche di prestazione del modello, a scapito di un tempo di training più lungo.

import numpy as np

class AdalineGD:
    """ADAptive LInear NEuron classifier"""

    def __init__(self, eta=0.01, epochs=50):
        """Initialize this object."""
        self.losses = None
        self.bias = None
        self.weights = None
        self.eta = eta
        self.epochs = epochs
        self.random_state = random_state

Il Metodo di Training

Il metodo fit⁴ implementa l’algoritmo di training del modello, usando la discesa del gradiente. Il codice è uguale a quello del metodo train usato dalla regressione lineare multipla. Il nome del metodo è stato cambiato da train a fit per avere un’interfaccia OOP simile a quella dei modelli di classificazione proposti da Scikit-Learn:

    def fit(self, X, y):
        """Fit training data. That is, compute the best values for weights and bias parameters
        that minimize the Loss Function associated with this model."""

        # clone the label data and reshape it as a 2D array
        y = np.copy(y).reshape(-1, 1)

        # initialize weights with a normal distribution, and bias with 0
        rgen = np.random.default_rng(seed=self.random_state)
        self.weights = rgen.normal(loc=0.0, scale=0.01, size=(X.shape[1], 1))
        self.bias = np.float64(0.)
        self.losses = []

        # for each training epoch...
        for i in range(self.epochs):
            # compute the gradient vectors:
            #
            #   ∂L/∂w = 2/m * sum(i=1 to m) { x^(i) * (out^(i) - y^(i)) }
            #         = 2/m * (X.T @ (out - y))
            #
            #   ∂L/∂b = 2/m * sum(i=1 to m) { out^(i) - y^(i) }
            #         = 2/m * (1^T)(out - y)
            #
            z = self.__net_input(X)                    # shape: (n_examples, 1)
            out = self.__activation(z)                 # shape: (n_examples, 1)
            error = out - y                            # shape: (n_examples, 1)
            grad_w = 2.0 * (X.T @ error) / X.shape[0]  # shape: (n_features, 1)
            grad_b = 2.0 * np.mean(error)              # float

            # calculate the steps in the direction of the w-axis and b-axis axis
            # used to reach the flat point on the loss curve for this iteration
            step_w = self.eta * grad_w                 # shape: (n_features, 1)
            step_b = self.eta * grad_b                 # float

            # by convention, the gradient at a certain point is an arrow that points
            # directly uphill from that point. Because we need to go into the opposite direction,
            # we have to subtract "step_w" from the current value of "w", and do the same for "b"
            self.weights -= step_w                     # shape: (n_features, 1)
            self.bias -= step_b                        # bias: float

            # compute the loss for the current iteration
            loss = np.average(error ** 2)
            self.losses.append(loss)

        return self

Confrontando questo codice con quello del modello della regressione lineare multipla, troviamo una differenza nel calcolo dei gradienti e del valore di costo. In Adaline, l’errore per la singola osservazione viene calcolato come la differenza tra l’uscita della funzione di attivazione $\sigma$, e la label $y^{(i)}$, ovvero:

# Adaline:
z = self.__net_input(X)     # weighted sum
out = self.__activation(z)  # activation function
error = out - y             # error

# Linear Regression:
y_hat = predict(X, w, b)    # weighted sum
error = y_hat - y           # error

In pratica, visto che la funzione di attivazione $\sigma$ è una funzione di identità, e quindi $\sigma\left(z^{(i)}\right) = z^{(i)}$, il calcolo dell’errore è equivalente. Il codice completo è indicato di seguito:

    def fit(self, X, y):
        # ...

        # for each training epoch...
        for i in range(self.epochs):
            # compute the gradient vectors:
            #
            #   ∂L/∂w = 2/m * sum(i=1 to m) { x^(i) * (out^(i) - y^(i)) }
            #         = 2/m * (X.T @ (out - y))
            #
            #   ∂L/∂b = 2/m * sum(i=1 to m) { out^(i) - y^(i) }
            #         = 2/m * (1^T)(out - y)
            #
            z = self.__net_input(X)                    # shape: (n_examples, 1)
            out = self.__activation(z)                 # shape: (n_examples, 1)
            error = out - y                            # shape: (n_examples, 1)
            grad_w = 2.0 * (X.T @ error) / X.shape[0]  # shape: (n_features, 1)
            grad_b = 2.0 * np.mean(error)              # float

            # ...

            # compute the loss for the current iteration
            loss = np.average(error ** 2)
            self.losses.append(loss)

        return self

I Metodi di Predizione

Adaline fonisce due metodi di predizione: predict_regression per predirre numeri reali continui, e predict per eseguire predizioni categoriche.

Il metodo predict_regression calcola la somma pesata $z^{(i)}$, che passa in ingresso alla funzione di attivazione $\sigma$, che restituisce il valore di uscita del neurone:

    def predict_regression(self, X):
        """Predict the regression value for the input data."""
        z = self.__net_input(X)
        out = self.__activation(z)
        return out

Il metodo predict calcola il valore di uscita del neurone tramite predict_regression, e poi passa tale valore alla funzione di soglia __threshold, che lo trasforma in un valore categorico: classe “$0$”, o classe “$1$”:

    def predict(self, X):
        """Predict the class label for the input data."""
        out = self.predict_regression(X)
        y_hat = self.__threshold(out)
        return y_hat

I restanti metodi privati sono elencati di seguito. Da notare che, in Adaline, il metodo __activation implementa una funzione d’identità, e quindi non fa nulla di utile. Teniamo comunque la definizione di tale metodo come “placeholder”, in quanto esso verrà reimplementato da altri modelli di neurone, che applicheranno al suo valore di ingresso una data funzione di trasformazione non lineare:

    def __net_input(self, X):
        """Calculate the weighted sum plus the bias."""
        return X @ self.weights + self.bias

    def __activation(self, X):
        """Apply an Identity Function to the input data and return it."""
        return X

    def __threshold(self, out):
        """Transform a regression value into a classification value,
        taking the continuous value returned by the activation function
        and converting it into a categorical value, used as a classification prediction."""
        return np.where(out >= 0.5, 1, 0)