Machine learning: dalla retta che impara all'agente che decide

Un programma di filtro antispam scritto a mano è un elenco di regole: «se contiene "vinci", è spam». Dopo la decima regola smette di funzionare. Che cosa fa di diverso un programma che impara?

Arthur Samuel, nel 1959, definì il machine learning come «il campo di studio che dà ai computer la capacità di imparare senza essere esplicitamente programmati». Il suo programma di dama giocò decine di migliaia di partite contro se stesso e, tenendo conto di quali posizioni portavano a vincere, finì per battere il suo autore. La differenza sta in chi scrive la regola. Nel programma tradizionale la scrive il programmatore.

I due grandi tipi di machine learning si distinguono per che cosa contengono i dati. Nell'apprendimento supervisionato ogni esempio è una coppia: un input x e la risposta giusta y, scritta da qualcuno. Email → spam o no; audio → trascrizione; immagine di un pezzo → difettoso o no; dati di una casa → prezzo di vendita. Il modello vede migliaia di coppie e impara a produrre y da x, così da farlo poi su x mai visti. È il tipo che produce più valore economico oggi, ed è la Parte I e II di questa guida.

Dentro il supervisionato ci sono due famiglie: la regressione, quando y è un numero tra infiniti possibili (un prezzo, una temperatura), e la classificazione, quando y è una tra poche categorie (spam/non spam, gatto/cane/cavallo, benigno/maligno).

Nell'apprendimento non supervisionato i dati hanno solo gli x: nessuno ha scritto la risposta, e il compito è trovare una struttura. Raggruppare clienti simili senza sapere in anticipo quali gruppi esistono (clustering, capitolo 11); segnalare la transazione che non somiglia a nessun'altra (rilevamento di anomalie, capitolo 12); comprimere molte variabili in poche (riduzione di dimensionalità).

Un terzo tipo, l'apprendimento per rinforzo (capitolo 14), non ha né le risposte né solo gli x: ha un agente che agisce e riceve ricompense, e deve scoprire da solo quali azioni le producono.

Per tutta la Parte I useremo un dataset minuscolo, abbastanza piccolo da seguire ogni numero: la superficie di alcune case vendute, in metri quadri, e il prezzo a cui sono state vendute, in migliaia di euro. È un problema di regressione supervisionata: abbiamo x (la superficie) e y (il prezzo), e vogliamo una funzione che, data la superficie di una casa nuova, ne stimi il prezzo.

Guardando i sei punti del dataset, un essere umano traccerebbe «a occhio» una retta che li attraversa e la userebbe per stimare il prezzo di una casa da 100 m². Come si traduce quell'«a occhio» in qualcosa che un programma può fare?

Prima si fissa la forma: una retta. Una retta è f(x) = w · x + b, dove w è la pendenza (quanti k€ in più per ogni m² in più) e b l'intercetta (il prezzo «di base» a superficie zero). w e b sono i parametri: i due numeri liberi del modello. Scegliere la retta significa scegliere w e b. Il modello si chiama regressione lineare a una variabile (o univariata), ed è il più semplice modello supervisionato: tutto ciò che impareremo dopo è una variazione di questo.

Poi serve un modo di dire quanto una retta è sbagliata, con un numero, perché solo un numero si può minimizzare. Per ogni esempio la retta stima ŷ⁽ⁱ⁾ = w·x⁽ⁱ⁾ + b, e il vero prezzo è y⁽ⁱ⁾: la differenza ŷ⁽ⁱ⁾ − y⁽ⁱ⁾ è l'errore (o residuo) su quell'esempio.

Il costo come paesaggio. Per ogni coppia (w, b) c'è un valore di J: se si disegna J al variare di w e b si ottiene una superficie a forma di ciotola, con un solo punto più basso. Per la regressione lineare con l'errore quadratico è sempre così (la funzione è convessa): non ci sono avvallamenti secondari in cui restare bloccati.

Tagliando la ciotola a quote fisse si ottengono le curve di livello, ellissi concentriche attorno al minimo: le useremo nel capitolo 4 per capire perché conviene scalare le feature.

Sei in una valle nebbiosa e devi raggiungere il punto più basso. Non vedi la valle: senti solo la pendenza del terreno sotto i piedi. Che cosa fai?

Fai un passo in discesa, nella direzione in cui il terreno scende di più; ti fermi, risenti la pendenza, fai un altro passo. È la discesa del gradiente (gradient descent), il procedimento che trova i parametri in quasi tutto il machine learning, dalle rette alle reti neurali con miliardi di pesi.

La «pendenza del terreno» ha un nome matematico: la derivata del costo rispetto a un parametro, ∂J/∂w, che dice di quanto cambierebbe J se aumentassi w di pochissimo. Positiva: salendo con w il costo sale, quindi w va diminuito. Negativa: va aumentato. Grande: siamo su un pendio ripido, lontani dal fondo. Vicina a zero: siamo quasi sul fondo.

Il gradiente è l'insieme delle derivate rispetto a tutti i parametri: la direzione di massima salita, e il suo opposto è la direzione di massima discesa.

Le derivate per la regressione lineare si calcolano a mano, ed è qui che il 2 nel denominatore di J ripaga:

Leggile così: la derivata rispetto a b è l'errore medio (se in media stimiamo troppo alto, b scende); quella rispetto a w è l'errore medio pesato per x (gli esempi con x grande spostano di più la pendenza). Questa versione, che a ogni passo usa tutti gli m esempi, si chiama batch gradient descent.

Il laboratorio mostra tutte e tre le situazioni sulla ciotola del nostro dataset, con b tenuto fermo al suo valore ottimo per poter disegnare J in due dimensioni.

