Reti neurali: dai perceptron al deep learning

Il 10 marzo 2016, nella seconda partita di una serie di cinque incontri a Seoul, una macchina chiamata AlphaGo piazzò una pietra nera sulla quinta linea della scacchiera. La mossa era così strana che i commentatori umani pensarono fosse un errore. Un professionista disse ad alta voce che un principiante sarebbe stato rimproverato per averla giocata. Lee Sedol — un campione del mondo per 18 volte al gioco del Go — si alzò e lasciò la sala per riprendersi.

Non era un errore. Cinquanta mosse dopo, quella pietra — ora famosa come «Mossa 37» — era il cardine su cui girava l'intera partita. AlphaGo vinse. Lee Sedol, considerato uno dei più grandi giocatori vivi, perse la serie 4–1. Ed ecco la parte che conta: nessun umano ha insegnato quella mossa ad AlphaGo. Non era in nessun libro di testo. La macchina l'aveva scoperta da sola, giocando milioni di partite contro se stessa e aggiustando miliardi di piccoli numeri interni finché non emerse un pattern che nessuna persona aveva mai visto.

Il Go ha più posizioni possibili sulla scacchiera di quanti atomi ci siano nell'universo osservabile. Non puoi affrontarlo con la forza bruta. Non puoi scriverne le regole. L'unico modo per giocarlo a un livello sovrumano è impararlo — e la cosa che faceva l'apprendimento era una rete neurale: una pila di semplici unità matematiche che, dati abbastanza dati e abbastanza aggiustamenti, può trovare struttura che nessun umano riesce ad articolare completamente.

Quello stesso meccanismo — le stesse somme pesate, lo stesso ciclo di addestramento, le stesse spinte del gradiente — è ciò che alimenta il modello linguistico con cui parli, il sistema che segnala le transazioni con carta fraudolente, e i modelli che i fondi quantitativi ora puntano sui mercati finanziari. Questa lezione riguarda ciò che accade realmente dentro quella scatola.

Ogni rete neurale — da un semplice filtro anti-spam a GPT ad AlphaGo — discende da un'unica idea: il perceptron, inventato da Frank Rosenblatt nel 1958. È un modello matematico vagamente inspirato a un neurone biologico. Un vero neurone riceve segnali elettrici attraverso i suoi dendriti, li accumula nel corpo cellulare, e invia un segnale lungo il suo assone solo se l'input combinato supera una soglia. Il perceptron fa la stessa cosa, solo con numeri invece che voltaggio.

Un perceptron prende un vettore di input x, moltiplica ogni input per un peso (weight) w appreso, somma i prodotti, aggiunge un termine di bias b che sposta la soglia, e passa il risultato attraverso una funzione di attivazione. Se il risultato supera la soglia, il neurone «si attiva»; altrimenti resta silenzioso. Il tutto è un'espressione compatta: output = f(w·x + b).

Pensa ai pesi come a manopole del volume. Ogni input arriva con un certo volume, e il peso decide quanto quell'input conta per questo particolare neurone. Un neurone che imparasse a individuare un trade fraudolento potrebbe alzare il peso su «dimensione della transazione rispetto alla storia dell'account» e abbassare il peso su «ora del giorno». L'apprendimento, alla base, non è nulla di più affascinante del girare quelle manopole sulle impostazioni giuste.

Un singolo perceptron ha un limite rigido: può separare i dati solo con una linea retta (o, in dimensioni superiori, un iperpiano piatto). Può rispondere a «questo punto è sopra o sotto la linea?» ma non a «questo punto è dentro la regione curva?». L'esempio storico è il problema XOR — un pattern che un singolo perceptron non può apprendere, dimostrabilmente, una limitazione che contribuì a congelare i finanziamenti all'AI per anni negli anni '70. La via di fuga è quasi assurdamente semplice col beneficio del senno di poi: impilare molti perceptron in livelli e inserire un'attivazione non lineare tra di essi. Fai questo, e la rete risultante può piegare, ripiegare e scolpire lo spazio in forme arbitrariamente complesse.

Un neurone è una manopola. Una rete utile ne ha migliaia, organizzate in livelli (layer) che passano informazione in avanti come una catena di persone che si passano un secchio.

• Livello di input — dove entrano le tue feature grezze: pixel di un'immagine, parole di una frase, oppure per un modello di trading, cose come prezzo, volume, volatilità e squilibrio dell'order book.
• Livelli hidden — i livelli intermedi, dove avviene il lavoro vero. Ogni livello prende gli output del precedente e li ricombina in feature nuove, più astratte.
• Livello di output — la risposta finale: una probabilità, una previsione di prezzo, un'etichetta di classe.

