Reti neurali - neuroni e funzioni di attivazione

Le Regressione lineareNell'apprendimento supervisionato si impara una funzione $F(x)$ dagli esempi $(x,y)$: regressione se $y$ è continua, classificazione se è categorica. Il modello lineare è $F_\beta(x)=\beta_0+\beta_1x_1+\dots+\beta_px_p=X\beta$ (con una colonna di uni per $\beta_0$) e i parametri si scelgono minimizzando l'errore quadratico medio $\mathrm{MSE}=\frac1n\sum_i(y_i-F_\beta(x_i))^2$, funzione convessa dei parametri. Annullando il gradiente di $J(\beta)=|y-X\beta|^2$ si ottengono le equazioni normali $X^TX\beta=X^Ty$ e la soluzione dei minimi quadrati ordinari $\beta=(X^TX)^{-1}X^Ty$. Il coefficiente di determinazione $R^2=1-SS_{res}/SS_{tot}$ misura la qualità del fit (0 = come la media, negativo = peggio della media). Un modello va valutato su un test set mai usato per addestrare: l'errore sul training è ottimistico e un polinomio di grado alto lo azzera senza generalizzare.Regressione lineare → e la 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 → sono già, a modo loro, reti con un solo neurone. Le reti neurali (neural networks, NN) le combinano in strati successivi per imparare funzioni molto più ricche: il deep learning (DL) è l'uso di reti con molti strati. Qui si costruisce la rete (neuroni, attivazioni, strati, uscita); come si addestra è in 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 →, come si evita l'overfitting in 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 →.

1. Perché il deep learning (e perché no)

Parole chiave: l'intelligenza artificiale (AI) è l'insieme delle «macchine» che imitano il comportamento umano; il machine learning (ML) lo fa imparando dai dati; il deep learning è l'ML basato su reti neurali; la GenAI (intelligenza artificiale generativa) usa modelli «creativi» in cui l'uscita non è deterministica.

Ragioni a favore (dalle slide):

• Prestazioni: visione artificiale (ImageNet, oltre 14 milioni di immagini), traduzione automatica neurale, modelli di linguaggio.
• Rappresentazione procedurale: le feature non si scrivono a mano; la rete le costruisce strato dopo strato, dalle più semplici alle più astratte.
• Capacità generativa: può produrre immagini e testi mai visti.
• Perché adesso: più dati (Web, ImageNet), software ottimizzato (TensorFlow, PyTorch) e hardware (GPU).

Ragioni contro:

