Deep learning - reti profonde, CNN e addestramento con Keras

Quattro lezioni e un laboratorio, nell'ottica del corso di IA: cosa sono le reti profonde, come si addestrano, le CNN e le architetture moderne (RNN, LSTM, autoencoder, GAN, trasformatori) e la pipeline Keras. Derivazioni, backpropagation completa e CNN in dettaglio sono nella materia Machine Learning; qui ci sono i concetti, gli esempi numerici e i rimandi. Esercizi di questa materia: Esercizio - CNN su CIFAR-10 con Keras (laboratorio 11). Metodi collegati: Apprendimento automatico nell'IA - supervisionato, SVM e valutazioneQuadro del machine learning nel corso di IA. Tre forme di apprendimento: supervisionato (coppie ingresso-uscita, classificazione se l'uscita è discreta e regressione se è un numero), non supervisionato (pattern senza feedback, per esempio clustering) e per rinforzo (ricompense). Un'ipotesi h approssima la funzione vera f e si valuta sul test set, non sul training set: un modello troppo semplice ha bias alto (underfitting), uno troppo complesso varianza alta (overfitting). Servono training, validation e test set; con pochi dati si usa la k-fold cross-validation. Alberi di decisione: si sceglie l'attributo con massimo guadagno d'informazione Gain = B(p/(p+n)) - somma (Nk/N) B(pk/Nk), si pota con il test del chi quadro (Delta > Delta*), si riduce la varianza con bagging e random forest. Perdita L1 e L2, regressione lineare e discesa del gradiente w <- w - alpha dL/dw. SVM: separatore a margine massimo, vettori di supporto, kernel trick con K(xj,xk). Pipeline scikit-learn del laboratorio 10: load_digits, train_test_split, SVC(C, kernel, gamma), fit, predict, classification_report, confusion_matrix, cross_val_score.Apprendimento automatico nell'IA - supervisionato, SVM e valutazione →.

1. Dal neurone alla rete

Definizione (unità). Un'unità (neurone) calcola la somma pesata dei suoi ingressi, $in_j=w_{0,j}+\sum_iw_{i,j}\,a_i$ (con $w_0$ il peso del bias, ingresso fisso $+1$), e applica una funzione di attivazione non lineare $g_j$: $a_j=g_j(in_j)$. Se $g$ fosse lineare la combinazione di più unità sarebbe ancora lineare.

Perceptron a soglia ($g(z)=1$ se $z\ge0$, 0 altrimenti): realizza le funzioni booleane linearmente separabili. Con pesi scelti ($w_0,w_1,w_2$):

• AND: $w=(-1{,}5;\,1;\,1)$: $in=x_1+x_2-1{,}5\ge0$ solo con $x_1=x_2=1$;
• OR: $w=(-0{,}5;\,1;\,1)$;
• NOT: $w=(0{,}5;\,-1)$: $in=0{,}5-x\ge0$ per $x=0$.

XOR non è linearmente separabile: nessuna retta separa $\{(0,1),(1,0)\}$ da $\{(0,0),(1,1)\}$. Si implementa con tre neuroni su due livelli (2 nascosti e 1 di uscita). Esempio con soglia: $h_1=\text{OR}(x_1,x_2)$ ($in=x_1+x_2-0{,}5$), $h_2=\text{AND}(x_1,x_2)$ ($in=x_1+x_2-1{,}5$), uscita $y=\text{step}(h_1-h_2-0{,}5)$, cioè "OR ma non AND":

In teoria si potrebbero usare soglie "dure", ma la differenziabilità delle funzioni "morbide" (sigmoide) rende possibile l'addestramento con il gradiente. Con due neuroni sigmoidi nascosti si ottiene una "cresta", con quattro un "dosso": con due soli livelli si può approssimare qualunque funzione continua (teorema di approssimazione universale). Dettagli: Reti neurali - neuroni e funzioni di attivazioneUn neurone calcola $\hat y=g(w_0+w^\top x)$: somma pesata degli ingressi più bias, poi una funzione di attivazione $g$ non lineare (Perceptron a soglia, sigmoide, tanh, ReLU e varianti). Senza non linearità ogni rete è equivalente a un solo modello lineare. Una rete feed-forward impila strati di neuroni: $a^{(k)}=g(W^{(k)}a^{(k-1)}+b^{(k)})$; con uno strato nascosto è già un approssimatore universale, ma più strati rappresentano funzioni complesse con molti meno neuroni e imparano feature gerarchiche (bordi, parti, oggetti). Lo strato di uscita e la loss si scelgono dal compito: lineare+MSE (regressione), sigmoide+cross-entropy binaria, softmax+cross-entropy (multiclasse). Il numero di parametri di uno strato denso è $n_{in}n_{out}+n_{out}$. Nel lab (Keras, MNIST) una rete 784-512-10 ha 407 050 parametri e supera il 98% di accuratezza.Reti neurali - neuroni e funzioni di attivazione →, Halfspace e PerceptronUn halfspace (semispazio) classifica con un iperpiano: $h(x)=\operatorname{sign}(w^Tx+b)$, con $w$ normale al piano e $|w^Tx+b|/|w|$ distanza dal piano; aggiungendo una componente costante $1$ a $x$ si scrive $\operatorname{sign}(\tilde w^T\tilde x)$. Il Perceptron (Rosenblatt, 1958) è il neurone con attivazione a gradino e impara con una regola semplice: per ogni errore $y_i,w^Tx_i\le0$ si aggiorna $w\leftarrow w+y_ix_i$. Teorema di convergenza (Novikoff): se i dati sono linearmente separabili con margine $\gamma$ ($y_iw^{T}x_i\ge\gamma$, $|w^|=1$) e $|x_i|\le R$, il Perceptron fa al più $(R/\gamma)^2$ errori e si ferma. Non risolve problemi non separabili (XOR), non ha un criterio di margine ottimale (le SVM sì) e il suo analogo morbido è la regressione logistica. Programma di Telecomunicazioni: halfspace model, Perceptron.Halfspace e Perceptron →, Esercizio - Halfspace, distanza dal piano e problema XOR.

Funzioni di attivazione comuni. Sigmoide $\sigma(z)=\tfrac1{1+e^{-z}}$ (valori in $(0,1)$, $\sigma(0)=0{,}5$); ReLU $\max(0,z)$; softplus $\ln(1+e^z)$ (versione liscia della ReLU); tanh (sigmoide scalata e traslata, in $(-1,1)$).

Reti. Una rete con $L$ livelli nascosti ha profondità legata a $L$. Feedforward: i collegamenti vanno in una sola direzione (grafo diretto aciclico, senza cicli). Ricorrente (RNN): le uscite tornano agli ingressi, e la rete è un sistema dinamico con stato interno (memoria). I livelli nascosti formano rappresentazioni interne dell'ingresso.

2. Ingressi, uscite e perdita

• Ingressi: booleani come 0 e 1; numerici usati direttamente (al più scalati); categorici con più di due valori in one-hot: un attributo con $d$ valori diventa $d$ bit, con a 1 solo quello corrispondente (per esempio Type $=$ Italian $\to(0,1,0,0)$ su French, Italian, Thai, Burger). Non si usano numeri interi, altrimenti French sarebbe "minore" di Italian senza senso.
• Uscita per la regressione: livello lineare, $\hat y_j=\sum_iw_{i,j}a_i$ (la media di una gaussiana a varianza fissa).
• Uscita per due classi: una sigmoide, interpretata come probabilità.
• Uscita per più classi: softmax, $\text{softmax}(in)_k=\dfrac{e^{in_k}}{\sum_je^{in_j}}$: valori non negativi che sommano a 1. Esempio: ingressi $(5,2,0,-2)$: gli esponenziali sono $148{,}41;\ 7{,}389;\ 1;\ 0{,}135$ (somma $156{,}93$), quindi uscita $(0{,}946;\ 0{,}047;\ 0{,}006;\ 0{,}001)$.
• Perdita: se le uscite sono probabilità, la distanza tra distribuzione vera e predetta è l'entropia incrociata (cross-entropy), di solito approssimata dalla log-verosimiglianza negativa. Minimizzarla equivale a massimizzare la probabilità dei dati osservati: $\arg\max_w\sum_j\log P_w(y_j\mid x_j)$. Vedi Regressione logistica e softmaxLa regressione lineare non è adatta alla classificazione (valori fuori da [0,1], retta tirata dai punti lontani). La regressione logistica passa il predittore lineare dalla sigmoide $\sigma(z)=1/(1+e^{-z})$ e interpreta $\hat y=\sigma(x^T\beta)$ come $P(y=1\mid x)$: si predice la classe 1 se $\hat y\ge0{,}5$, cioè $x^T\beta\ge0$ (bordo lineare). L'errore quadratico dà una funzione non convessa; si usa la log-verosimiglianza negativa $-\sum[y\log\hat y+(1-y)\log(1-\hat y)]$, convessa, con gradiente $X^T(\hat y-y)$ e nessuna formula chiusa (discesa del gradiente). Per più classi: one-vs-one ($C(C-1)/2$ classificatori, voto), one-vs-all ($C$ classificatori, massima probabilità), o la softmax $p_c=e^{z_c}/\sum_ke^{z_k}$ con cross-entropia. Si può regolarizzare (ridge, LASSO, Elastic Net) e la cross-validation si fa stratificata. Approfondimento: non nel programma di Telecomunicazioni.Regressione logistica e softmax →.

3. Addestramento

Le reti si addestrano con varianti della discesa stocastica del gradiente (SGD a minibatch) $w\leftarrow w-\alpha\nabla L(w)$, come in Apprendimento automatico nell'IA - supervisionato, SVM e valutazioneQuadro del machine learning nel corso di IA. Tre forme di apprendimento: supervisionato (coppie ingresso-uscita, classificazione se l'uscita è discreta e regressione se è un numero), non supervisionato (pattern senza feedback, per esempio clustering) e per rinforzo (ricompense). Un'ipotesi h approssima la funzione vera f e si valuta sul test set, non sul training set: un modello troppo semplice ha bias alto (underfitting), uno troppo complesso varianza alta (overfitting). Servono training, validation e test set; con pochi dati si usa la k-fold cross-validation. Alberi di decisione: si sceglie l'attributo con massimo guadagno d'informazione Gain = B(p/(p+n)) - somma (Nk/N) B(pk/Nk), si pota con il test del chi quadro (Delta > Delta*), si riduce la varianza con bagging e random forest. Perdita L1 e L2, regressione lineare e discesa del gradiente w <- w - alpha dL/dw. SVM: separatore a margine massimo, vettori di supporto, kernel trick con K(xj,xk). Pipeline scikit-learn del laboratorio 10: load_digits, train_test_split, SVC(C, kernel, gamma), fit, predict, classification_report, confusion_matrix, cross_val_score.Apprendimento automatico nell'IA - supervisionato, SVM e valutazione →. Il gradiente si calcola con la backpropagation: un passaggio in avanti in cui ogni nodo calcola la sua funzione (prodotto, somma, attivazione) dagli ingressi, e un passaggio all'indietro in cui si propaga l'informazione sull'errore dall'uscita ai livelli nascosti. I "messaggi" sono derivate parziali della perdita $L$: i messaggi in ingresso a un nodo interno si sommano e poi si moltiplicano per le derivate locali. Per un nodo prodotto $h=f\cdot g$ si ha $\partial h/\partial f=g$ e $\partial h/\partial g=f$.

