Le Reti Multistrato

Reti Neurali Multistrato: Oltre la Linea Retta

Avete presente il Percettrone di Rosenblatt? Era bravo a imparare, ma aveva un tallone d'Achille: poteva tracciare solo linee rette per separare le classi. Questo andava bene per problemi semplici, ma falliva miseramente con configurazioni più complesse come il famoso problema XOR o dati disposti a cerchi concentrici.

Ecco che entrano in scena le Reti Neurali Multistrato (Multilayer Perceptrons, MLP). L'idea geniale è stata quella di non fermarsi a un singolo strato di calcolo, ma di inserire uno o più strati nascosti (hidden layers) tra lo strato di input e quello di output. 

Immagina questi strati nascosti come team di specialisti intermedi:

1. Input: La rete riceve i dati iniziali (nel simulatore, le coordinate x1​,x2​).

2. Primo Strato Nascosto: Ogni neurone in questo strato riceve gli input e, proprio come un Percettrone, impara a tracciare una sua linea di separazione (le linee ciano nel simulatore). Ma, e qui sta il punto chiave, non produce un semplice 0 o 1. Grazie a funzioni di attivazione non lineari (come la Sigmoide usata qui), produce un output "sfumato" (tra 0 e 1), indicando quanto è "sicuro" della sua decisione o quanto è "attivo".

3. Strati Successivi (Output): I neuroni dello strato successivo (nel nostro caso, direttamente lo strato di output) non vedono gli input originali, ma ricevono come input gli output "sfumati" dei neuroni dello strato nascosto precedente.

4. Combinazione Magica: Lo strato di output, a sua volta dotato di pesi, bias e attivazione non lineare, impara a combinare le semplici separazioni lineari (le linee ciano) apprese dallo strato nascosto. È questa combinazione non lineare di separazioni lineari che permette alla rete di creare confini di decisione complessi e curvi (la superficie colorata nel simulatore), capaci finalmente di risolvere problemi come XOR o separare i cerchi!

L'apprendimento avviene tramite un algoritmo chiamato Backpropagation (retropropagazione dell'errore), che calcola l'errore all'output e lo "propaga" all'indietro attraverso la rete, aggiornando i pesi e i bias di tutte le connessioni (anche quelle verso gli strati nascosti) in modo da minimizzare l'errore complessivo.Rumelhart fu il principale ideatore dell'applicazione della backpropagation alle reti neurali. Geoffrey Hinton stesso ha riconosciuto in diverse interviste che "David Rumelhart era un brillante psicologo che riuscì a capire come estendere la regola delta, normalmente usata per addestrare reti neurali in cui gli input sono direttamente collegati agli output". 

Per chi vuole approfondire

Gli strati nascosti (hidden layers) superano i limiti del percettrone lineare agendo come intermediari che frammentano un problema complesso in sottoproblemi più semplici, permettendo alla rete di tracciare confini di decisione curvi e complessi anziché limitarsi a una singola linea retta.

Ecco i meccanismi chiave attraverso cui avviene questo superamento strutturale:

1. Moltiplicazione delle Linee di Separazione

Mentre il percettrone classico può tracciare solo un'unica linea retta per separare i dati (fallendo in problemi come lo XOR o i cerchi concentrici), ogni neurone presente in uno strato nascosto impara a tracciare la propria linea di separazione.

• Immagina questi neuroni come un "team di specialisti": ognuno analizza i dati di input e crea una distinzione lineare specifica.

• Nel simulatore descritto, queste sono visualizzate come "linee ciano" individuali.

2. L'Introduzione della Non-Linearità

Il vero salto di qualità avviene grazie alle funzioni di attivazione non lineari (come la Sigmoide) applicate negli strati nascosti.

• A differenza del percettrone che emette un output binario rigido (0 o 1), i neuroni nascosti producono un output "sfumato" (un valore continuo tra 0 e 1).

• Questo valore indica quanto il neurone è "sicuro" o "attivo" rispetto alla sua decisione, fornendo una ricchezza di informazioni che un semplice sistema binario non possiede.

3. La "Combinazione Magica"

Lo strato di output non osserva più i dati grezzi originali, ma riceve come input le decisioni sfumate dei neuroni nascosti. La rete supera il limite strutturale combinando matematicamente le diverse linee rette apprese dallo strato precedente.

• Questa combinazione non lineare trasforma le semplici separazioni rette in una superficie complessa e curva.

• È questa capacità di sintesi che permette finalmente di risolvere configurazioni topologiche difficili, come separare dati disposti a cerchio o risolvere la logica XOR.

Il Potere Teorico: Approssimazione Universale

