Il Percettrone di Frank Rosenblatt

Il Percettrone: L'Alba dell'Apprendimento Automatico

Se i neuroni MCP erano interruttori logici fissi, il Percettrone, introdotto da Frank Rosenblatt nel 1958, rappresenta un passo cruciale per le reti neurali artificiali: è un modello capace di apprendere da esempi. Immaginalo come un bimbo che impara a distinguere tra due categorie (ad esempio, mele e arance) solo guardando diverse immagini e correggendo i propri errori di giudizio. Come funziona?

1. Input Ponderati: Simile ai neuroni MCP, riceve input (nel simulatore, le coordinate x1​ e x2​ di un punto, che possono corrispondere nel caso illustrato nel libro a forrma e colore). Ogni input ha un peso (w1​,w2​) che ne determina l'importanza. Sia per gli input che per i pesi, a differenza del Neurone MCP, questi posso essere anche valori decimali lungo un continuum.

2. Bias: C'è un input speciale, sempre attivo (valore 1), chiamato bias. Anche lui ha un peso (w0​) e agisce come una sorta di "regolazione" indipendente dagli input specifici, aiutando a spostare la soglia di decisione.

3. Somma Pesata: Il Percettrone calcola la somma di tutti gli input moltiplicati per i loro pesi: somma=(w1​*x1​)+(w2​*x2​)+w0​.

4. Attivazione a Gradino: Applica una semplice regola di decisione (funzione di attivazione a gradino): se la somma ≥ 0, l'output è 1 (appartiene alla Classe 1); altrimenti, l'output è 0 (appartiene alla Classe 0). Geometricamente, questa regola definisce una linea retta (o un iperpiano in più dimensioni) che separa lo spazio degli input in due regioni.

5. Apprendimento dall'Errore: Qui sta la magia! Se il Percettrone classifica un punto in modo errato, aggiusta i suoi pesi e il bias per cercare di fare meglio la prossima volta. L'entità dell'aggiustamento dipende da:

   • L'errore commesso (la differenza tra la classe corretta e quella predetta).

   • Il valore degli input che hanno causato l'errore.

   • Un parametro chiamato Learning Rate (tasso di apprendimento), che controlla quanto "grandi" devono essere questi aggiustamenti.

Il Percettrone è quindi un classificatore binario lineare: impara a tracciare una linea retta per separare dati appartenenti a due classi diverse.

Un esempio numerico del processo di apprendimento

Ecco un esempio numerico passo dopo passo che simula un singolo ciclo di apprendimento del Percettrone, mostrando come vengono corretti i pesi e, in particolare, il bias.

Immaginiamo una situazione in cui il Percettrone deve imparare che un certo punto appartiene alla Classe 1, ma attualmente sbaglia e predice Classe 0.

1. La Situazione Iniziale (Setup)

Definiamo i parametri di partenza:

• Input (x1, x2): Coordinate del punto (2,3).

• Target (Etichetta reale): 1 (questo è il risultato corretto che vogliamo).

• Pesi attuali (w1, w2): 0.5 e −0.5.

• Bias attuale (w0): 0.2 (ricorda: l'input del bias è sempre 1).

• Learning Rate (Tasso di apprendimento): 0.1 (indica la "grandezza" del passo di correzione).

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

2. Passo 1: La Previsione (Forward Pass)

Il Percettrone calcola la somma pesata per decidere. La formula è: 

Somma=(w1⋅x1) + (w2⋅x2) + (w0⋅1).

Somma=(0.5⋅2)+(−0.5⋅3)+(0.2⋅1)

Somma=1.0−1.5+0.2=−0.3

Decisione: Poiché la somma (−0.3) è minore di 0, l'output del Percettrone è 0.

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

3. Passo 2: Calcolo dell'Errore

Confrontiamo la previsione con la realtà.

• Realtà (Target): 1

• Previsione: 0

Errore = Target−Previsione =1−0 =+1

Poiché c'è un errore (positivo), il Percettrone deve aumentare i pesi per spingere la somma verso l'alto (verso i numeri positivi).

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

4) Passo 3: aggiornamento dei pesi e del bias

La regola di correzione è:  Nuovo peso = Vecchio peso + (learning rate × errore × input)

Quindi prendiamo ogni peso e aggiungiamo una correzione. La correzione dipende da:

• learning rate (quanto correggiamo),

• errore (quanto abbiamo sbagliato),

• input (quanto “pesa” quell’ingresso nel caso specifico).
  
  

A) Aggiornamento di w1 (input x1 = 2)

• Vecchio w1 = 0,5

• Correzione = 0,1 × 1 × 2 = 0,2

• Nuovo w1 = 0,5 + 0,2 = 0,7
  
  

B) Aggiornamento di w2 (input x2 = 3)

• Vecchio w2 = -0,5

• Correzione = 0,1 × 1 × 3 = 0,3

• Nuovo w2 = -0,5 + 0,3 = -0,2
  
  

C) Aggiornamento del bias w0 (input fisso = 1)

Il bias si aggiorna come un peso normale, ma usa un input sempre uguale a 1 (come un “interruttore sempre acceso”).

• Vecchio w0 = 0,2

• Correzione = 0,1 × 1 × 1 = 0,1

• Nuovo w0 = 0,2 + 0,1 = 0,3

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

5. Verifica: Cosa succede adesso?

Proviamo a ricalcolare la somma con i nuovi pesi (0.7,−0.2,0.3) per lo stesso punto (2,3):

Nuova Somma=(0.7⋅2)+(−0.2⋅3)+(0.3⋅1)

Nuova Somma=1.4−0.6+0.3=1.1

Risultato: La somma è ora 1.1 (maggiore di 0). L'output diventa 1. Il Percettrone ha imparato! La linea di decisione si è spostata (e ruotata) quanto basta per includere questo punto nella classe corretta.

Esempio di XOR nella vita reale

Rilevamento Frodi (Comportamento d'acquisto)

Le banche analizzano i pattern di spesa per bloccare le carte di credito.

• Variabile 1: Importo della transazione (Piccolo vs Grande).

• Variabile 2: Frequenza delle transazioni (Rara vs Comune).

Spesso sono considerati Normali (Classe 1):

• Piccole spese quotidiane frequenti (caffè, spesa).

• Grandi spese rare (acquisto di un PC, una vacanza).

Sono considerati Anomali/Sospetti (Classe 0):

• Piccole spese rarissime (potrebbe essere un test della carta da parte di un hacker).

• Grandi spese frequentissime in un arco di tempo brevissimo (tentativo di svuotare il conto).

Antonio Rizzo & Paolo Legrenzi