Esempio della slide (perdita quadratica, peso $w_{3,5}$ che collega l'unità 3 all'unità 5): $$\frac{\partial L}{\partial w_{3,5}}=-2(y-\hat y)\,g_5'(in_5)\,a_3,$$ dove $-2(y-\hat y)=\partial L/\partial\hat y$ è il primo messaggio, $g_5'(in_5)$ la derivata locale dell'attivazione e $a_3$ la derivata di $in_5$ rispetto a $w_{3,5}$; tutte le $a_i$ e le $in_j$ sono quelle del passaggio in avanti (per questo vanno memorizzate).

Esempio numerico: un solo neurone sigmoide. Ingresso $x=2$, peso $w=0{,}5$, bias $0$, uscita voluta $y=1$, perdita quadratica.

• Avanti: $in=0{,}5\cdot2=1$, $\hat y=\sigma(1)=0{,}7311$, $L=(1-0{,}7311)^2=0{,}0723$.
• Indietro: $\partial L/\partial\hat y=-2(1-0{,}7311)=-0{,}5379$; $g'(in)=\sigma'(1)=\hat y(1-\hat y)=0{,}1966$; $\partial in/\partial w=x=2$. Quindi $\partial L/\partial w=-0{,}5379\cdot0{,}1966\cdot2=-0{,}2115$.
• Aggiornamento con $\alpha=1$: $w=0{,}5+0{,}2115=0{,}7115$. Nuova uscita $\sigma(1{,}4230)=0{,}8058$ e $L=0{,}0377$: la perdita è quasi dimezzata.