L'aggiunta di strati nascosti conferisce alla rete un potere formale descritto dal Teorema di Approssimazione Universale. Questo teorema stabilisce che una rete con un solo strato nascosto (se dotato di abbastanza neuroni e attivazione non lineare) può approssimare qualsiasi funzione continua. Ciò significa che la struttura non è più vincolata alla linearità: qualsiasi relazione complessa tra input e output può, in teoria, essere imparata e rappresentata dalla rete.

Per rendere possibile tutto questo, l'algoritmo di Backpropagation (retropropagazione) è essenziale: esso calcola l'errore finale e lo propaga all'indietro, aggiornando i pesi anche delle connessioni profonde che non sono direttamente collegate all'output, permettendo ai neuroni nascosti di specializzarsi.

• La Backpropagation (o retropropagazione dell'errore) è il meccanismo matematico che permette alla rete di imparare dai propri sbagli. Funziona calcolando l'errore finale della rete e "propagandolo" all'indietro, dallo strato di output fino all'input, per correggere progressivamente ogni connessione.

• Ecco i passaggi fondamentali di come questo algoritmo aggiorna i pesi:

1. Calcolo e Propagazione dell'Errore

• Il processo inizia alla fine della rete. L'algoritmo confronta l'output prodotto dalla rete con il risultato desiderato e calcola l'errore complessivo.

• • Invece di fermarsi lì, l'algoritmo diffonde questo errore a ritroso attraverso la rete.

• • Il suo obiettivo è aggiornare i pesi (w) e i bias (b) di tutte le connessioni, inclusi quelli degli strati nascosti che non sono direttamente collegati all'uscita.

2. L'Innovazione di Rumelhart (Oltre la Regola Delta)

• La grande sfida storica era capire come aggiornare i pesi degli strati "invisibili" (nascosti). David Rumelhart, uno psicologo cognitivo, ha risolto questo problema estendendo la "regola delta".

• • La regola classica funzionava solo per gli input collegati direttamente all'output.

• • La Backpropagation permette di attribuire la "colpa" dell'errore anche ai neuroni interni, calcolando quanto ciascuno di essi ha contribuito allo sbaglio finale e aggiustando i loro pesi di conseguenza.

3. La Velocità di Aggiornamento (Learning Rate)

• L'aggiornamento dei pesi non avviene in modo casuale, ma è regolato da un parametro chiamato Tasso di Apprendimento (Learning Rate):

• • Questo parametro decide la "velocità" o l'intensità con cui i pesi vengono modificati ad ogni errore rilevato.

• • Un tasso troppo basso rende l'apprendimento lentissimo; un tasso troppo alto può far "saltare" la rete oltre la soluzione ottimale, rendendo il grafico dell'errore instabile.

Come osservarlo nel simulatore

Nel contesto pratico del simulatore descritto nelle fonti, la Backpropagation si manifesta visivamente:

• Attivando la modalità passo-passo ("Un Passo"), puoi vedere i valori numerici dei pesi (w) vicino alle linee e dei bias (b) sotto i neuroni cambiare fisicamente dopo ogni errore.

• L'obiettivo finale di questi continui aggiornamenti è minimizzare l'errore quadratico medio (visibile nel grafico dell'errore), permettendo alla rete di tracciare confini sempre più precisi

Un pò più di dettaglio

 Per spiegare la Backpropagation (retropropagazione) in modo numerico ma intuitivo, useremo l'analogia di una "Squadra di Amplificazione Audio".

Immagina una rete neurale molto semplice con tre membri del team (neuroni) in fila:

1. Input (Microfono)

2. Hidden (Tecnico Intermedio)

3. Output (Altoparlante Finale)

Tra di loro ci sono delle manopole del volume (i Pesi, w). L'obiettivo è ottenere un volume finale perfetto di 0.8.

--------------------------------------------------------------------------------

1. La Configurazione (Forward Pass)

Facciamo un tentativo di previsione con valori numerici reali.

• Il Segnale (Input): Entra un valore di 1.0.

• Manopola A (w

in

​

 - verso lo strato nascosto): È impostata su 0.6.

• Manopola B (w

out

​

 - verso l'output): È impostata su 0.5.

• Tasso di Apprendimento (Learning Rate): 0.1 (quanto velocemente giriamo le manopole).

Il Viaggio del Segnale:

1. Il segnale 1.0 passa per la Manopola A (0.6). Il "Tecnico Intermedio" riceve: 1.0×0.6=0.6.

2. Questo valore 0.6 passa per la Manopola B (0.5). L'Altoparlante emette: 0.6×0.5=0.3.

Il Risultato: La rete ha prodotto 0.3. L'Obiettivo: Volevamo 0.8. L'Errore: 0.8−0.3=0.5 (Il volume è troppo basso!).

--------------------------------------------------------------------------------

2. La Backpropagation (Assegnare la Colpa)

Qui avviene la magia descritta da Rumelhart: dobbiamo capire di chi è la colpa e girare le manopole nella direzione opposta all'errore. L'errore fluisce "all'indietro".

Passo A: Aggiornare la Manopola B (Output)

L'Altoparlante guarda indietro al Tecnico Intermedio e dice: "Io ho ricevuto da te un segnale di 0.6, e con la mia manopola a 0.5 il risultato è stato troppo basso. Devo alzare la mia manopola!"

• La Logica: Poiché l'errore è positivo (manca volume) e l'input ricevuto era positivo, dobbiamo aumentare il peso.

• Il Calcolo Semplificato:

NuovoPeso=PesoVecchio+(LearningRate×Errore×InputRicevuto)

Nuovow

out

​

=0.5+(0.1×0.5×0.6)

Nuovow

out

​

=0.5+0.03=0.53

La manopola finale è stata corretta. Ma non basta.

Passo B: Aggiornare la Manopola A (Strato Nascosto)

Questa è la parte difficile che la "Regola Delta" classica non poteva risolvere. Il Tecnico Intermedio dice: "Ehi, non guardare solo me! Io ho solo passato quello che mi è arrivato dal Microfono (Input). Se il volume finale è basso, forse anche la prima manopola era troppo bassa!"

L'algoritmo propaga l'errore indietro attraverso la connessione esistente.

• Calcolo della Colpa Nascosta: Quanto ha contribuito l'errore finale al nodo nascosto? Dipende da quanto era alta la manopola B.

ErroreNascosto = ErroreFinale × PesoB(vecchio)

ErroreNascosto=0.5×0.5 = 0.25

(Nota: Matematicamente, questo passaggio è cruciale: l'errore viene "scalato" dai pesi che attraversa tornando indietro).

• Aggiornamento Manopola A: Ora usiamo questo "errore nascosto" per aggiornare la prima manopola.

Nuovo win

​

=0.6+(0.1×0.25×1.0)

Nuovo win

​

=0.6+0.025=0.625

--------------------------------------------------------------------------------

3. Risultato del Prossimo Tentativo

Se ora riproviamo con i nuovi pesi (win = 0.625 e wout = 0.53):

1. Input 1.0 × 0.625 = 0.625.

2. Intermedio 0.625 × 0.53 = 0.331.

Il risultato è salito da 0.3 a 0.331. Ci stiamo avvicinando all'obiettivo di 0.8! Ripetendo questo processo centinaia di volte (le "Epoche" nel simulatore), l'errore quadratico medio scenderà fino a zero.

Sintesi dell'Analogia

La Backpropagation non fa altro che:

1. Guardare l'errore finale.

2. Dire all'ultimo strato: "Correggiti in base al tuo errore".

3. Dire allo strato nascosto: "Correggiti in base all'errore pesato dalla connessione successiva" (L'innovazione di Rumelhart).

4. Ripetere il tutto finché i pesi (le manopole) non sono perfettamente calibrati per tracciare quei confini complessi e curvi che abbiamo visto nel simulatore

La parte più difficile

Per spiegare come la Backpropagation gestisce una rete complessa (2 input, 2 hidden, 1 output), dobbiamo scendere nel cuore matematico dell'algoritmo.

Prima di vedere i numeri, chiariamo i concetti fondamentali: derivata e derivata parziale.

1. I Concetti: Derivata vs. Derivata Parziale

Immagina di essere su una montagna (la superficie dell'errore) e di voler scendere a valle (errore zero) bendato.

• La Derivata (d): È la pendenza del terreno sotto i tuoi piedi se ti muovi in un'unica direzione possibile (avanti/indietro). Ti dice: "Se faccio un passo, di quanto scendo?".

• La Derivata Parziale (∂): In una rete complessa, non hai una sola direzione, ma sei su un terreno 3D (o multidimensionale). Hai diverse manopole per muoverti (i pesi). La derivata parziale risponde alla domanda: "Se muovo solo la manopola X (tenendo bloccate tutte le altre), quanto cambia l'errore finale?".

    ◦ Matematicamente si scrive 

∂w  /  ∂E

​

 (La variazione parziale dell'Errore rispetto al peso w).

--------------------------------------------------------------------------------

2. L'Esempio: Una Rete 2-2-1

Costruiamo una rete per risolvere un problema simile allo XOR, dove la linearità non basta.

Struttura:

• Input (x): x1 = 1,  x2 =1

• Target Atteso (T): 0 (Vogliamo che la rete spenga l'output).

• Strato Nascosto (h): Due neuroni, h

1

​

 e h

2

​

.

• Pesi (w):

    ◦ w

A

​

 (da x

1

​

 a h

1

​

) = 0.6 (Il peso che aggiorneremo).

    ◦ w

B

​

 (da h

1

​

 a Output) = 1.0 (Connessione successiva).

    ◦ Ignoriamo gli altri pesi per semplicità, assumendo siano fissi.

Fase A: Forward Pass (Cosa pensa la rete?)

1. Al Neurone Nascosto h

1

​

: Riceve l'input 1 moltiplicato per il peso 0.6. Applichiamo una funzione Sigmoide (σ).

    ◦ Input netto: 0.6.

    ◦ Output h

1

​

: σ(0.6)≈0.65 (Il neurone è mediamente attivo).

2. All'Output Finale (O): Il neurone di output riceve 0.65 da h

1

​

 moltiplicato per il peso w

B

​

 (1.0).

    ◦ Input netto: 0.65.

    ◦ Output Finale O: σ(0.65)≈0.66.

3. L'Errore (E): Volevamo 0, abbiamo ottenuto 0.66.

    ◦ Formula Errore Quadratico: E=

2

1

​

(Target−Output)

2

=

2

1

​

(0−0.66)

2

≈0.218.

--------------------------------------------------------------------------------

3. Fase B: Backward Pass (Derivate Parziali in Azione)

Il problema è: come aggiorniamo w

A

​

 (il peso profondo)? w

A

​

 non tocca l'errore direttamente; è separato da un altro strato. Qui Rumelhart ha usato la Regola della Catena (Chain Rule): dobbiamo moltiplicare le derivate parziali lungo il percorso all'indietro.

Vogliamo calcolare 

∂w

A

​

∂E

​

 (l'influenza di w

A

​

 sull'Errore totale). La scomponiamo in tre pezzi collegati:

∂w

A

​

∂E

​

=

Errore finale

∂O

∂E

​

​

​

×

Peso intermedio

∂h

1

​

∂O

​

​

​

×

Attivazione interna

∂w

A

​

∂h

1

​

​

​

​

Calcoliamo i tre pezzi:

1. Quanto cambia l'Errore se cambia l'Output? (

∂O

∂E

​

)

• È semplicemente la differenza: (Output−Target).

• Calcolo: 0.66−0=0.66.

2. Quanto cambia l'Output se cambia il neurone nascosto h

1

​

? (

∂h

1

​

∂O

​

)

• Qui entra in gioco la "derivata della Sigmoide" (che è output×(1−output)) moltiplicata per il peso di connessione w

B

​

.

• Derivata Sigmoide Output: 0.66×(1−0.66)≈0.22.

• Influenza del peso w

B

​

: 1.0.

• Calcolo: 0.22×1.0=0.22.

3. Quanto cambia h

1

​

 se cambia il peso w

A

​

? (

∂w

A

​

∂h

1

​

​

)

• È la derivata della Sigmoide interna moltiplicata per l'input originale x

1

​

.

• Derivata Sigmoide h

1

​

: 0.65×(1−0.65)≈0.23.

• Input x

1

​

: 1.

• Calcolo: 0.23×1=0.23.

--------------------------------------------------------------------------------

4. Il Risultato Finale: La Moltiplicazione

Ora uniamo la catena per trovare il "Gradiente" complessivo per il peso w

A

​

:

Gradiente=0.66 (Errore)×0.22 (Passaggio)×0.23 (Interno)≈0.033

Questo numero (0.033) è la Derivata Parziale Finale. Ci dice che l'errore è positivamente correlato al peso w

A

​

. Per ridurre l'errore, dobbiamo diminuire il peso.

L'Aggiornamento del Peso: Usiamo un Tasso di Apprendimento (Learning Rate, η) di 0.5.

Nuovow

A

​

=Vecchio wA

​

−(η×Gradiente)

Nuovo wA

​

=0.6−(0.5×0.033)=0.6−0.0165=0.5835

Conclusioni

Grazie alle derivate parziali, la rete ha capito che per spegnere l'output finale (che era troppo alto), deve abbassare leggermente il peso wA all'ingresso, portandolo da 0.6 a 0.5835.

Ripetendo questo calcolo per tutti i pesi (sia dei neuroni nascosti che di output) migliaia di volte, la rete "scolpisce" quelle superfici di decisione complesse e curve che nel simulatore vediamo come aree colorate che risolvono problemi non lineari

Antonio Rizzo & Paolo Legrenzi