La parola «deep» in deep learning significa semplicemente molti livelli hidden. E la profondità ti compra qualcosa di specifico: una gerarchia di feature. In una rete per immagini, il primo livello individua i contorni, il successivo assembla i contorni in forme, il successivo assembla le forme in oggetti. Nessuno ha programmato un «rilevatore di contorni» o un «rilevatore di occhi» — questi concetti emergono dall'addestramento. La rete inventa il proprio vocabolario intermedio.

C'è un bel risultato teorico qui, il teorema di approssimazione universale: una rete con anche un solo livello hidden, dati abbastanza neuroni, può approssimare qualsiasi funzione continua con accuratezza arbitraria. In altre parole, la rete giusta può in principio rappresentare qualsiasi pattern esistente nei tuoi dati. Il problema — e non è piccolo — è che «in principio» sta facendo un lavoro pesante. Il teorema promette che tale rete esiste; non dice nulla sul fatto che tu possa trovarla, che tu abbia abbastanza dati per determinarla, o che il pattern che stai cercando sia addirittura reale. Nei domini a basso segnale come la finanza, quel divario tra «rappresentabile» e «apprendibile» è esattamente dove la maggior parte dei modelli va a morire.

Ecco un fatto che sorprende le persone: senza funzioni di attivazione, la profondità non vale nulla. Se ogni livello fosse una semplice somma pesata, allora impilare dieci livelli sarebbe matematicamente identico a un unico livello — una catena di operazioni lineari collassa in un'unica operazione lineare. Avresti spesso una fortuna in calcolo per costruire una linea retta glorificata. Le funzioni di attivazione sono la curvatura non lineare inserita tra i livelli che permette alla rete di piegarsi, e piegarsi è ciò che la rende potente.

Le attivazioni che ogni praticante dovrebbe conoscere:

• Sigmoid — σ(x) = 1/(1+e⁻ˣ). Schiaccia qualsiasi input in (0, 1), che si legge naturalmente come una probabilità. Ottima per un output binario, ma una scelta scarsa dentro i livelli hidden: per input grandi positivi o negativi la curva si appiattisce, il suo gradiente va quasi a zero, e l'apprendimento si arresta — il problema del vanishing gradient.
• Tanh — output in (−1, 1) e centrata su zero, il che aiuta l'ottimizzazione. Satura ancora agli estremi, ma meno bruscamente della sigmoid.
• ReLU — f(x) = max(0, x). Lo standard moderno per i livelli hidden. È ridicolamente semplice, economica da calcolare, e mantiene un gradiente sano per tutti gli input positivi. Il suo difetto è la «dying ReLU»: un neurone spinto a produrre sempre zero può diventare permanentemente inerte.
• Leaky ReLU — f(x) = max(0.01x, x). Lascia passare un piccolo filo di gradiente per i valori negativi, il che impedisce ai neuroni di morire.
• GELU — un cugino fluido e probabilistico della ReLU che è lo standard dentro i transformer come BERT e GPT.

Finora abbiamo una rete piena di pesi. Ma da dove vengono i valori dei pesi giusti? Nessuno li digita — sono milioni. Vengono scoperti attraverso un ciclo di feedback che, alla base, è tentativi ed errori organizzati con il calcolo infinitesimale a fare la contabilità.

Il primo passo è il forward pass: dai in pasto un esempio, lascia che scorra attraverso i livelli, e leggi una predizione. Il secondo passo è misurare quanto sbagliata era quella predizione usando una funzione di loss. Per predire un numero (un prezzo), il Mean Squared Error media il divario al quadrato tra predizione e verità. Per la classification, la cross-entropy misura quanto lontane sono le probabilità predette dalla risposta corretta. Una loss alta significa «molto sbagliato»; l'intero obiettivo dell'addestramento è spingere quel numero verso il basso.

Il terzo passo è la parte intelligente: la backpropagation. Usando la regola della catena del calcolo infinitesimale, l'algoritmo lavora all'indietro dalla loss attraverso ogni livello e calcola, per ogni singolo peso, un gradiente — la risposta a «se spingo leggermente questo peso verso l'alto, l'errore sale o scende, e quanto?». Questo è il trucco che ha scongelato l'inverno dell'AI. La backprop, resa popolare negli anni '80, ha reso possibile assegnare la colpa attraverso milioni di pesi in modo efficiente invece che indovinare.

Il quarto passo è il gradient descent: sposta ogni peso di un piccolo passo nella direzione che riduce la loss, usando la regola w = w − α × ∂L/∂w. Immagina di stare su un pendio nella nebbia cercando di raggiungere il fondovalle; non riesci a vedere il fondo, ma senti sotto i piedi quale direzione scende, quindi fai un passo in quella direzione e ripeti. Il learning rate α è la lunghezza del tuo passo, ed è probabilmente la manopola più importante di tutto il sistema. Troppo grande e superi il fondovalle rimbalzando avanti e indietro all'infinito; troppo piccolo e avanzi lentamente per l'eternità o resti bloccato in un fossato a metà strada.