Pro e contro. Il costo del calcolo del gradiente è lineare nel numero di nodi del grafo, e le derivate delle attivazioni si possono preparare in anticipo. Ma servono i valori intermedi del passaggio in avanti (memoria) e c'è il gradiente che svanisce (vanishing gradient): se $g'(\cdot)\ll1$ (molto probabile con sigmoide e tanh) l'errore retropropagato incide poco sui pesi dei primi livelli. Per la sigmoide $\sigma'\le0{,}25$: dopo 10 livelli il fattore è al più $0{,}25^{10}\approx10^{-6}$. Dettagli, esempio completo su una rete $2$-$2$-$1$ e ottimizzatori: Addestramento delle reti neurali - backpropagation e ottimizzatoriAddestrare una rete significa minimizzare la loss empirica $J(W)=\frac1n\sum_i\mathcal L(f(x^{(i)};W),y^{(i)})$ con la discesa del gradiente $W\leftarrow W-\eta,\partial J/\partial W$; in pratica a mini-batch (SGD). Il gradiente di tutti i pesi si ottiene con la backpropagation, cioè la regola della catena applicata all'indietro: $\delta^{(L)}=\partial J/\partial a^{(L)}\odot g'(z^{(L)})$, $\delta^{(l)}=(W^{(l+1)\top}\delta^{(l+1)})\odot g'(z^{(l)})$, $\partial J/\partial W^{(l)}=\delta^{(l)}a^{(l-1)\top}$ (con sigmoide e cross-entropy $\delta=\hat y-y$). Per far funzionare reti profonde: attivazioni ReLU, inizializzazione di Xavier o He (varianza $2/(n_{in}+n_{out})$ e $2/n_{in}$), batch normalization, ottimizzatori con momento o adattivi (Momentum, AdaGrad, RMSProp, Adam con $\beta_1=0{,}9$, $\beta_2=0{,}999$, lr $10^{-3}$) e un learning rate che varia nel tempo (a gradini, coseno). Si addestra tenendo d'occhio la loss di training e di validazione.Addestramento delle reti neurali - backpropagation e ottimizzatori →, Esercizio - Backpropagation a mano su una rete 2-2-1.