• Complessità e scarsa interpretabilità: dove servono robustezza, fiducia e spiegazioni (medicina, guida autonoma) è un limite (Explainable AI (XAI)approfondimento: non nel programma di Telecomunicazioni. L'interpretabilità è l'arte di produrre descrizioni di un modello abbastanza semplici da essere capite da un umano; la spiegabilità aggiunge la completezza (permettere di anticipare la previsione). I metodi si classificano in intrinseci o post-hoc, agnostici o specifici del modello, globali o locali. Modelli intrinsecamente interpretabili: regressione lineare (pesi $\beta_j$, intervalli di confidenza, LASSO per la sparsità), regressione logistica ($\log\frac y{1-y}=\beta_0+\sum\beta_jx_j$), alberi. Importanza nelle foreste: MDI $=\sum_{\text{nodi}}\frac{n_p}{n_{TOT}}\Delta Gini$ (con feature selection bias). Metodi agnostici: permutation importance (aumento dell'errore dopo aver mescolato una feature), PDP $\hat f_S(x_S)=\frac1n\sum_if(x_S,x_C^{(i)})$ (media delle curve ICE), LIME (modello semplice locale pesato sui punti perturbati), SHAP (valori di Shapley: media dei contributi marginali su tutti gli ordini, somma $=f(x)-f(\text{base})$). Per le reti profonde: mappe di salienza, Grad-CAM, occlusione. Valutazione: livello applicativo, umano, funzionale. Lab: cardiopatia AHD con logistica, LASSO, random forest, ICE, PDP, SHAP.Explainable AI (XAI) →). Gli adversarial examples ne sono l'esempio: sommando a un'immagine di un panda un rumore impercettibile la rete la classifica «gibbone» con il 99,3% di confidenza.
• Servono molti dati: si mitiga con transfer learning e domain adaptation. Sui dati tabulari gli alberi e i metodi ensemble (Metodi ensemble - bagging, random forest e boostingUn albero da solo ha varianza alta; un ensemble combina molti modelli deboli. Bagging: ogni albero è addestrato su un campione bootstrap (n estrazioni con rimpiazzo, circa il 63% di campioni distinti) e si vota o si fa la media: riduce la varianza, perché la media di $T$ stimatori con varianza $\sigma^2$ e correlazione $\rho$ ha varianza $\rho\sigma^2+(1-\rho)\sigma^2/T$. Random forest = bagging + a ogni split solo $\sqrt p$ feature casuali (alberi meno correlati); l'importanza di una feature è la somma delle riduzioni di Gini pesate sui nodi in cui è usata. Boosting: alberi in sequenza, ciascuno corregge gli errori dei precedenti, e si riduce il bias. Gradient boosting: $F\leftarrow F+\eta h$ con $h$ albero sui residui (gradiente negativo della perdita), $\eta$ piccolo; AdaBoost: stump e pesi sui campioni sbagliati; XGBoost: similarity score $\frac{(\sum r)^2}{N+\lambda}$, gain, potatura con $\gamma$, output $\frac{\sum r}{N+\lambda}$. Programma di Telecomunicazioni: Random Forests; boosting come approfondimento.Metodi ensemble - bagging, random forest e boosting →) spesso battono ancora il deep learning.

2. Il neurone

Il Perceptron (soglia)

Il primo modello (Rosenblatt, 1958) somma gli ingressi pesati e confronta con una soglia:

$$\text{uscita}=\begin{cases}0&\text{se }\sum_jw_jx_j<\text{soglia}\\1&\text{se }\sum_jw_jx_j\ge\text{soglia}.\end{cases}$$

Spostando la soglia a sinistra e chiamandola $-b$ si ottiene la forma con bias: $1$ se $w\cdot x+b\ge0$. È esattamente un halfspace, il classificatore lineare di 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 →. Limite: la funzione a gradino non è derivabile in $0$ e ha derivata nulla altrove, quindi non si può addestrare con la discesa del gradiente.

Il neurone generale

Definizione (neurone artificiale). Dato un vettore di ingressi $x=[x_1,\dots,x_m]^\top$, pesi $w=[w_1,\dots,w_m]^\top$, bias $w_0$ e una funzione di attivazione $g$ (non lineare) il neurone calcola $$\hat y=g\big(w_0+x^\top w\big),\qquad z=w_0+x^\top w\ \text{ (pre-attivazione)},\ \ a=g(z)\ \text{ (attivazione)}.$$

Con $g(z)=z$ si ha la regressione lineare; con $g=\sigma$ (sigmoide) la regressione logistica. Il bias $w_0$ trasla la soglia di attivazione; i pesi $w_j$ dicono quanto conta l'ingresso $j$.

Esempio. $x=(2,1)$, $w=(1,-0{,}5)$, $w_0=-0{,}2$, $g=\sigma$: $z=2-0{,}5-0{,}2=1{,}3$ e $\hat y=\sigma(1{,}3)=1/(1+e^{-1{,}3})\approx0{,}786$.

Perché serve la non linearità

Se $g$ fosse lineare, due strati in cascata darebbero ancora una funzione lineare: $W_2(W_1x+b_1)+b_2=(W_2W_1)\,x+(W_2b_1+b_2)$, che è un solo strato con matrice $W_2W_1$ e bias $W_2b_1+b_2$ (prodotto di matrici: Operazioni tra matriciLe matrici m×n formano uno spazio vettoriale (somma e prodotto per scalare elemento per elemento); il prodotto righe per colonne corrisponde alla composizione di funzioni lineari, è associativo ma non commutativo; la trasposta scambia righe e colonne e (AB)^T = B^T A^T.Operazioni tra matrici →). Una rete lineare profonda equivale a un solo strato, per quanto sia profonda. Le non linearità permettono di approssimare funzioni arbitrarie e, nell'immagine delle slide, di «piegare» lo spazio degli ingressi fino a rendere separabili con una retta dati aggrovigliati.

3. Funzioni di attivazione

Formula (attivazioni principali). Le quattro funzioni usate negli strati nascosti, con la derivata (serve alla backpropagation):

Esempio. $\sigma(0)=0{,}5$, $\sigma(2)=0{,}881$, $\sigma(-2)=0{,}119$; $\sigma'(0)=0{,}25$ (massimo), $\sigma'(5)=0{,}0066$. $\tanh(1)=0{,}762$ e $\tanh'(1)=1-0{,}762^2=0{,}42$.

Da dove vengono le derivate (regole di Regole di derivazioneDerivate delle funzioni elementari e delle loro inverse (arcsin, arctan, settcosh...) e regole di calcolo: linearità, prodotto (Leibniz), quoziente, funzione composta (regola della catena), funzione inversa, f(x)^g(x).Regole di derivazione → e Derivata - definizione e significatoLa derivata è il limite del rapporto incrementale; geometricamente è la pendenza della retta tangente. f è derivabile in x0 se e solo se f(x) = f(x0) + f'(x0)(x − x0) + o(x − x0); derivabile implica continua, non viceversa. Derivata destra e sinistra, punti angolosi, flessi a tangente verticale, cuspidi.Derivata - definizione e significato →). Per la sigmoide si scrive $\sigma(z)=(1+e^{-z})^{-1}$ e si deriva come potenza di una funzione composta: $\sigma'(z)=-(1+e^{-z})^{-2}\cdot(-e^{-z})=\dfrac{e^{-z}}{(1+e^{-z})^2}$. Si separa il quadrato in due fattori: $\dfrac1{1+e^{-z}}\cdot\dfrac{e^{-z}}{1+e^{-z}}$; il primo è $\sigma(z)$ e il secondo vale $\dfrac{1+e^{-z}-1}{1+e^{-z}}=1-\sigma(z)$, da cui $\sigma'=\sigma(1-\sigma)$. Poiché il prodotto $s(1-s)$ con $s\in(0,1)$ è massimo per $s=\frac12$ (vale $\frac14$), $\sigma'(z)\le0{,}25$ con massimo in $z=0$. Per la tangente iperbolica, derivando il quoziente $\tanh z=\frac{e^z-e^{-z}}{e^z+e^{-z}}$ con la regola $(N/D)'=(N'D-ND')/D^2$ e notando che $N'=D$, $D'=N$: $\tanh'z=\frac{D^2-N^2}{D^2}=1-\tanh^2z$.

Sigmoide. Si legge come probabilità. Difetti: (i) gradiente evanescente (vanishing gradient): per $|z|$ grande la curva è piatta e $g'\approx0$; poiché $g'\le0{,}25$, il gradiente moltiplicato attraverso $L$ strati sigmoidali scala al più come $0{,}25^{L}$ (con $L=10$ meno di $10^{-6}$) e i primi strati smettono di imparare; (ii) l'uscita non è centrata sullo zero e provoca aggiornamenti a zig-zag; (iii) l'esponenziale costa.

Tanh. Come la sigmoide ma centrata in zero ($\tanh(z)=2\sigma(2z)-1$). Soffre ancora di gradiente evanescente.

ReLU (rectified linear unit). Semplicissima, non satura per $z>0$ (derivata $1$, niente gradiente evanescente) e la discesa del gradiente converge molto più in fretta. Difetti: uscita non centrata e dead ReLU: se $z<0$ per tutti i dati il neurone ha gradiente nullo e non si riattiva più; con un learning rate troppo alto fino al 40% dei neuroni può «morire».

Leaky ReLU e PReLU. Per $z<0$ la pendenza non è zero ma $\alpha$: in Leaky ReLU è fissa (tipicamente $0{,}01$), in PReLU si impara con gli altri pesi, nella randomized Leaky ReLU si estrae a caso in un intervallo durante il training e si fissa al test. Non muoiono mai.

Regola pratica: negli strati nascosti usare ReLU (eventualmente con un bias iniziale lievemente positivo); se si hanno neuroni morti provare Leaky ReLU o PReLU; mai la sigmoide negli strati nascosti. La sigmoide e la softmax si usano solo nello strato di uscita.

4. Rete feed-forward (vanilla neural network)

Una rete feed-forward (FFNN, fully connected) è una pila di strati in cui ogni neurone di uno strato riceve tutte le uscite dello strato precedente e l'informazione va solo avanti (nessun ciclo). Strato di ingresso $\to$ uno o più strati nascosti (hidden) $\to$ strato di uscita.

Con un solo strato nascosto di $d_1$ neuroni e $m$ ingressi, le slide scrivono per ogni neurone $i$

$$z_i=w^{(1)}_{0,i}+\sum_{j=1}^{m}x_j\,w^{(1)}_{j,i},\qquad \hat y_i=g\Big(w^{(2)}_{0,i}+\sum_{j=1}^{d_1}g(z_j)\,w^{(2)}_{j,i}\Big).$$

Per $k$ strati la regola è la stessa, ripetuta: $z_{k,i}=w^{(k)}_{0,i}+\sum_{j=1}^{d_{k-1}}g(z_{k-1,j})\,w^{(k)}_{j,i}$.

Formula (forma matriciale). Con $a^{(0)}=x$ e, per ogni strato $k=1,\dots,L$, $$z^{(k)}=W^{(k)}a^{(k-1)}+b^{(k)},\qquad a^{(k)}=g^{(k)}\big(z^{(k)}\big),\qquad \hat y=a^{(L)}.$$ $W^{(k)}$ ha dimensione $d_k\times d_{k-1}$, $b^{(k)}$ ha $d_k$ componenti.

Il prodotto $W^{(k)}a^{(k-1)}$ è un prodotto matrice-vettore (Operazioni tra matriciLe matrici m×n formano uno spazio vettoriale (somma e prodotto per scalare elemento per elemento); il prodotto righe per colonne corrisponde alla composizione di funzioni lineari, è associativo ma non commutativo; la trasposta scambia righe e colonne e (AB)^T = B^T A^T.Operazioni tra matrici →): la componente $i$ è $\sum_jW^{(k)}_{ij}a_j^{(k-1)}$, cioè la formula neurone per neurone sopra. Il calcolo dall'ingresso all'uscita si chiama forward pass. È tutto prodotti matrice-vettore e funzioni applicate componente per componente, per questo le GPU lo eseguono bene.

Esempio numerico completo

Rete $2\to2\to1$: strato nascosto con ReLU, uscita con sigmoide. Pesi $W^{(1)}=\begin{bmatrix}1&-1\\0{,}5&2\end{bmatrix}$, $b^{(1)}=(0,-1)$, $w^{(2)}=(1,-0{,}5)$, $b^{(2)}=-0{,}2$. Ingresso $x=(2,1)$.

1. $z^{(1)}=W^{(1)}x+b^{(1)}=(1\cdot2-1\cdot1+0,\ 0{,}5\cdot2+2\cdot1-1)=(1,\ 2)$.
2. $a^{(1)}=\operatorname{ReLU}(z^{(1)})=(1,2)$ (entrambi positivi).
3. $z^{(2)}=w^{(2)}\cdot a^{(1)}+b^{(2)}=1\cdot1-0{,}5\cdot2-0{,}2=-0{,}2$.
4. $\hat y=\sigma(-0{,}2)=0{,}450$.

Contare i parametri

Uno strato denso con $n_{in}$ ingressi e $n_{out}$ uscite ha $n_{in}\,n_{out}$ pesi più $n_{out}$ bias.

Esempio (LAB MNIST). Immagini $28\times28$ appiattite in $784$ ingressi, strato nascosto da $512$ neuroni, uscita da $10$: $784\cdot512+512=401\,920$ e $512\cdot10+10=5\,130$, totale $407\,050$ parametri, come stampa model.summary(). Il Dropout e il Flatten non hanno parametri.

5. Universalità e profondità

Teorema (approssimazione universale). Una rete con un solo strato nascosto (sufficientemente largo) e attivazione non lineare può approssimare qualsiasi funzione continua su un insieme compatto con precisione arbitraria.

Il teorema dice che una soluzione esiste, non che sia facile trovarla né compatta: alcune funzioni richiedono con un solo strato un numero esponenziale di neuroni e invece sono rappresentate in modo compatto da $k$ strati successivi. Da qui il deep learning: la profondità dà feature gerarchiche. Nel riconoscimento di volti gli strati iniziali rilevano linee e bordi, quelli intermedi parti (occhi, naso, orecchie), gli ultimi strutture complete. In alternativa alle feature costruite a mano (semplici, interpretabili, ma poco espressive e non scalabili) le feature apprese si adattano al compito ma sono meno interpretabili e richiedono più dati.

6. Strato di uscita e funzione di perdita

L'uscita e la loss si scelgono dal tipo di problema:

Formula (softmax). Trasforma i punteggi grezzi (logits) $z_1,\dots,z_K$ in probabilità: $$\operatorname{softmax}(z)_i=\frac{e^{z_i}}{\sum_{j=1}^Ke^{z_j}}.$$ Ogni uscita sta in $(0,1)$ e la somma è $1$ (il numeratore è positivo ed è una parte del denominatore, che è la somma di tutti i numeratori). Si usa l'esponenziale (Esponenziale e logaritmoLa funzione esponenziale a^x (base positiva diversa da 1) e la sua inversa, il logaritmo in base a, con grafici e proprietà.Esponenziale e logaritmo →) perché è positivo, monotono (ordine dei punteggi conservato) e derivabile. Si veda 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 →.

Esempio. $z=(2,1,0)$: gli esponenziali sono $7{,}389;\ 2{,}718;\ 1$, somma $11{,}107$, quindi probabilità $(0{,}665;\ 0{,}245;\ 0{,}090)$.

Formula (cross-entropy). Con $y_i$ la distribuzione vera (one-hot) e $p_i$ quella predetta, la perdita di un campione è $-\sum_iy_i\log p_i$; nel caso binario $-[\,y\log p+(1-y)\log(1-p)\,]$. Penalizza molto una previsione sbagliata con alta confidenza. Su un campione di classe vera $2$ con probabilità predetta $0{,}245$ la perdita è $-\log0{,}245=1{,}41$.

Attenzione al segno: sulle slide la formula della cross-entropy binaria è scritta senza il meno davanti alla somma; la quantità che si minimizza è la log-verosimiglianza cambiata di segno, sempre non negativa. Con sparse_categorical_crossentropy di Keras le etichette sono interi ($0,\dots,K-1$), con categorical_crossentropy sono vettori one-hot: la formula è la stessa.

Più uscite (multi-output). Una rete può avere più teste che condividono gli strati iniziali, ciascuna con la sua loss: nel lab di Keras un modello di rischio di credito legge $30$ attributi e produce sia la probabilità di insolvenza (sigmoide, cross-entropy) sia la perdita attesa (lineare, MSE). Gli strati condivisi imparano una rappresentazione comune e un solo passaggio dà entrambe le uscite.

7. Una rete in Keras (laboratorio, MNIST)

Il dataset MNIST ha $70\,000$ immagini $28\times28$ in scala di grigi di cifre scritte a mano: $60\,000$ di training e $10\,000$ di test, $10$ classi. Si normalizzano i pixel dividendoli per $255$ per portarli in $[0,1]$ (scalare gli ingressi stabilizza l'addestramento).

import tensorflow as tf
from tensorflow.keras import Sequential, Input
from tensorflow.keras.layers import Flatten, Dense, Dropout

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = Sequential([
    Input(shape=(28, 28)),
    Flatten(),                        # 28x28 -> 784
    Dense(512, activation="relu"),    # 407 050 parametri in totale
    Dropout(0.2),
    Dense(10, activation="softmax"),  # una probabilità per cifra
])
model.compile(loss="sparse_categorical_crossentropy",
              optimizer="adam", metrics=["accuracy"])
history = model.fit(x_train, y_train, batch_size=32, epochs=10,
                    validation_split=0.1)   # 54 000 training, 6 000 validazione
model.evaluate(x_test, y_test)              # nel lab: accuratezza di test circa 0,98

• compile fissa loss, ottimizzatore e metriche; fit esegue l'addestramento; validation_split=0.1 riserva il $10\%$ del training come validazione; predict dà le probabilità e np.argmax(..., axis=1) la classe.
• Keras offre tre modi di costruire modelli: Sequential (pila lineare, quello usato qui), API funzionale (più ingressi/uscite, strati condivisi, connessioni residue: ogni strato è una funzione x = Dense(64)(x) e si crea Model(inputs, outputs)) e sottoclasse di tf.keras.Model (si definiscono __init__ e call, massima libertà e massimo rischio di errori).
• Pesi e modelli si salvano con model.save_weights / load_weights o model.save; durante l'addestramento una callback ModelCheckpoint li salva a ogni epoca.
• La matrice di confusione (Metriche di classificazioneIn classificazione binaria ogni previsione è vero positivo (TP), vero negativo (TN), falso positivo (FP, errore di tipo I) o falso negativo (FN, errore di tipo II). Da queste quattro quantità: accuracy $=\frac{TP+TN}{TP+TN+FP+FN}$, specificità $=\frac{TN}{TN+FP}$, precision $=\frac{TP}{TP+FP}$, recall $=\frac{TP}{TP+FN}$, e la loro media armonica $F_1=\frac{2PR}{P+R}$. Con dati sbilanciati l'accuracy inganna (un modello che predice sempre la classe maggioritaria ha 99%): si usano precision, recall, F1, ROC-AUC, la cross-validation stratificata e il riequilibrio con undersampling o oversampling (non SMOTE). Cambiando la soglia sulla probabilità si ottiene la curva ROC (TPR contro FPR) e l'area AUC. Approfondimento: non nel programma di Telecomunicazioni.Metriche di classificazione →) dice quali cifre si confondono; nel lab la si visualizza in scala logaritmica con np.log(1 + confusion_matrix(...)).

Esercizi: Esercizio - Forward pass e conteggio dei parametri di una rete, Esercizio - Rete feed-forward su MNIST con Keras, Esercizio - Rete feed-forward su dati tabulari sbilanciati (appello).

8. Errori tipici

• Usare la sigmoide negli strati nascosti di una rete profonda (gradiente evanescente) o la ReLU nello strato di uscita di un problema di classificazione.
• Mettere la softmax e poi una loss che la applica di nuovo (from_logits): in PyTorch CrossEntropyLoss applica già la softmax, quindi la rete deve produrre i logits.
• Dimenticare di normalizzare gli ingressi.
• Confondere epoca (un passaggio su tutto il training), batch e iterazione (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 →).
• Contare male i parametri: ricordare i bias, e che pooling, Flatten e Dropout non ne hanno.