Due affinamenti che incontrerai immediatamente. I mini-batch: invece di aggiornare dopo ogni singolo esempio (rumoroso) o solo dopo l'intero dataset (lento), aggiorni dopo un piccolo batch — tipicamente da 32 a 256 esempi — che è stabile, adatto alle GPU, e il punto ottimale in pratica. E Adam: un optimizer più intelligente che dà a ogni peso il proprio passo adattivo e aggiunge momentum per smussare i gradienti rumorosi. Adam è il punto di partenza sensato per quasi qualsiasi progetto — anche se in finanza, con il suo basso rapporto segnale/rumore, dovrai comunque regolare a mano il learning rate, il weight decay e il punto di arresto.

Ecco lo schema di fallimento che distrugge più modelli finanziari di qualsiasi altro. Una rete neurale è un adattatore di funzioni così flessibile che, data l'occasione, memorizzerà i tuoi dati di training in toto — incluso tutto il rumore casuale, i colpi di fortuna isolati e le coincidenze che non si ripeteranno mai. Ottiene punteggi meravigliosi sui dati che ha visto e crolla nel momento in cui incontra qualcosa di nuovo. Questo è l'overfitting, e nei mercati — dove il vero segnale è debole e il rumore è assordante — è l'esito predefinito, non l'eccezione. Gli strumenti che lo combattono si chiamano regularization.

Il dropout è il più popolare. Durante ogni passo di training, ogni neurone ha una probabilità p (spesso 0.2–0.5) di essere temporaneamente spento. Costretta a funzionare anche quando compagni di squadra casuali continuano a svanire, la rete impara a distribuire la sua conoscenza tra molti neuroni piuttosto che puntare tutto su pochi fragili — un effetto ensemble incorporato in un singolo modello. Al momento della predizione tutti i neuroni si riaccendono, riscalati appropriatamente.

Le penalità L1 e L2 aggiungono una tassa sui pesi grandi alla loss. La L2 (weight decay) scoraggia qualsiasi singolo peso dal diventare troppo grande, distribuendo l'influenza in modo uniforme. La L1 è più netta: spinge attivamente i pesi inutili fino a esattamente zero, eseguendo una selezione automatica delle feature. In un dataset finanziario dove la maggior parte delle tue cento feature è rumore, la L1 può silenziosamente trovare la manciata che porta effettivamente segnale.

La batch normalization riscala gli output di ogni livello a una media e varianza stabili, il che stabilizza il training e permette di usare learning rate più alti. L'early stopping è la protezione più semplice e affidabile di tutte: osserva l'errore su un set di validazione tenuto da parte, e nell'istante in cui inizia a salire mentre l'errore di training continua a scendere, fermati — quell'incrocio è il momento esatto in cui la rete passa dall'imparare pattern al memorizzare rumore.

Le reti feedforward semplici trattano ogni input come un sacco non strutturato di numeri. Ma molti dati reali hanno struttura — un'immagine ha una disposizione spaziale, una serie di prezzi ha un ordine temporale — e due architetture specializzate sfruttano quella struttura direttamente.

Le reti neurali convoluzionali (CNN) sono state costruite per le immagini. Invece di connettere ogni pixel a ogni neurone, una CNN fa scorrere piccoli filtri attraverso l'input, cercando pattern locali — un contorno qui, una texture là — e riutilizzando lo stesso filtro ovunque. I primi livelli catturano contorni; i livelli più profondi li assemblano in forme e oggetti. In finanza, i ricercatori hanno puntato le CNN su:

• Immagini di grafici candlestick — riformulando la lettura dei grafici come un compito di riconoscimento visivo dei pattern.
• Heatmap dell'order book — individuando squilibri di offerta/domanda in snapshot della profondità di mercato.
• Convoluzioni 1D su sequenze di prezzo grezze — imparando motivi temporali brevi nel modo in cui una CNN per immagini impara motivi spaziali.

Le reti neurali recurrent (RNN) sono costruite per le sequenze. Elaborano un passo temporale alla volta portando avanti uno stato hidden — una memoria in corso — da ogni passo al successivo. In teoria questo le rende ideali per le serie temporali. In pratica, le RNN pure sono paralizzate dal problema del vanishing gradient su sequenze lunghe: il segnale di molti passi indietro si restringe verso zero nel percorso a ritroso, quindi la rete semplicemente dimentica il passato distante.