Generalizzazione. Per ingressi ad alta dimensione (immagini, video, voce) le reti profonde sono migliori di ogni altro approccio di ML puro; a parità di pesi, reti più profonde di solito generalizzano meglio. Ma possono fallire con esempi avversari (rumore aggiunto a un'immagine che produce un'uscita del tutto inattesa) e un buon errore di training non garantisce buone prestazioni reali. Il dropout disattiva casualmente alcune unità durante l'addestramento (per esempio dopo ogni minibatch): rende più difficile adattarsi al training set, rende il modello robusto al rumore e approssima un grande insieme di reti più piccole. Vedi Regolarizzazione delle reti neuraliUna rete con tanti parametri tende a memorizzare il training set (overfitting): la loss di training scende ma quella di validazione risale. Le tecniche di regolarizzazione limitano la capacità effettiva: penalità sui pesi ($\ell_2$: $J+\lambda|W|_2^2$, il passo diventa $W\leftarrow(1-2\eta\lambda)W-\eta\nabla J$; $\ell_1$: $J+\lambda|W|_1$, porta pesi esattamente a zero), early stopping (si ferma l'addestramento quando la validation loss smette di scendere, con pazienza e ripristino dei pesi migliori), dropout (in training si azzera a caso una frazione $p$ delle attivazioni e si riscala per $1/(1-p)$; in inferenza è spento), batch normalization (effetto collaterale) e data augmentation. Nel lab MNIST con $\lambda=0{,}01$ la penalità $\ell_1$ è troppo forte (accuratezza di test 0,844 contro 0,9815 senza regolarizzazione), mentre dropout e early stopping non peggiorano e tengono la validation loss più bassa.Regolarizzazione delle reti neurali →.

4. Reti convolutive

Una CNN ha livelli convolutivi, con collegamenti spazialmente locali: ogni unità è collegata a una sotto-regione dell'ingresso, il suo campo recettivo, piccolo nei primi livelli e sempre più grande in profondità (idea ispirata alla corteccia visiva). Segue spesso il pooling e poi una rete di classificazione.

