Chiunque lavori con i dati di un sito, prima o poi, si fa una domanda che sa già di machine learning. Quali pagine nuove porteranno traffico? Quali sessioni finiranno in un acquisto? Quali delle mille query di Search Console parlano della stessa cosa?
Sono domande diverse, ma hanno un tratto comune: la risposta non la scriviamo noi, regola per regola. La ricaviamo dagli esempi che abbiamo già.
È tutto qui, in fondo, il machine learning (in italiano, apprendimento automatico): un modo di costruire regole a partire dai dati, invece di scriverle a mano. Il nome evoca robot e intelligenze artificiali, ma il cuore è statistica, e una buona parte di quello che serve per capirlo l’abbiamo già vista su questo blog.
In questa introduzione al machine learning mettiamo in ordine i concetti di base, li colleghiamo agli articoli che li trattano uno per uno, e ci fermiamo sull’idea che fa la differenza fra un modello utile e uno che inganna: imparare non vuol dire memorizzare.
In sintesi: il machine learning costruisce un modello, cioè una regola che trasforma dei dati in ingresso (le caratteristiche di una pagina, di una sessione, di una query) in una previsione o in un raggruppamento. Nell’apprendimento supervisionato il modello impara da esempi di cui conosciamo già la risposta (le pagine che hanno convertito e quelle che no) e serve a prevedere o a classificare; in quello non supervisionato non ci sono risposte, e il modello cerca strutture nei dati, come gruppi di query simili. Il rischio principale è l’overfitting: un modello troppo flessibile impara anche il rumore dei dati di addestramento e sbaglia sui dati nuovi. Per questo un modello si valuta sempre su dati che non ha visto durante l’addestramento.
Di cosa parleremo:
- Che cosa sono i modelli di machine learning
- Supervisionato e non supervisionato
- Imparare non è memorizzare: l’overfitting
- Come si valuta un modello
- I principali algoritmi, e dove trovarli sul blog
- Le fasi di un progetto
- Come iniziare
- Domande frequenti
- Prova tu
- Per approfondire
Che cosa sono i modelli di machine learning
Un modello è una regola che collega quello che sappiamo (gli ingressi, o feature, come dicono gli anglosassoni) a quello che vogliamo sapere (l’uscita). Facciamo un esempio che conosciamo bene: il CTR di una pagina dipende dalla sua posizione in SERP. Nell’articolo sul CTR atteso abbiamo costruito proprio un modello di questo tipo: una curva che, data la posizione, restituisce il CTR tipico del nostro sito.
Quel modello non l’abbiamo scritto a mano, decidendo che “in terza posizione il CTR è il 7%”. Abbiamo scelto la forma della regola (una curva che scende rapidamente), e poi abbiamo lasciato che fossero i dati a fissarne i parametri, cioè i numeri che la rendono precisa. È esattamente questo che fa un algoritmo di machine learning: sceglie i parametri di una regola in modo che si adatti il più possibile agli esempi. La regressione lineare, in questo senso, è già machine learning: il più semplice e il più trasparente.
Quello che distingue gli algoritmi fra loro è soprattutto la flessibilità della regola. Una retta ha due parametri e può disegnare una forma sola; un albero decisionale o una rete neurale ne hanno moltissimi e possono adattarsi a forme complicatissime. Più flessibilità vuol dire poter catturare relazioni più ricche, ma anche, come vedremo, un rischio in più.
Supervisionato e non supervisionato
La distinzione più importante riguarda gli esempi da cui il modello impara.
Nell’apprendimento supervisionato ogni esempio ha la sua risposta: per ogni sessione passata sappiamo se ha portato a un acquisto, per ogni email se era spam, per ogni pagina quanti clic ha ricevuto. Il modello impara la relazione fra ingressi e risposta, e poi la applica ai casi nuovi. Se la risposta è un numero (il CTR, il fatturato) si parla di regressione; se è una categoria (acquista o no, informativa o transazionale) si parla di classificazione.
Nell’apprendimento non supervisionato le risposte non ci sono. Abbiamo solo i dati, e chiediamo al modello di trovarvi una struttura: gruppi di query che si somigliano, poche dimensioni che riassumono molte variabili, osservazioni che non somigliano a nessun’altra. È il caso del clustering delle keyword o dell’analisi delle componenti principali.
Esiste anche una terza famiglia, l’apprendimento per rinforzo, in cui un sistema impara provando azioni e ricevendo ricompense: è l’idea dietro i multi-armed bandit, che spostano il traffico verso la variante che rende di più mentre il test è in corso.
Imparare non è memorizzare: l’overfitting
Se un modello più flessibile si adatta meglio ai dati, perché non usare sempre il più flessibile possibile? Perché adattarsi ai dati di addestramento non è lo scopo: lo scopo è prevedere bene i dati nuovi. E un modello troppo flessibile, con pochi dati, impara anche quello che nei dati è solo rumore.
Facciamo un esempio. Vogliamo prevedere il CTR di una pagina dalla sua posizione, e abbiamo i dati di sole 20 pagine. Costruiamo modelli di flessibilità crescente: polinomi di grado 1 (una retta), 2, 3 e così via fino a 9. Per ogni modello misuriamo l’errore tipico due volte: sulle 20 pagine con cui l’abbiamo addestrato, e su 2.000 pagine nuove che non ha mai visto.
Simulo i dati in R, con un CTR vero che scende come una legge di potenza più un po’ di rumore, e misuro gli errori:
set.seed(2026)
ctr_vero <- function(pos) 0.30 * pos^-1
simula <- function(n) {
pos <- runif(n, 1, 15)
data.frame(pos = pos, ctr = ctr_vero(pos) * exp(rnorm(n, 0, 0.35)))
}
addestramento <- simula(20) # le pagine che conosciamo
nuove <- simula(2000) # le pagine nuove, che il modello non ha mai visto
errore <- function(modello, dati) sqrt(mean((dati$ctr - predict(modello, dati))^2))
for (g in 1:9) {
m <- lm(ctr ~ poly(pos, g), data = addestramento)
cat(g, round(errore(m, addestramento), 4), round(errore(m, nuove), 4), "\n")
}| grado | errore sui dati di addestramento | errore sui dati nuovi |
|---|---|---|
| 1 | 0,082 | 0,068 |
| 2 | 0,057 | 0,057 |
| 3 | 0,046 | 0,044 |
| 4 | 0,043 | 0,048 |
| 5 | 0,043 | 0,064 |
| 6 | 0,035 | 0,578 |
| 7 | 0,029 | 0,500 |
| 8 | 0,026 | 0,438 |
| 9 | 0,026 | 0,295 |
L’errore è il RMSE (la radice della media degli errori al quadrato, che pesa di più gli errori grandi), in unità di CTR: 0,044 vuol dire circa 4,4 punti percentuali.
Sui dati di addestramento l’errore scende sempre: più il modello è flessibile, meglio “ricorda” le 20 pagine che ha visto. Sui dati nuovi, invece, l’errore scende fino al grado 3 e poi risale, fino a esplodere: al grado 6 il RMSE arriva a 58 punti, perché il modello prevede CTR assurdi appena esce dalle situazioni che conosce. È l’overfitting: il modello ha imparato a memoria il rumore delle 20 pagine invece della relazione che le lega.