Una casa non ha solo la superficie: ha il numero di stanze, il piano, l'età. Come si estende la retta a quattro input? E perché, appena lo si fa, la discesa del gradiente comincia a comportarsi male?

La forma resta lineare: ogni feature ha il suo peso, f(x) = w₁x₁ + w₂x₂ + w₃x₃ + w₄x₄ + b. Si scrive in modo compatto raccogliendo le feature in un vettore x = [x₁, x₂, x₃, x₄] e i pesi in un vettore w: f(x) = w · x + b, dove il punto è il prodotto scalare (si moltiplicano le componenti a coppie e si sommano).

Ogni peso ha un significato leggibile: w₂ = 15 dice «ogni stanza in più vale 15 k€, a parità del resto»; un w₄ negativo dice che l'età abbassa il prezzo.

Il modello si chiama regressione lineare multipla (non «multivariata», che indica più output).

Vettorizzazione. Il prodotto scalare si può scrivere come un ciclo for su n feature, oppure come np.dot(w, x) + b. La seconda forma non è solo più corta: NumPy la esegue con istruzioni del processore che moltiplicano molte coppie in parallelo e sommano in blocco, e con n grande la differenza è di decine di volte.

La stessa idea vale per il gradiente: i Σ su tutti gli esempi diventano prodotti tra matrici, ed è così che il training di una rete neurale su GPU diventa possibile. Le derivate della discesa del gradiente restano quelle del capitolo 3, una per ogni w_j: ∂J/∂w_j = 1/m · Σ (f(x⁽ⁱ⁾) − y⁽ⁱ⁾) · x_j⁽ⁱ⁾.

La superficie va da 50 a 130, il numero di stanze da 1 a 5. Perché questo dovrebbe disturbare la discesa del gradiente?

Perché il peso di una feature grande deve essere piccolo e viceversa: se x₁ (superficie) vale 100 e x₂ (stanze) vale 3, un w₁ = 2 sposta il prezzo di 200 mentre un w₂ = 2 lo sposta di 6. La ciotola del costo diventa allora una valle stretta e lunga: ripidissima lungo w₁ (basta un filo per cambiare molto il prezzo), piattissima lungo w₂.

La discesa del gradiente, che segue la pendenza locale, rimbalza da una parete all'altra della valle stretta facendo passi minuscoli lungo l'asse lungo: serve un α piccolo per non divergere su w₁, e con quell'α lungo w₂ si impiega un'eternità.

Il rimedio è portare tutte le feature su una scala simile, tipicamente intorno a [−1, 1].

La normalizzazione per media sulle case del capitolo 1. Le superfici sono 50, 65, 80, 95, 110 e 130 m². Servono tre numeri, tutti calcolati sul training set: il minimo (50), il massimo (130) e la media vera μ. Il denominatore è l'ampiezza dell'intervallo, max − min.

Ogni superficie diventa x′ (la colonna centrale è lo scarto x − μ, quella a destra il valore scalato x′):

Che cosa si nota. La media delle x′ è esattamente 0: sottrarre μ sposta il centro dei dati sullo zero. I valori vanno da −0,479 a 0,521, un intervallo largo esattamente 1, perché si è diviso proprio per l'ampiezza max − min; non è quindi [−1, 1] pieno, ma un tratto largo 1 che sta dentro [−1, 1] e che è simmetrico solo se i dati lo sono.

Qui la casa più piccola è più vicina alla media di quella più grande (38 m² contro 42), e infatti −0,479 è più vicino a zero di 0,521.

Se al posto di μ si usasse il punto medio tra minimo e massimo, si otterrebbe un [−0,5, 0,5] perfetto, ma la media delle x′ non sarebbe più zero: per questo serve la media vera e non bastano minimo e massimo.

Una casa nuova di 150 m² diventa:

Anche se supera il massimo del training set: non si ricalcolano minimo e massimo con la casa nuova.