Convoluzione. Un kernel $k$ (un vettore di pesi, appreso) di dimensione $l$ si applica all'ingresso $x$: $z_i$ è il prodotto scalare tra $k$ e il tratto di $x$ centrato in $x_i$. Il risultato passa per una funzione di attivazione. Il passo (stride) $s$ è la distanza tra i centri successivi del kernel; il padding aggiunge pixel al bordo, così il kernel si applica esattamente $\lceil n/s\rceil$ volte.

Esempio 1D. $x=(1,3,2,5,4)$, kernel $k=(+1,-1,+1)$, senza padding. Posizioni (stride 1): $z_1=1-3+2=0$, $z_2=3-2+5=6$, $z_3=2-5+4=1$, quindi $z=(0,6,1)$. Con stride 2 si tengono la prima e la terza posizione: $z=(0,1)$. La dimensione dell'uscita è $\lfloor(n+2p-l)/s\rfloor+1$: con $n=5$, $l=3$, $p=0$ è $3$ per $s=1$ e $2$ per $s=2$.

Tensori. Un tensore è un array multidimensionale; tenere traccia della forma dei dati livello per livello permette ai pacchetti di generare codice ottimizzato per GPU o TPU. Esempio della slide: 64 immagini RGB $256\times256\times3$; 96 kernel $5\times5\times3$ con stride $s=2$ solo su $x$-$y$ e padding 2: l'uscita per un kernel e un'immagine è $\lfloor(256+4-5)/2\rfloor+1=128$, quindi $128\times128$; l'uscita complessiva ha forma $128\times128\times96\times64$ (una feature map a 96 canali). I parametri del livello sono $96\cdot(5\cdot5\cdot3+1)=7\,296$ (un bias per kernel).

Pooling. Riassume un gruppo di unità adiacenti con un solo valore: max-pooling (massimo) o average-pooling (media); è una convoluzione con pesi fissi, non appresi. Si usa per ridurre la dimensione dei livelli nascosti. Dettagli e architetture: Reti neurali convolutive (CNN)approfondimento: non nel programma di Telecomunicazioni. Una rete convolutiva (CNN) sostituisce gli strati densi con filtri piccoli che scorrono sull'immagine: ogni neurone vede solo una patch locale (campo recettivo) e i pesi del filtro sono condivisi in tutta l'immagine, quindi i parametri non dipendono dalla dimensione dell'immagine ($K^2C_{in}C_{out}+C_{out}$ per strato) e si conserva l'informazione spaziale. Dimensione dell'uscita: $\lfloor(W-K+2P)/S\rfloor+1$. Pooling (max 2x2, stride 2) sottocampiona e dà invarianza locale; i filtri 1x1 riducono i canali; struttura tipica CONV+ReLU, POOL, ..., FLATTEN, FC, SOFTMAX, addestrata con cross-entropy e backpropagation. Tre strati 3x3 hanno il campo recettivo di un 7x7 con meno parametri e più non linearità (VGG). Architetture: LeNet, AlexNet (ReLU, dropout, data augmentation), VGG, GoogLeNet (moduli Inception), ResNet (blocchi residui $H(x)=F(x)+x$), EfficientNet. Nel lab: CNN su Fashion-MNIST (241 546 parametri) e su CIFAR-10 (122 570).Reti neurali convolutive (CNN) →, Esercizio - Convoluzione 2D a mano, Esercizio - Dimensioni e parametri di una CNN.

5. Reti ricorrenti e LSTM

Una RNN ha cicli nel grafo di calcolo (ogni ciclo con un ritardo): un'unità può usare un valore calcolato dalla propria uscita a un passo precedente. Ha stato interno (memoria), con ipotesi di Markov $z_t=f_w(z_{t-1},x_t)$: $z_t$ riassume tutto il passato. Per l'addestramento si "srotola" nel tempo e si usa la backpropagation attraverso il tempo (BPTT), in cui il contributo del gradiente al passo $t$ si calcola da quello al passo $t-1$, con costo lineare nella dimensione della rete. Ma se $w_{z,z}<1$ il gradiente svanisce, se $w_{z,z}>1$ esplode. Esempio: dopo 20 passi con fattore $0{,}9$ resta $0{,}9^{20}=0{,}12$; con fattore $1{,}1$ vale $1{,}1^{20}=6{,}7$.