C’è un dettaglio che vale tutto l’esempio. Il modello che sui dati nuovi va meglio di tutti non è un polinomio, ma la legge di potenza stimata sui logaritmi, con soli due parametri: lo stesso modello dell’articolo sul CTR atteso. Lo verifico in R:
m_log <- lm(log(ctr) ~ log(pos), data = addestramento)
s2 <- summary(m_log)$sigma^2 # varianza dei residui (scala log)
prev <- function(dati) exp(predict(m_log, dati) + s2 / 2) # previsione del CTR medio
sqrt(mean((addestramento$ctr - prev(addestramento))^2)) # 0,0490
sqrt(mean((nuove$ctr - prev(nuove))^2)) # 0,0304Sui dati di addestramento sbaglia più del polinomio di grado 3 (0,049 contro 0,046), ma sui dati nuovi sbaglia molto meno (0,030 contro 0,044). Un modello con la forma giusta e pochi parametri può battere un modello flessibile che la forma deve indovinarla dai dati. In questa simulazione succede con un margine netto, e il messaggio vale in generale: quando abbiamo poche osservazioni, conoscere il fenomeno vale più di qualunque algoritmo.
n.b. il termine s2 / 2 serve perché, tornando dai logaritmi con exp(), si ottiene il CTR mediano di ogni posizione, non quello medio: con errori di questo tipo la media è più alta della mediana di un fattore exp(σ²/2): stimato sui nostri dati vale circa 1,085, quello vero della simulazione 1,063. Anche la “curva vera” della simulazione, a rigore, è il CTR mediano.
L’altra cura è avere più dati. Lo verifico in R con un nuovo campione di 200 pagine:
set.seed(1)
add200 <- simula(200)
m9 <- lm(ctr ~ poly(pos, 9), data = add200)
errore(m9, nuove) # 0,0345Con 200 pagine invece di 20, lo stesso polinomio di grado 9 sbaglia sui dati nuovi 0,034, non più 0,295. È un solo campione, quindi un’illustrazione più che una legge, ma la direzione è quella attesa: la flessibilità diventa un problema soprattutto quando i dati sono pochi rispetto ai parametri da stimare.
Come si valuta un modello
L’esempio contiene la regola d’oro della valutazione: un modello si giudica su dati che non ha visto durante l’addestramento. L’errore sui dati di addestramento tende a essere ottimista, e tanto più quanto più il modello è flessibile (in media, non caso per caso: nella nostra tabella, al grado 1, è perfino più alto di quello sui dati nuovi).
Nella pratica i dati disponibili si separano in tre parti, con tre compiti diversi. Sull’insieme di addestramento (training set) il modello impara. Sull’insieme di validazione si confrontano i modelli candidati e si sceglie il migliore: è quello che abbiamo fatto nell’esempio, usando le pagine nuove per scegliere il grado. L’insieme di prova (test set), infine, resta chiuso in un cassetto fino alla fine e serve solo a misurare quanto sbaglierà il modello scelto: se lo usassimo anche per scegliere, la stima tornerebbe ottimista. Quando i dati sono pochi, al posto dell’insieme di validazione si usa la validazione incrociata (cross-validation): si divide il campione in, diciamo, cinque parti, si addestra il modello su quattro e lo si prova sulla quinta, a rotazione, e si fa la media dei cinque errori.
Due avvertenze. La prima: il modo di misurare l’errore deve corrispondere al problema. Per un classificatore, una percentuale alta di risposte giuste può non voler dire niente: se solo il 2% delle sessioni converte, un modello che risponde sempre “non converte” ha ragione nel 98% dei casi, e non serve a nulla.
La seconda: i dati nuovi su cui il modello lavorerà devono somigliare a quelli su cui è stato valutato. Un modello addestrato sul traffico di un anno fa può sbagliare dopo un aggiornamento di Google o un cambio nel modo di misurare: è il tema delle rotture strutturali.
I principali algoritmi, e dove trovarli sul blog
Gli algoritmi di machine learning sono decine, ma quelli che si incontrano più spesso sono pochi. La tabella li mette in fila con un esempio d’uso sui dati web e, dove c’è, l’articolo del blog che li tratta passo per passo.
| Algoritmo | Tipo | A che cosa serve, per esempio | Sul blog |
|---|---|---|---|
| Regressione lineare | supervisionato, regressione | prevedere un numero: il CTR dalla posizione, il traffico da più fattori | semplice, multipla |
| Regressione logistica | supervisionato, classificazione | stimare la probabilità che una sessione converta | regressione logistica |
| Alberi decisionali | supervisionato | classificare pagine o sessioni con regole leggibili | alberi decisionali |
| Naive Bayes | supervisionato, classificazione | riconoscere l’intento di una query dalle parole che contiene | Naive Bayes |
| Random forest, gradient boosting | supervisionato | previsioni più accurate combinando molti alberi | — |
| k-NN | supervisionato | classificare un caso nuovo in base ai casi noti più simili | — |
| SVM | supervisionato, classificazione | separare due classi con il confine più distante da entrambe | — |
| k-means e clustering gerarchico | non supervisionato | raggruppare query o pagine simili | clustering delle keyword |
| Analisi delle componenti principali (PCA) | non supervisionato | riassumere molte metriche in poche dimensioni | PCA |
| Rilevamento di anomalie | non supervisionato | trovare giorni o pagine fuori norma | anomaly detection |
Qualche precisazione su quelli che il blog non tratta ancora. La random forest costruisce molti alberi decisionali, ciascuno su un campione casuale delle osservazioni (estratto con reinserimento), e a ogni suddivisione sceglie fra un sottoinsieme casuale delle variabili; poi combina le risposte degli alberi: fa la media delle previsioni nella regressione, e un voto a maggioranza nella classificazione. Il gradient boosting costruisce gli alberi uno dopo l’altro, e ognuno cerca di correggere gli errori dei precedenti. Il k-NN (k-nearest neighbors) classifica un caso nuovo guardando i k casi noti più simili. Le SVM (support vector machine) cercano il confine che separa le classi con il margine più ampio possibile, e grazie alle funzioni kernel possono tracciare anche confini curvi, non solo rette.
Molti modelli, e in particolare le reti neurali, si addestrano con un procedimento che aggiusta i parametri passo dopo passo per ridurre l’errore: la discesa del gradiente. Non è l’unico motore: gli alberi si costruiscono con suddivisioni successive, il k-NN confronta distanze, il Naive Bayes stima probabilità, la PCA scompone una matrice.
Le fasi di un progetto
Un progetto di machine learning, anche piccolo, attraversa sempre le stesse fasi.
- Formulare la domanda. Che cosa vogliamo prevedere o scoprire, e che cosa faremo con la risposta. Una domanda vaga produce un modello inutile, per quanto sofisticato.
- Raccogliere e pulire i dati. È la fase più lunga, quasi sempre: valori mancanti, metriche che cambiano definizione, duplicati, buchi di tracciamento.
- Esplorare. Guardare le distribuzioni e le relazioni prima di modellare: i grafici scoprono problemi che nessun algoritmo segnala.
- Scegliere e addestrare il modello, partendo dal più semplice che possa funzionare.
- Sceglierlo e valutarlo su dati nuovi: la scelta con un insieme di validazione o con la validazione incrociata, il giudizio finale sul test set tenuto da parte; e confrontarlo con un riferimento ingenuo (per esempio prevedere sempre la media).
- Usarlo e sorvegliarlo. Un modello in produzione va controllato nel tempo, perché i dati su cui lavora cambiano.
Come iniziare
Per mettere le mani sul machine learning non serve installare niente di complicato. Google Colab permette di scrivere ed eseguire codice nel browser e di condividere il lavoro con un link: è pensato soprattutto per Python, ma si può lavorare anche in R scegliendolo come tipo di runtime (menu Runtime, Cambia tipo di runtime); Jupyter offre lo stesso tipo di quaderno di lavoro sul proprio computer. Chi usa già R, come negli esempi di questo blog, può partire da RStudio e dalla raccolta di pacchetti tidymodels, che dà un’interfaccia comune a molti algoritmi e alla validazione incrociata.
Fra i corsi, quello di Andrew Ng su Coursera resta un ottimo punto di partenza, con esempi in Python. Fra i libri, An Introduction to Statistical Learning è il testo che consiglio prima di tutti: spiega gli algoritmi con pochissima matematica e molti esempi, e gli autori lo mettono a disposizione gratuitamente in PDF sul sito ufficiale, accanto all’edizione a stampa.
Il consiglio più utile, però, è un altro: lavorare presto su dati veri, possibilmente i propri. Un modello addestrato sui dati del proprio sito insegna più di dieci tutorial, proprio perché lì i dati sono sporchi, pochi e pieni di sorprese.
Domande frequenti
Che cos’è il machine learning, in parole semplici?
È un insieme di metodi che costruiscono una regola a partire dagli esempi, invece di farla scrivere a mano a un programmatore. La regola, chiamata modello, serve poi a fare previsioni o a trovare strutture in dati nuovi.
Quali sono i principali algoritmi di machine learning?
Per l’apprendimento supervisionato la regressione lineare e logistica, gli alberi decisionali, la random forest e il gradient boosting, il Naive Bayes, il k-NN e le SVM; per quello non supervisionato il clustering (k-means, gerarchico), la PCA e i metodi di rilevamento delle anomalie.
Che differenza c’è fra apprendimento supervisionato e non supervisionato?
Nel supervisionato ogni esempio ha la sua risposta (ha convertito o no) e il modello impara a prevederla; nel non supervisionato le risposte non ci sono e il modello cerca strutture nei dati, come gruppi di elementi simili.
Che cos’è l’overfitting?
È quando un modello impara troppo bene i dati di addestramento, compreso il loro rumore, e per questo sbaglia sui dati nuovi. Il segnale tipico è un forte divario fra l’errore sui dati di addestramento, basso, e quello su dati nuovi confrontabili, alto; si combatte con modelli più semplici, più dati e la validazione su dati non visti.
Machine learning e statistica sono la stessa cosa?
Condividono gran parte degli strumenti: la regressione, per esempio, è di entrambi. Cambia soprattutto l’accento: la statistica cura di più la comprensione e l’incertezza delle stime, il machine learning la qualità delle previsioni su dati nuovi.
Prova tu
Il codice dell’esempio si può rieseguire e modificare. Tre direzioni:
- Più pagine. Portiamo le pagine di addestramento da 20 a 50 e poi a 200: come cambia il grado con l’errore minimo sui dati nuovi? E quanto si riduce la distanza fra i due errori?
- Più rumore. Aumentiamo il rumore da 0,35 a 0,6 (il terzo argomento di
rnorm): l’overfitting arriva prima o dopo? - Un altro seme. Cambiamo
set.seed(2026)con un altro numero e ripetiamo: il grado migliore resta 3? Che cosa ci dice questo sulla stabilità della scelta fatta con soli 20 dati?
Suggerimento: in tutte e tre le prove conviene guardare non solo quale grado vince, ma di quanto. Una differenza minima fra due modelli, stimata su pochi dati, non è una buona ragione per preferire il più complicato.
Il primo algoritmo che vale la pena vedere al lavoro è anche il più leggibile: un albero decisionale, che impara dai dati una serie di domande sì/no e le mostra in chiaro, una per una. Lo trattiamo nell’articolo sugli alberi decisionali, e tutto il percorso, dalla regressione al clustering, è raccolto nel percorso sul machine learning.
Per approfondire
Per proseguire, An Introduction to Statistical Learning di James, Witten, Hastie e Tibshirani è il libro che consiglio a chi parte: unisce l’intuizione alla pratica, con laboratori in R per ogni capitolo, e affronta con cura proprio il compromesso fra flessibilità e overfitting. Per un inquadramento più completo e teorico, Introduction to Machine Learning di Ethem Alpaydın copre l’intero campo con rigore.