Le reti Long Short-Term Memory (LSTM) risolvono questo con un piccolo insieme di gate apprendibili — forget, input e output — che decidono a ogni passo cosa cancellare dalla memoria, cosa scrivervi e cosa leggerne. Quel meccanismo di gating permette a un LSTM di trattenere informazione rilevante su centinaia di passi, ed è il motivo per cui è diventato un cavallo di battaglia per modellare le serie temporali finanziarie dove un evento di ieri muove ancora il prezzo di oggi.

import torch.nn as nn

class PricePredictor(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers):
        super().__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim,
                            num_layers, batch_first=True,
                            dropout=0.2)
        self.fc = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

Su una piattaforma come GaiaEx, dove i feed WebSocket trasmettono in streaming dati continui di prezzo e order book, un LSTM può ingerire quella sequenza naturalmente. Detto questo, il campo è andato in gran parte avanti: i transformer — l'architettura dietro i moderni modelli linguistici — ora eguagliano o battono le LSTM su molti compiti di sequenza usando l'«attention» per guardare tutti i passi temporali in una volta invece di attraversarli uno per uno.

Le reti neurali sono cercatori di pattern spettacolari. Ma un'educazione onesta significa nominare dove si rompono — e nel trading, si rompono in modi costosi.

• Trovano pattern anche quando non esistono. Dai a una rete profonda del rumore e lo adatterà con sicurezza. I mercati sono in gran parte rumore, quindi l'onere della prova è tuo per mostrare che un pattern è reale e persistente — non solo presente nei dati dell'anno scorso.
• Sono scatole nere. Un modello può essere accurato e comunque incapace di dirti perché. Quando improvvisamente perde denaro, spesso non c'è una spiegazione netta né una correzione ovvia. Per il capitale a rischio, «non so perché ha fatto questo» è una responsabilità seria.
• Sono affamate e fragili. Il deep learning brilla con milioni di esempi puliti. La storia finanziaria è breve, non stazionaria e rumorosa — il regime che ha addestrato il tuo modello potrebbe semplicemente smettere di esistere, un problema chiamato distribution shift.
• Non battono gratis i modelli più semplici. Sui dati tabulari e basati su feature comuni in finanza, gli alberi gradient-boosted come XGBoost sovraperformano frequentemente le reti neurali, addestrandosi più velocemente e risultando più facili da interpretare. La complessità è un costo, non una virtù.
• Possono essere attaccate. Piccole, deliberate perturbazioni a un input possono ribaltare l'output di una rete — un esempio avversariale — cosa che conta ovunque un avversario possa modellare ciò che il tuo modello vede.

Addestrare reti neurali è pesante in termini di aritmetica — prevalentemente moltiplicazioni di matrici — e l'hardware su cui lo esegui cambia la tua velocità di iterazione da «durante la notte» a «durante il caffè».

Le GPU sono lo standard. I loro migliaia di core eseguono tutti la stessa operazione su dati diversi contemporaneamente, che è esattamente la forma della matematica delle reti neurali. Un modello che striscia per 8 ore su una CPU può finire in 15 minuti su una GPU moderna. NVIDIA domina: le schede consumer (una GPU di classe RTX) vanno bene per imparare, mentre le schede da data center (A100, H100) e le istanze cloud gestiscono il training a scala di produzione. Le TPU, i chip custom di Google per la matematica tensoriale, brillano su modelli molto grandi tramite Google Cloud, ma le GPU restano lo standard pratico per la maggior parte dei praticanti grazie a un supporto software più ampio.

Non hai bisogno di comprare nulla per iniziare. Google Colab distribuisce tempo GPU gratuito che basta ampiamente per imparare e prototipare; noleggia GPU cloud a richiesta man mano che i tuoi modelli crescono; compra hardware dedicato solo quando ti stai addestrando quotidianamente e la bolletta cloud lo giustifica.

Un percorso di apprendimento sensato da qui:

• Inizia con una semplice rete feedforward su alcune feature progettate — veloce da addestrare, facile da debuggare, e una baseline onesta.
• Prova una CNN 1D su sequenze di prezzo grezze e confrontala testa a testa con quella baseline.
• Costruisci un LSTM che consuma sequenze di dati candlestick dall'API di GaiaEx.
• Studia l'attention e i transformer — sempre più l'architettura di scelta per le sequenze.
• Sopra ogni cosa, confronta sempre il tuo modello profondo con una baseline di gradient boosting come XGBoost. Se la rete neurale non riesce a battere il modello più semplice out-of-sample sui tuoi dati finanziari tabulari, spedisci il modello più semplice e vai avanti.

Lo stesso ciclo che ha trovato la Mossa 37 — predire, misurare l'errore, spingere i pesi, ripetere — è il ciclo che gira dentro ogni sistema in questa lista. Capisci quel ciclo e capisci il deep learning; il resto è architettura e ingegneria costruite sopra di esso.