La LSTM aggiunge uno stato di memoria a lungo termine $c_t$, copiato da un passo al successivo invece di essere moltiplicato (e questo evita i problemi del gradiente), controllato da porte (vettori con valori in $[0,1]$, uscite sigmoidi) usate per moltiplicare elemento per elemento: forget (cosa si ricorda di $c$), input (cosa si aggiorna in modo additivo), output (cosa passa alla memoria a breve termine). Applicazioni: elaborazione del linguaggio, serie temporali, riconoscimento del parlato, didascalie di immagini, gesti, rilevamento di anomalie, scrittura a mano. Panoramica: Cenni a reinforcement learning e reti per sequenzeapprofondimento: non nel programma di Telecomunicazioni, solo cenni (ultima lezione del corso). Reinforcement learning: un agente in uno stato $S_t$ sceglie azioni, l'ambiente restituisce ricompense; l'obiettivo non è minimizzare una loss ma massimizzare il ritorno $G_t=\sum_{k\ge0}\gamma^kR_{t+k+1}$ (fattore di sconto $\gamma\in[0,1)$) trovando la politica ottima $\pi^*=\arg\max G$. Apprendimento di sequenze: servono lunghezze variabili, dipendenze a lungo termine, ordine, parametri condivisi nel tempo; una rete ricorrente aggiorna uno stato $h_t=f_W(h_{t-1},x_t)$; le reti convolutive temporali (TCN) usano convoluzioni causali e dilatate con campo recettivo $1+(k-1)\sum d_\ell$. Chiude con i modelli generativi (VAE, GAN) già visti in Autoencoder.Cenni a reinforcement learning e reti per sequenze →.

6. Apprendimento non supervisionato: autoencoder, VAE, GAN

Nel non supervisionato si hanno solo esempi $x$ senza uscite $y$: si evita l'annotazione di grandi dataset e si costringe il modello a "spiegare" ingressi ad alta dimensione. Due usi: imparare rappresentazioni (utili per un classificatore) e imparare modelli generativi ($\sim P(x)$ per generare nuovi esempi).

• Autoencoder: un encoder $f$ porta l'ingresso $x$ in una rappresentazione compressa $\hat z$ (bottleneck, embedding) e un decoder $g$ lo ricostruisce, $g(f(x))\approx x$. Usi: compressione e riduzione di dimensione, eliminazione del rumore, ricostruzione di parti mancanti, rilevamento di anomalie (differenza tra ingresso e uscita).
• VAE (variational autoencoder): versione probabilistica che codifica un ingresso in una distribuzione (per esempio gaussiana) $P(z\mid x)$ e non in un punto: il decoder viene addestrato su punti casuali dello spazio latente e può generare dati nuovi da rumore; un AE deterministico no.
• GAN: un generatore trasforma $z$ in campioni falsi e un discriminatore classifica gli ingressi come veri o falsi; si addestrano insieme (il generatore cerca di ingannare il discriminatore). Sono modelli impliciti (si generano campioni, ma la probabilità non è disponibile). Problemi: mode collapse (il generatore copre solo alcuni picchi della distribuzione) e mode hopping.

Dettagli in Autoencoderapprofondimento: non nel programma di Telecomunicazioni. Un autoencoder è una rete non supervisionata che impara a ricostruire il proprio ingresso passando per un collo di bottiglia: encoder $z=e(x)$ (dimensione bassa), decoder $\hat x=d(z)$, loss $|x-d(e(x))|^2$. Con attivazioni lineari equivale alla PCA; con non linearità impara rappresentazioni latenti più ricche (ipotesi del manifold). Varianti: sparse (penalità $\ell_1$ sulle attivazioni), denoising (ingresso corrotto, bersaglio pulito), convolutivi (inpainting). Anomaly detection: si addestra su dati normali e si segnala come anomalo ciò che ha errore di ricostruzione sopra una soglia. VAE: l'encoder produce media e deviazione standard di una gaussiana, il campione si ottiene con il trucco di riparametrizzazione $z=\mu+\sigma\odot\zeta$, $\zeta\sim\mathcal N(0,I)$, e la loss è errore di ricostruzione più KL verso $\mathcal N(0,I)$, con $KL=\frac12\sum(\mu^2+\sigma^2-1-\ln\sigma^2)$; il $\beta$-VAE pesa il KL con $\beta>1$ per rappresentazioni disaccoppiate. Cenno ai GAN.Autoencoder →.