Il grafico da guardare sempre è J in funzione del numero di iterazioni (la curva di apprendimento): se la discesa funziona, scende a ogni passo e poi si appiattisce. Se sale, anche solo a tratti, α è troppo grande (o c'è un errore nel codice: con α abbastanza piccolo J deve scendere a ogni iterazione).

Un metodo pratico per scegliere α: provare valori distanziati di circa tre volte, 0,001, 0,003, 0,01, 0,03, 0,1…, scegliere il più grande che fa ancora scendere J in modo regolare, o poco meno. Quando J scende di meno di una soglia (per esempio 0,001) in un'iterazione si può dichiarare la convergenza, ma guardare il grafico è più affidabile di qualsiasi soglia.

Il modello è lineare nei parametri, non necessariamente nei dati: nessuno vieta di costruire nuove feature dalle vecchie. Se hai la larghezza e la profondità del lotto, la feature che conta è probabilmente l'area, larghezza × profondità: creala e dalla al modello.

Se la relazione tra superficie e prezzo non è una retta ma si piega, aggiungi x² e x³ come feature: f(x) = w₁x + w₂x² + w₃x³ + b è ancora una regressione lineare (nei w), ma disegna una curva. È la regressione polinomiale, e qui lo scaling diventa indispensabile: se x va fino a 130, x² arriva a 17.000 e x³ a due milioni.

Scegliere le feature giuste, con la conoscenza del problema, è spesso ciò che fa la differenza tra un modello mediocre e uno buono; nel capitolo 7 vedremo che le reti neurali imparano da sole feature intermedie, ed è il motivo del loro successo.

Un tumore è maligno (1) o benigno (0), e conosciamo la sua dimensione. Perché non usare la retta del capitolo 2, con una soglia a 0,5?

Perché la retta non sa che y è una categoria. Funziona finché i dati sono «comodi», ma basta aggiungere un esempio di tumore molto grande, chiaramente maligno, perché la retta si inclini per inseguirlo, sposti la soglia a destra e cominci a classificare come benigni tumori che prima classificava bene.

Inoltre produce valori sotto 0 e sopra 1, che come «probabilità di essere maligno» non significano nulla. Serve un modello che produca sempre un numero tra 0 e 1 e che non si lasci trascinare dagli esempi estremi.

La regressione logistica (che, nonostante il nome, è un algoritmo di classificazione) prende la stessa combinazione lineare z = w·x + b e la passa attraverso la funzione sigmoide, g(z) = 1 / (1 + e^−z): una S che vale 0,5 per z = 0, tende a 1 per z grande e a 0 per z molto negativo. L'uscita f(x) = g(w·x + b) si legge come la probabilità che y sia 1 dato x: f = 0,7 vuol dire «70% maligno».

Per decidere si confronta con una soglia, di solito 0,5: f ≥ 0,5 equivale a z ≥ 0, cioè w·x + b ≥ 0. L'insieme dei punti in cui w·x + b = 0 è il confine di decisione (decision boundary): una retta se le feature sono due, un piano se tre; e con feature polinomiali (x₁², x₂²…) diventa un cerchio o una forma qualsiasi, come nel capitolo 4.

Serve una misura dell'errore pensata per le probabilità. Per un singolo esempio, la perdita (loss) della regressione logistica è −log(f(x)) se y = 1 e −log(1 − f(x)) se y = 0. Leggila:

Più il modello è sicuro della cosa sbagliata, più la perdita cresce, senza limite. Le due righe si scrivono in una sola, perché y vale 0 o 1: L = −y·log(f) − (1 − y)·log(1 − f). Il costo J è la media delle perdite sugli m esempi, e con questa scelta torna a essere convesso: un solo minimo. (Nel capitolo 2 della guida sul training degli LLM la stessa funzione, chiamata cross-entropy, è la loss con cui si addestrano i modelli linguistici.)

Il colpo di scena è nella discesa del gradiente: le derivate hanno la stessa identica forma della regressione lineare:

Cambia solo che cosa è f: w·x + b prima, g(w·x + b) ora. Tutto il resto (vettorizzazione, scaling, controllo della curva di J, scelta di α) si trasferisce senza modifiche.

Un polinomio di grado 5 passa esattamente per tutti e sei i punti del dataset: costo zero. È il modello migliore?

No, e si vede appena arriva una casa nuova: la curva che si contorce per toccare ogni punto del training set stima prezzi assurdi tra un punto e l'altro. Ha imparato il rumore dei sei esempi, non la relazione tra superficie e prezzo.

Si dice che il modello ha overfit (si è sovradattato) o che ha alta varianza: cambiando di poco i dati di training, la curva cambierebbe moltissimo.

All'estremo opposto c'è l'underfit, o alto bias: una retta su dati che si piegano ha un pregiudizio (la relazione è lineare) che i dati non confermano, e sbaglia sia sul training set sia sui dati nuovi. Il modello che generalizza sta nel mezzo: va bene sui dati di training e quasi altrettanto bene su quelli mai visti. Lo stesso accade nella classificazione: un confine di decisione che si avvolge attorno a ogni singolo esempio ha overfit.

L'idea è aggiungere al costo un termine che cresce con la grandezza dei pesi:

Il primo pezzo chiede di adattarsi ai dati, il secondo di tenere i w piccoli; λ (lambda, il parametro di regolarizzazione) decide il compromesso.

λ = 0: nessuna tassa, si torna all'overfitting. λ enorme: tutti i w vengono schiacciati a zero e resta f = b, una retta orizzontale, underfitting. Nel mezzo c'è il valore giusto, e il capitolo 9 spiega come sceglierlo con i dati. Per convenzione b non si regolarizza: non cambia la forma della curva, solo la sua altezza.

Nella discesa del gradiente il termine aggiunge λ/m · w_j alla derivata, e la regola di aggiornamento diventa:

A ogni passo ogni peso viene prima moltiplicato per un numero appena sotto 1 (per esempio 0,9998) e poi aggiornato come sempre. La regolarizzazione è letteralmente un restringimento continuo dei pesi, che il termine dei dati contrasta solo dove serve davvero. Per la regressione logistica è identico: stessa tassa, stesso restringimento.

Nel capitolo 4 le feature utili (l'area del lotto, x²) le abbiamo costruite noi. Per riconoscere un volto in una foto di un milione di pixel, quali feature costruiresti a mano? E se fosse il modello a inventarle?

Una rete neurale fa esattamente questo, con una differenza: le tre grandezze intermedie non le definisce nessuno. Il modello ha tre «unità» che ricevono tutte e quattro le feature e imparano, durante il training, quali combinazioni calcolare perché la previsione finale funzioni. Noi, dopo, possiamo guardarle e dar loro un nome; la rete non ne ha bisogno.

Ogni unità, o neurone, è una regressione logistica del capitolo 5: prende i suoi input, calcola z = w·x + b, applica una funzione di attivazione g (per ora la sigmoide) e produce un numero a, l'attivazione.

Un gruppo di neuroni che ricevono gli stessi input è uno strato (layer); l'uscita di uno strato è l'input del successivo. Lo strato finale produce la previsione; quelli in mezzo si chiamano nascosti (hidden), perché il training set non dice che cosa debbano calcolare: contiene solo gli x e le y, e i valori intermedi li decide la rete.

In una rete per il riconoscimento dei volti, i neuroni dei primi strati finiscono per reagire a bordi e linee corte, quelli successivi a occhi e nasi, gli ultimi a forme di volto intere: una gerarchia di feature che nessuno ha programmato.

La notazione mette tra parentesi quadre l'indice dello strato: a^[1] è il vettore delle attivazioni dello strato 1, a₂^[1] quella del suo secondo neurone, W^[1] e b^[1] i suoi parametri; l'input x si può chiamare a^[0]. Lo strato l calcola, per ciascun neurone j:

Fare questo calcolo strato dopo strato, dall'input all'uscita, si chiama forward propagation (propagazione in avanti) ed è ciò che la rete fa in inferenza, quando è già addestrata e deve rispondere. Tutti i neuroni di uno strato si calcolano insieme con un prodotto tra matrici:

È la vettorizzazione del capitolo 4, ed è il motivo per cui le reti girano bene su GPU.

Il laboratorio allena davvero una rete piccola su dati che nessuna retta può separare; guarda nascere il confine e le rette dei singoli neuroni nascosti.

In TensorFlow addestrare una rete sono tre righe: model = Sequential([...]), model.compile(loss=...), model.fit(X, Y, epochs=100). Che cosa fanno davvero quelle tre righe?

Sono le tre mosse della regressione logistica. La prima definisce il modello: quanti strati, quanti neuroni, quali attivazioni, cioè la funzione f(x) con i suoi parametri. La seconda sceglie il costo: per una classificazione binaria la binary cross-entropy, che è esattamente la perdita logistica del capitolo 5 (−y log f − (1−y) log(1−f)) mediata sugli esempi; per una regressione l'errore quadratico. La terza minimizza il costo con la discesa del gradiente per il numero di epoche indicato (un'epoca = un passaggio su tutto il training set).

La libreria calcola le derivate rispetto a tutti i parametri con la backpropagation, la regola della catena applicata all'indietro strato per strato; è la stessa cosa che il laboratorio del capitolo 7 fa a mano per una rete piccola, e la guida sul training degli LLM la spiega passo per passo.

Quando il gradiente non c'è, perché l'unico segnale è un punteggio che arriva alla fine di una prova e non è derivabile rispetto ai pesi, si può farne a meno: la guida Neural Network Driving allena una rete piccola come quella del capitolo 7 per evoluzione, facendo competere molte copie e ricombinando i pesi delle migliori.

Tre attivazioni coprono quasi tutto. La sigmoide, tra 0 e 1, va bene quando l'uscita è una probabilità: il neurone finale di una classificazione binaria. La lineare (g(z) = z, cioè nessuna attivazione) serve quando l'uscita è un numero qualsiasi, positivo o negativo: una regressione.

La ReLU (Rectified Linear Unit, g(z) = max(0, z)) è la scelta di default per gli strati nascosti, per due ragioni: è più veloce da calcolare, e soprattutto non si «appiattisce» a destra come la sigmoide, che per z grande ha derivata quasi zero e rende la discesa del gradiente lentissima. Per uscite che devono essere non negative (un prezzo) va bene la ReLU anche in uscita.

Riconoscere le cifre scritte a mano ha dieci risposte possibili, non due. Come si generalizza la sigmoide?

Con la softmax. Lo strato di uscita ha un neurone per classe, ciascuno con la sua z_j = w_j·a + b_j; la softmax trasforma le N z in probabilità che sommano a 1:

La perdita è la cross-entropy: −log a_y, il logaritmo negativo della probabilità data alla classe vera; se la classe vera era la 3 e il modello le dà:

A differenza delle altre attivazioni, qui ogni uscita dipende da tutte le z: alzare una abbassa le altre.

Un dettaglio pratico che conta: calcolare e^z per z grandi e poi il logaritmo produce errori di arrotondamento. Le librerie permettono di far uscire dalla rete le z grezze (attivazione lineare) e di dire alla loss di applicare la softmax internamente (from_logits=True), riorganizzando i conti in modo più stabile. Il risultato è lo stesso, i numeri sono più precisi.

Adam (Adaptive Moment Estimation) è la discesa del gradiente con un learning rate per parametro, che si adatta da solo: se un parametro continua a muoversi nella stessa direzione passo dopo passo, il suo α cresce (si può andare più in fretta); se oscilla avanti e indietro, il suo α si riduce. In pratica è più robusto della discesa semplice alla scelta di α iniziale ed è l'ottimizzatore di default per quasi tutto; si parte di solito da 10⁻³.

Negli strati convoluzionali, infine, ogni neurone guarda solo una finestra dell'input (un pezzo di immagine, un tratto di segnale) invece che tutto: meno parametri, meno overfitting, e la capacità di riconoscere un motivo ovunque compaia. Sono il mattone delle reti per immagini (CNN, Convolutional Neural Network); qui basta sapere che esistono e perché.

Il modello della casa sbaglia di 60 k€ su case nuove. Potresti raccogliere più dati, aggiungere feature, toglierne, cambiare λ, cambiare rete. Ciascuna scelta costa settimane: quale fare?

La risposta sbagliata è «proviamole tutte». Quella giusta è misurare due numeri che dicono di che male soffre il modello, perché i rimedi per i due mali sono opposti. Per misurarli servono dati che il modello non ha usato per imparare: si divide il dataset in training set (per esempio il 60%), con cui si trovano i parametri, cross-validation set (20%, detto anche validation o dev set), con cui si scelgono grado del polinomio, λ, architettura della rete, e test set (20%), toccato una volta sola alla fine per stimare quanto il modello finale sbaglierà nel mondo.

Il capitolo 6 ha dato i nomi: alto bias (underfitting) e alta varianza (overfitting). Due numeri li distinguono. J_train alto significa che il modello non riesce nemmeno a imparare gli esempi che vede: alto bias. J_train basso ma J_cv molto più alto significa che li ha imparati ma non generalizza: alta varianza. Possono anche coesistere, in parti diverse dello spazio: J_train alto e J_cv ancora più alto.

«Alto» rispetto a che cosa? Rispetto a una baseline: le prestazioni umane sullo stesso compito, un modello concorrente, o una stima di quanto il rumore dei dati renda impossibile scendere.

Da qui la tabella delle decisioni, che è il cuore pratico di tutto il corso. Alta varianza: più dati di training, meno feature, λ più grande. Alto bias: più feature o feature polinomiali, λ più piccolo, un modello più grande.

Le curve di apprendimento rendono la diagnosi visiva: J_train e J_cv in funzione del numero di esempi m. Con pochi esempi J_train è quasi zero (facile adattarsi a due punti) e J_cv altissimo; crescendo m, J_train sale e J_cv scende.

Con alto bias le due curve si avvicinano presto e si appiattiscono alte: aggiungere dati non serve. Con alta varianza resta un divario largo tra le due che si chiude lentamente: qui i dati servono eccome. Il laboratorio le calcola davvero, adattando un polinomio a dataset sempre più grandi.

Con le reti neurali il compromesso tra bias e varianza si allenta. Una rete grande, con una regolarizzazione scelta bene, fa almeno bene quanto una piccola: il costo è solo computazionale.

Da qui una ricetta: se J_train è alto rispetto alla baseline, rete più grande (più strati o più neuroni), finché J_train non scende; poi, se J_cv è alto, più dati, e si ricomincia. La regolarizzazione in una rete è la stessa tassa λ·Σw² del capitolo 6, applicata ai pesi di ogni strato (kernel_regularizer=L2(0.01) in TensorFlow).

Un progetto reale gira in un ciclo: si sceglie l'architettura (modello, dati, iperparametri), si addestra, si fanno le diagnosi (bias/varianza e analisi degli errori), si decide che cosa cambiare, e si ricomincia. L'analisi degli errori è il complemento umano della diagnosi numerica: si prendono 100 esempi del cross-validation set sbagliati dal modello, si leggono uno per uno e si contano per categoria.

Se gli errori sono migliaia se ne campiona un centinaio: l'analisi manuale è lenta ma è lo strumento che evita mesi di lavoro su problemi irrilevanti.

Aggiungere dati con criterio. Non «più dati di tutto», ma più dati del tipo che l'analisi degli errori indica.

Due strumenti: la data augmentation, cioè creare esempi nuovi trasformando quelli esistenti in modo realistico (ruotare, ingrandire, distorcere una lettera scritta a mano; aggiungere rumore di fondo a un audio: distorsioni che il modello incontrerà davvero, non rumore casuale sui pixel), e la sintesi, cioè generare dati artificiali da zero (testo reso con font diversi su sfondi fotografati, per il riconoscimento di scritte).

Negli ultimi anni l'attenzione si è spostata dal modello ai dati (data-centric AI): spesso il miglioramento più grande viene da dati migliori, non da un algoritmo diverso.

Transfer learning. Se di dati ne hai pochi, puoi partire da una rete addestrata da altri su un compito vicino con milioni di esempi (riconoscere oggetti generici) e riaddestrare solo l'ultimo strato sui tuoi dati, o tutta la rete con un learning rate piccolo (fine-tuning).

Funziona perché i primi strati hanno imparato feature generali (bordi, forme) che servono anche a te; richiede che l'input sia dello stesso tipo (immagini con immagini, audio con audio). È il modo in cui, su scala enorme, si addestrano gli assistenti linguistici a partire da un modello pre-addestrato.

Una malattia rara colpisce lo 0,5% dei pazienti. Un «modello» che dice sempre «sano» ha il 99,5% di accuratezza. Come si smaschera?

Con due misure che l'accuratezza nasconde. Dividendo le previsioni in veri positivi (TP), falsi positivi (FP), falsi negativi (FN) e veri negativi (TN), la precisione è TP/(TP+FP): di quelli che ho detto malati, quanti lo erano; il recall è TP/(TP+FN): dei malati veri, quanti ne ho trovati. Il modello «sempre sano» ha recall zero, e il trucco è scoperto.

Le due misure tirano in direzioni opposte, e la leva è la soglia sulla probabilità: alzarla sopra 0,5 (dire «malato» solo se molto sicuri) aumenta la precisione e abbassa il recall; abbassarla fa il contrario. La scelta dipende dai costi: una malattia curabile con un trattamento pesante chiede alta precisione; una malattia grave da non lasciar passare chiede alto recall.

Per confrontare modelli con un solo numero si usa l'F1, la media armonica di precisione e recall, che punisce i valori sbilanciati:

Devi riconoscere se un animale è un gatto da tre indizi: forma delle orecchie, forma del muso, presenza dei baffi. Quale domanda fai per prima?

Un albero di decisione è esattamente questo: un nodo radice con una domanda su una feature, rami per le risposte, altri nodi con altre domande, e in fondo le foglie con la previsione. Per classificare un esempio nuovo si parte dalla radice e si seguono le risposte.

Il problema dell'apprendimento è costruire l'albero dai dati: quale feature mettere in ogni nodo, e quando fermarsi. Il criterio è la purezza: la domanda migliore è quella che divide gli esempi in gruppi il più possibile omogenei (tutti gatti da una parte, nessun gatto dall'altra). Per misurarla serve un numero.

L'entropia misura il disordine di un gruppo. Se p₁ è la frazione di gatti nel gruppo:

Vale 0 se il gruppo è tutto gatti o tutto non-gatti (ordine perfetto), vale 1 (il massimo) se è metà e metà.

Il logaritmo in base 2 fa sì che l'entropia si misuri in bit, ma la base non cambia quale split è migliore.

Una domanda divide il gruppo in due sottogruppi, sinistro e destro, ciascuno con la sua entropia. Il guadagno di informazione (information gain) è di quanto l'entropia scende grazie alla domanda:

La media è pesata perché un sottogruppo purissimo ma con un solo esempio conta poco. L'algoritmo calcola il guadagno per ogni feature disponibile, sceglie la più alta, e ripete ricorsivamente su ciascun ramo con gli esempi che vi sono finiti, finché un criterio di arresto non lo ferma: il nodo è puro, l'albero ha raggiunto la profondità massima, il guadagno è sotto una soglia, o gli esempi nel nodo sono troppo pochi.

Questi criteri sono il controllo dell'overfitting: un albero lasciato crescere fino a foglie con un esempio ciascuna ha imparato il training set a memoria.

Se una feature ha tre valori (orecchie a punta, flosce, ovali) si può aprire un nodo a tre rami, oppure, più comodo per gli algoritmi che vogliono domande sì/no, trasformarla in tre feature binarie con il one-hot encoding: «a punta?», «flosce?», «ovali?», di cui una sola vale 1. Lo stesso trucco serve alle reti neurali, che vogliono numeri in ingresso.

Una feature continua (il peso dell'animale) diventa una domanda con soglia, «peso ≤ 9 kg?»: l'algoritmo prova come soglia tutti i punti a metà tra due valori consecutivi presenti nei dati e tiene quella con il guadagno più alto.

Infine un albero di regressione prevede un numero: le foglie contengono la media dei y degli esempi finiti lì, e al posto dell'entropia si usa la varianza dei y, scegliendo lo split che la riduce di più, con la stessa media pesata.

Un albero singolo è fragile: basta cambiare un esempio del training set perché la domanda alla radice cambi e con lei l'intero albero. Come lo si rende stabile?

Allenandone tanti, diversi, e facendoli votare: un ensemble. La diversità si ottiene con il campionamento con reinserimento: da m esempi se ne estraggono m a caso, rimettendo ogni volta l'estratto nell'urna, così alcuni compaiono due o tre volte e altri mai; ogni albero è allenato su un campione diverso. Con B alberi (64, 100, 128: oltre il guadagno si appiattisce) si ha il bagged decision tree.

La random forest aggiunge un secondo elemento di diversità: a ogni nodo l'albero può scegliere solo tra un sottoinsieme casuale di k feature, tipicamente k ≈ √n, così gli alberi non finiscono tutti per usare la stessa feature forte alla radice. Il voto di molti alberi un po' diversi riduce la varianza senza aumentare il bias.

Il boosting cambia il modo di scegliere i campioni: invece che a caso, dopo ogni albero si guardano gli esempi che l'ensemble sbaglia ancora e si rende più probabile estrarli per l'albero successivo, che quindi si concentra sui casi difficili, come uno studente che ripassa solo gli esercizi sbagliati.

XGBoost (eXtreme Gradient Boosting) è l'implementazione che domina le competizioni su dati tabellari: veloce, con regolarizzazione e criteri di arresto buoni per default, e un'interfaccia di due righe (XGBClassifier().fit(X, y)).

Hai le misure di mille clienti (quanto spendono, quanto spesso) e vuoi dividerli in tre gruppi per tre campagne. Nessuno ti ha detto quali sono i gruppi: come li trovi?

Con il primo algoritmo non supervisionato della guida, k-means. L'idea è di una semplicità disarmante, e si capisce guardandola girare. Si scelgono K punti a caso, i centroidi, uno per gruppo.

Poi si ripetono due mosse. Assegna: ogni esempio viene assegnato al centroide più vicino. Sposta: ogni centroide si trasferisce nel baricentro (la media) degli esempi che gli sono stati assegnati. Si ripete finché i centroidi smettono di muoversi.

Dopo poche iterazioni i centroidi si sono sistemati nel mezzo dei gruppi, anche se all'inizio erano in posizioni assurde; e funziona anche quando i gruppi non sono ben separati (le taglie di una maglietta su un continuo di altezze e pesi: S, M, L sono un k-means con K = 3).

Dietro le due mosse c'è una funzione di costo, come sempre: la distorsione, la media delle distanze al quadrato tra ogni esempio e il centroide a cui è assegnato:

La mossa «assegna» la minimizza rispetto alle assegnazioni tenendo fermi i centroidi; la mossa «sposta» la minimizza rispetto ai centroidi tenendo ferme le assegnazioni. Per questo J non può mai salire da un'iterazione all'altra, e se sale c'è un errore nel codice. Se un centroide resta senza punti, lo si elimina o lo si reinizializza.

Il risultato dipende da dove partono i centroidi: inizializzazioni diverse portano a minimi locali diversi, alcuni chiaramente peggiori (due centroidi che si dividono un gruppo e un terzo che ne copre due). La pratica standard: scegliere i centroidi iniziali tra gli esempi stessi (K punti a caso del dataset), eseguire k-means 50–1.000 volte con inizializzazioni diverse, e tenere la soluzione con la distorsione J più bassa. Costa poco e toglie quasi sempre i minimi cattivi.

Il metodo del gomito disegna J in funzione di K e cerca il punto in cui smette di scendere in fretta; spesso il gomito non c'è. Il criterio migliore è lo scopo a valle: tre taglie o cinque? Dipende da quanto costa produrne cinque e quanto meglio vestono. K si sceglie per come verranno usati i cluster, non per una statistica.

Hai i dati di mille motori d'aereo appena prodotti: vibrazione, temperatura, consumo. Quasi tutti sono buoni; non sai quali no, e i difettosi sono pochi e tutti diversi. Come li segnali?

Non con la classificazione: per addestrare un classificatore servirebbero molti esempi di difetti, e di ogni tipo di difetto, mentre i difetti futuri saranno diversi da quelli passati.

Il rilevamento di anomalie rovescia il problema: impara com'è fatto un motore normale, con un modello di probabilità p(x) stimato sugli esempi, e segnala come anomalo tutto ciò che il modello ritiene molto improbabile, p(x) < ε. Non serve sapere che forma avrà il prossimo difetto: basta che non somigli al normale.

Lo stesso schema vale per le frodi (comportamenti anomali di un account), il monitoraggio dei server, i controlli di qualità.

Il modello più semplice per «com'è fatto il normale» è la distribuzione gaussiana (o normale), la campana: ha un centro μ (la media) e una larghezza σ (la deviazione standard), e la probabilità di un valore x decresce con il quadrato della sua distanza dal centro, misurata in σ:

Stimare μ e σ dai dati è un calcolo diretto: μ è la media dei valori, σ² la media dei quadrati degli scarti. Con n feature si stima una gaussiana per ciascuna e si moltiplicano:

È un'ipotesi di indipendenza che quasi mai è vera, e che in pratica funziona lo stesso: un motore con vibrazione un po' alta e temperatura un po' alta ha una p piccola per effetto del prodotto, anche se nessuna delle due da sola sarebbe anomala.

Scegliere ε, e valutare. Anche se il training è non supervisionato (solo esempi normali), per scegliere la soglia servono alcuni esempi anomali etichettati, pochi: si mettono nel cross-validation set insieme a molti normali, si prova una gamma di ε e si tiene quello con la F1 migliore (le anomalie sono rare: precisione e recall, non accuratezza, come nel capitolo 9). Il test set, se i difetti bastano, funziona uguale.

Le feature contano più dell'algoritmo. Se una feature ha una distribuzione molto lontana dalla campana (una coda lunga a destra), una trasformazione la rende più gaussiana: log(x), log(x + c), √x, x^1/3; si prova a occhio con l'istogramma.

E quando un'anomalia sfugge perché le sue feature prese una per una sono normali, si costruisce una feature che la cattura: un server con CPU normale e traffico normale ma CPU/traffico altissimo (un processo bloccato in un ciclo) si vede solo con il rapporto. È lo stesso lavoro del capitolo 4, con lo stesso effetto decisivo.

Hai una tabella utenti × film con i voti da 0 a 5, piena di buchi. Come riempi i buchi, cioè come prevedi quanto piacerebbe a Alice un film che non ha mai visto?

Se dei film conoscessi delle feature (quanto è romantico, quanto è d'azione), il problema sarebbe una regressione lineare per ogni utente: i parametri w^(j), b^(j) di Alice si imparano dai voti che ha dato, e il voto previsto per il film i è w^(j)·x⁽ⁱ⁾ + b^(j). Il costo è l'errore quadratico sui soli voti esistenti (r(i,j) = 1), con la regolarizzazione.

Ma le feature dei film, nella realtà, nessuno le ha scritte. E qui c'è un'idea bella: se conoscessi i gusti degli utenti (i loro w), potresti dedurre le feature di ogni film dai voti ricevuti, con la stessa regressione al contrario.

Non conosciamo né gli uni né le altre: il filtro collaborativo (collaborative filtering) li impara insieme, minimizzando un unico costo rispetto a tutti i w^(j), b^(j) e x⁽ⁱ⁾ contemporaneamente, con la discesa del gradiente. Funziona perché gli utenti collaborano senza saperlo: i voti di molti su un film lo descrivono, e i voti di uno su molti film lo descrivono.

Voti binari. Spesso non ci sono stelle ma segnali sì/no: ha cliccato, ha comprato, ha guardato fino in fondo. Lo stesso modello passa da regressione a classificazione come nel capitolo 5: la previsione diventa g(w·x + b) con la sigmoide e il costo diventa la perdita logistica.

In TensorFlow il costo si scrive in poche righe e le derivate le calcola tf.GradientTape: è la discesa del gradiente «a mano», senza strati Dense, perché il modello non è una rete.

Il filtro collaborativo usa solo i voti. Ma di utenti e film si sa altro: età, paese, genere; anno, attori, durata. Il filtro basato sul contenuto usa due reti neurali: una trasforma le feature dell'utente in un vettore v_u, l'altra le feature del film in un vettore v_m della stessa lunghezza, e il voto previsto è il prodotto scalare v_u·v_m. Le due reti si addestrano insieme sui voti esistenti: è la stessa architettura «a due torri» che si usa per il retrieval nei sistemi di ricerca.

Il vantaggio sul collaborativo è che funziona anche per un film nuovo senza voti (ha pure lui le feature) e per un utente nuovo.

Con milioni di film non si calcola il prodotto per tutti a ogni richiesta: si fa retrieval e ranking, prima si pescano poche centinaia di candidati plausibili (i film simili agli ultimi visti, i più popolari nel genere preferito, con i v_m precalcolati), poi si ordinano solo quelli con il modello completo.

PCA, per guardare i dati. Chiude il capitolo l'analisi delle componenti principali (Principal Component Analysis): dato un dataset con 50 feature, trova i pochi assi (2 o 3) lungo i quali i dati variano di più e li proietta su quelli, perdendo meno informazione possibile. Serve soprattutto per visualizzare: un grafico a due dimensioni di dati che ne avevano cinquanta.

Non è un passo di pre-elaborazione raccomandato per il training (le reti e gli alberi gestiscono bene molte feature), ma è lo strumento per vedere se i cluster del capitolo 11 esistono davvero.

Devi far atterrare un elicottero autonomo. Non esiste un dataset di «stato → comando giusto»: nessuno sa scriverlo. Che cosa si può dare al programma, allora?

Una ricompensa (reward): un numero che dice quanto bene sta andando. Vola bene, +1; si schianta, −1000.

Nell'apprendimento per rinforzo (reinforcement learning, RL) un agente si trova in uno stato s, sceglie un'azione a, finisce in un nuovo stato s′ e riceve una ricompensa R; il compito è imparare una policy π, una regola che a ogni stato associa l'azione da fare, tale da massimizzare la ricompensa accumulata.

La definizione si applica a tutto: robot, giochi (le partite a scacchi e Go dei programmi campioni), controllo industriale, trading, e, su scala enorme, l'ultima fase di addestramento degli assistenti linguistici.

L'esempio del corso è un rover su una striscia di sei caselle. Nella casella 1 c'è una roccia molto interessante (ricompensa 100), nella 6 una meno interessante (40), nelle altre nulla; il rover parte dalla 4 e a ogni passo può andare a sinistra o a destra; raggiunta una delle due estremità la missione finisce (stato terminale). Che cosa deve fare? La roccia da 100 è lontana tre passi, quella da 40 due.

Per rispondere serve il ritorno (return): la somma delle ricompense future, ma con le più lontane che valgono meno:

Dove γ (gamma) è il fattore di sconto, un numero appena sotto 1 (0,9, 0,99). Il ritorno dice che un euro domani vale meno di un euro oggi, e rende l'agente un po' impaziente:

Conviene la roccia grande. Con γ più piccolo vince la roccia vicina. Lo sconto serve anche a far convergere la somma quando il compito non ha fine, e con ricompense negative spinge a rimandare il male il più possibile.

Lo strumento centrale è la funzione stato-azione Q(s, a): il ritorno che si ottiene partendo dallo stato s, facendo una volta l'azione a, e poi comportandosi nel modo migliore possibile. Se conosci Q, la policy ottima è immediata: in ogni stato scegli l'azione con Q più alta, π(s) = argmax_a Q(s, a). Nel rover, Q(4, sinistra) = 12,5 e Q(4, destra) = 10 → sinistra.

Come si calcola Q senza enumerare tutti i futuri? Con l'equazione di Bellman, che è una definizione ricorsiva:

Negli stati terminali Q(s, a) = R(s). L'equazione lega il valore di ogni stato a quello dei suoi vicini; applicarla ripetutamente (si parte da Q = 0 e si aggiorna ogni cella con la formula finché i valori non cambiano più) fa convergere Q al valore vero. Il laboratorio lo fa sotto i tuoi occhi.

Ambienti stocastici. Il rover reale, comandato «sinistra», va a sinistra con probabilità 0,9 e scivola a destra con 0,1. Allora la ricompensa accumulata è casuale, l'obiettivo diventa il ritorno atteso (la media su tanti tentativi) e Bellman prende una media sui possibili s′:

Il resto non cambia.

Un modulo lunare non ha sei caselle: ha posizione, velocità, angolo, velocità angolare, tutti numeri reali. Dove si mette la tabella Q?

Da nessuna parte: si sostituisce con una rete neurale che, dato lo stato s (il vettore dei numeri) e un'azione, stima Q(s, a); in pratica la rete riceve s e produce quattro uscite, una per azione (niente, sinistra, motore principale, destra). È il Deep Q-Network (DQN).

L'addestramento usa Bellman come fonte di esempi: si fa agire il lander (anche male), si registrano le quadruple (s, a, R, s′), e per ciascuna si costruisce un esempio di training con input s e target y = R + γ·max_a′ Q(s′, a′), dove Q sul lato destro è calcolata dalla rete attuale. Si addestra la rete su questi esempi con l'errore quadratico, si aggiorna, si ripete. È una regressione in cui i target cambiano man mano che la rete migliora, e converge verso la Q vera.

Tre accorgimenti rendono la ricetta stabile. L'ε-greedy: durante la raccolta, con probabilità 1 − ε si fa l'azione che la rete attuale ritiene migliore, con probabilità ε (per esempio 0,05, o alta all'inizio e decrescente) un'azione a caso, altrimenti la rete non scopre mai che un'azione che oggi stima male è in realtà buona (è l'esplorazione, lo stesso dilemma degli assistenti linguistici addestrati con RL).

Il replay buffer con i mini-batch: si tengono le ultime 10.000 quadruple e a ogni passo si addestra su un campione di 1.000, non su tutto, per velocità.

Gli aggiornamenti morbidi (soft update): invece di sostituire la rete di colpo con quella appena addestrata, la si muove di poco verso di essa:

Così i target non saltano a ogni passo.

Ogni algoritmo della guida risponde alle stesse tre domande: che cosa c'è nei dati, che forma ha il modello e che cosa minimizza. Le tre colonne centrali della tabella sono il motivo per cui, imparata la regressione lineare, il resto si riconosce.