7. Transfer learning, modelli linguistici e trasformatori

Transfer learning. L'esperienza su un compito $A$ aiuta un compito $B$: si copiano i pesi appresi per $A$ in una rete da addestrare per $B$ e si aggiornano con i dati di $B$. In pratica si congelano i primi livelli del modello pre-addestrato (che sono rilevatori di caratteristiche) e si modificano solo i livelli alti (le caratteristiche specifiche e la classificazione), partendo da un modello diffuso (per esempio ResNet-50) e facendo fine-tuning con esempi del dominio.

Modelli linguistici. Un modello linguistico è un modello probabilistico del linguaggio naturale; un LLM è una rete neurale con comprensione e generazione generali (IA generativa): preso un testo, predice ripetutamente la parola successiva. Parole o parti di parole sono token (numeri; anche spazi e punteggiatura); l'insieme dei token è il vocabolario (circa 50 000 per GPT-2). Il word embedding va oltre la semplice codifica: raggruppa parole simili in uno spazio di dimensione minore. Dato un prompt, il modello restituisce le probabilità di tutti i token del vocabolario; si sceglie in modo greedy (il più probabile) oppure a caso secondo la distribuzione (più varietà). La generazione di una frase è un ciclo: frase $=$ prompt; token $\leftarrow$ predizione; frase $\leftarrow$ frase più token; si ferma al punto.

Attenzione e trasformatori. I modelli sequence-to-sequence con LSTM tendono a dimenticare le informazioni vecchie. Con le unità di attenzione il modello impara a selezionare le parti dell'ingresso più utili al contesto; nella self-attention gli stati nascosti guardano se stessi, catturando il contesto vicino e lontano. I trasformatori implementano la self-attention e sono il cuore di GPT (Generative Pre-trained Transformer): un blocco di ingresso (embedding del token e della posizione), una colonna di 12-96 blocchi, una testa che produce le probabilità dei token. Ogni blocco contiene LayerNorm, attenzione multi-testa, un altro LayerNorm e una rete feedforward a due livelli con connessioni residue. Il numero di colonne è l'ampiezza del contesto (fino a circa 128 000 token), il numero di blocchi in verticale la profondità (livello di astrazione). L'uscita usa la trasposta della matrice di embedding e un softmax; l'addestramento minimizza l'entropia incrociata mediata sulla sequenza.

8. Keras: la pipeline del laboratorio 11

Il laboratorio classifica cani e gatti (23 410 immagini; alcune sono corrotte e vanno filtrate) con la Sequential API di Keras, adatta a una pila di livelli con un solo ingresso e una sola uscita (per grafi più complessi esistono la functional API e la sottoclasse). Il codice delle slide:

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models

image_size = (180, 180); batch_size = 128
train_ds, val_ds = tf.keras.utils.image_dataset_from_directory(
    "PetImages", validation_split=0.2, subset="both", seed=1337,
    image_size=image_size, batch_size=batch_size)          # 18728 immagini di training, 4682 di validazione
train_ds = train_ds.map(lambda x, y: (x / 255, y))         # standardizzazione: da [0, 255] a [0, 1]
val_ds = val_ds.map(lambda x, y: (x / 255, y))

data_augmentation = keras.Sequential([layers.RandomFlip("horizontal"), layers.RandomRotation(0.1)])
train_ds = train_ds.map(lambda img, label: (data_augmentation(img), label),
                        num_parallel_calls=tf.data.AUTOTUNE).prefetch(tf.data.AUTOTUNE)
val_ds = val_ds.prefetch(tf.data.AUTOTUNE)

model = models.Sequential()
model.add(layers.Conv2D(16, (3, 3), 1, activation="relu", input_shape=(180, 180, 3)))   # 16 filtri 3x3, stride 1
model.add(layers.MaxPooling2D((2, 2)))                      # massimo su regioni 2x2
model.add(layers.Conv2D(16, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())                                 # da tensore 3D a vettore 1D
model.add(layers.Dense(64, activation="relu"))
model.add(layers.Dense(1, activation="sigmoid"))            # una sola uscita: 0 gatto, 1 cane
model.summary()

model.compile(optimizer=keras.optimizers.Adam(1e-3), loss="binary_crossentropy", metrics=["accuracy"])
hist = model.fit(train_ds, epochs=5, validation_data=val_ds)

I passi, con i numeri:

• Dati: image_dataset_from_directory legge le sottocartelle come classi (etichetta 0 gatto, 1 cane) e rimescola; ogni batch ha forma $(128,180,180,3)$: 128 immagini, $180\times180$ pixel, 3 canali RGB.
• Data augmentation (solo sul training): rovesciamenti orizzontali casuali e piccole rotazioni, per esporre il modello ad aspetti diversi dei dati e rallentare l'overfitting.
• Standardizzazione: i valori RGB sono in $[0,255]$, non ideali per una rete (in generale gli ingressi vanno tenuti piccoli); si portano in $[0,1]$ dividendo per 255 con una map sui due dataset (il testo delle slide parla di un livello Rescaling all'inizio del modello, ma il codice mostrato usa la map: sono due modi equivalenti di fare la stessa cosa). In predizione l'immagine va divisa per 255 allo stesso modo.
• Architettura (model.summary() riportato dal corso), verificata a mano con $\lfloor(n+2p-k)/s\rfloor+1$ e conteggio dei parametri $(k_hk_wC_{in}+1)C_{out}$:

Totale parametri addestrabili: $448+2\,320+1\,893\,440+65=1\,896\,273$, come nel riepilogo del corso. Il $178/2=89$ è il pooling $2\times2$; $87/2$ si arrotonda per difetto a $43$.

• Compilazione: si definiscono ottimizzatore (Adam con passo $10^{-3}$), perdita (entropia incrociata binaria, adatta a una sigmoide) e metriche; con fit si addestra. Output del corso (5 epoche, 147 passi per epoca): accuratezza di training da $0{,}5481$ a $0{,}7499$, perdita da $0{,}7653$ a $0{,}5058$; accuratezza di validazione da $0{,}6591$ a $0{,}7666$, perdita di validazione da $0{,}6159$ a $0{,}4834$. La perdita deve scendere e l'accuratezza salire a ogni epoca.
• Test su immagini nuove: model.predict(np.expand_dims(resize/255, 0)) dà un numero in $[0,1]$; se $>0{,}5$ la classe è Cane, altrimenti Gatto (per esempio $0{,}387\to$ Gatto).
• Salvataggio: model.save("models/imageclassifier.h5") e load_model(...) (formato HDF5).

Un secondo esercizio con CIFAR-10 (10 classi, softmax) è Esercizio - CNN su CIFAR-10 con Keras (laboratorio 11); un'altra CNN in Keras, su Fashion-MNIST e CIFAR-10, è in Esercizio - CNN su Fashion-MNIST e CIFAR-10 con Keras.

Errori tipici

• Usare una attivazione lineare nei livelli nascosti: la rete resterebbe lineare.
• Codificare un attributo categorico con interi invece che in one-hot.
• Dimenticare di dividere per 255 le immagini in predizione, se il modello è stato addestrato su valori in $[0,1]$.
• Applicare la data augmentation anche al validation set.
• Contare i parametri di un livello convolutivo senza i bias, o senza moltiplicare per i canali di ingresso.
• Pensare che len(train_ds) sia il numero di immagini: è il numero di batch (147 batch da 128, circa 18 700 immagini).
• Aspettarsi che sigmoide e tanh funzionino bene in reti molto profonde (gradiente che svanisce).

Domande d'esame

1. Perché lo XOR richiede almeno due livelli? Perché non è linearmente separabile: un singolo neurone a soglia produce un confine lineare. Servono 3 neuroni (2 nascosti, per esempio OR e AND, e uno di uscita "OR e non AND").
2. Un softmax riceve $(5,2,0,-2)$. Che cosa restituisce? $e^z=(148{,}41;\,7{,}39;\,1;\,0{,}135)$, somma $156{,}93$, uscita $(0{,}946;\,0{,}047;\,0{,}006;\,0{,}001)$.
3. Un livello convolutivo ha 96 kernel $5\times5\times3$, stride 2, padding 2, su immagini $256\times256\times3$. Dimensione dell'uscita e numero di parametri? $\lfloor(256+4-5)/2\rfloor+1=128$: uscita $128\times128\times96$; parametri $96\cdot(75+1)=7\,296$.
4. Cosa risolvono le LSTM rispetto alle RNN semplici? Il gradiente che svanisce o esplode: la memoria $c_t$ è copiata tra i passi e controllata da porte (forget, input, output) in $[0,1]$.