Immagina di trovarti su un terreno montagnoso, completamente bendato. Il tuo obiettivo: raggiungere il punto più basso della valle. Non puoi vedere nulla, ma puoi sentire la pendenza del terreno sotto i piedi. Cosa fai? Ti muovi nella direzione in cui il terreno scende, un passo alla volta. Se scende più ripidamente a sinistra, vai a sinistra. Se scende di più a destra, vai a destra. Ad ogni passo, senti di nuovo la pendenza e cambi direzione.

Questa strategia, così semplice e naturale, è esattamente quella che le reti neurali usano per imparare. Ogni volta che un modello di intelligenza artificiale migliora — che impari a riconoscere un volto, tradurre una frase, o generare un testo — lo fa scendendo lungo un paesaggio matematico, un passo alla volta, seguendo la pendenza.

Si chiama discesa del gradiente (gradient descent), ed è probabilmente l’algoritmo più importante del machine learning moderno.

Da Cauchy alle reti neurali: una breve storia

L’idea di seguire la pendenza per trovare un minimo ha radici sorprendentemente antiche. Nel 1847, il matematico francese Augustin-Louis Cauchy pubblica un metodo per risolvere sistemi di equazioni che, nella sostanza, è già la discesa del gradiente: calcolare la direzione di massima crescita di una funzione e muoversi nella direzione opposta. Cauchy non pensava alle reti neurali — mancava più di un secolo alla loro comparsa — ma aveva formalizzato il principio che ancora oggi alimenta l’intelligenza artificiale.

Per oltre un secolo l’idea resta confinata alla matematica pura. La svolta arriva nel 1951, quando Herbert Robbins e Sutton Monro propongono una versione stocastica del metodo: invece di calcolare il gradiente sull’intero problema, lo si stima su un campione casuale. È il seme di quello che oggi chiamiamo Stochastic Gradient Descent (SGD) — ne parleremo nella sezione finale. Pochi anni dopo, nel 1958, Frank Rosenblatt costruisce il perceptron, il primo modello di apprendimento automatico che usa la discesa del gradiente per imparare dai dati. L’entusiasmo è enorme, ma dura poco: nel 1969 Minsky e Papert dimostrano i limiti del perceptron, e l’interesse per le reti neurali crolla. È il cosiddetto inverno dell’intelligenza artificiale.

La rinascita arriva nel 1986, quando David Rumelhart, Geoffrey Hinton e Ronald Williams pubblicano l’algoritmo di backpropagation: un modo efficiente per calcolare il gradiente in reti neurali con molti strati. È la chiave che sblocca il deep learning. Da quel momento, la discesa del gradiente non è più un esercizio teorico ma lo strumento pratico con cui si addestrano le reti neurali. L’ultimo tassello di questa storia lo pongono Diederik Kingma e Jimmy Ba nel 2014, con l’ottimizzatore Adam — che ritroveremo nella sezione finale di questo articolo. Quasi due secoli separano Cauchy da Adam, eppure il principio è rimasto lo stesso: senti la pendenza, fai un passo nella direzione opposta.

La matematica, spiegata geometricamente

La funzione di costo: misurare quanto sbaglia il modello

Prima di scendere, dobbiamo sapere cosa stiamo minimizzando. La persona bendata cerca il punto più basso della valle — ma nel machine learning, cos’è esattamente quella valle?

Facciamo un esempio concreto. Supponiamo di voler prevedere il prezzo di una casa conoscendo solo la sua superficie. Abbiamo cinque case di cui conosciamo superficie e prezzo reale, e il nostro modello è il più semplice possibile: una retta che passa per l’origine, prezzo = m × superficie, dove m è l’unico parametro da regolare.

Per ogni valore di m, il modello fa una previsione. Se m è troppo basso, le previsioni sottostimano i prezzi reali; se è troppo alto, li sovrastimano. Abbiamo bisogno di un numero che ci dica quanto il modello sta sbagliando: è la funzione di costo (o loss function, come dicono gli anglosassoni).

La funzione di costo più usata è l’errore quadratico medio (MSE, Mean Squared Error): per ogni casa, calcoliamo la differenza tra il prezzo previsto e quello reale, la eleviamo al quadrato, e facciamo la media di tutti questi errori. In formula:

MSE(m) = (1/n) ∑_i (prezzo_i − m × superficie_i)²

Se plottiamo MSE(m) al variare di m, otteniamo una curva a forma di parabola: la stessa parabola che useremo tra poco come esempio della discesa del gradiente. Non è una coincidenza — la parabola è la funzione di costo, e il suo punto più basso è il valore di m che rende il modello migliore possibile.

Gli esempi che seguono sono disponibili sia in R che in Python — ognuno segua il linguaggio con cui ha più familiarità.

Calcoliamo in R la funzione di costo per il nostro esempio delle case:

# Funzione di costo: prevedere il prezzo di una casa
superficie <- c(50, 70, 90, 120, 150)
prezzo <- c(150, 200, 260, 340, 400)  # migliaia di euro

# Modello: prezzo = m * superficie
# Funzione di costo MSE al variare di m
m_valori <- seq(1, 4, by = 0.01)
mse <- sapply(m_valori, function(m) mean((prezzo - m * superficie)^2))

plot(m_valori, mse, type = "l", lwd = 2, col = "steelblue",
     xlab = "m (pendenza)", ylab = "MSE",
     main = "Funzione di costo al variare di m")
m_ottimo <- m_valori[which.min(mse)]
abline(v = m_ottimo, col = "red", lty = 2)
cat("Il valore di m che minimizza l'errore:", round(m_ottimo, 2), "\n")

Verifichiamo in Python:

import numpy as np
import matplotlib.pyplot as plt

# Funzione di costo: prevedere il prezzo di una casa
superficie = np.array([50, 70, 90, 120, 150])
prezzo = np.array([150, 200, 260, 340, 400])  # migliaia di euro

# Modello: prezzo = m * superficie
# Funzione di costo MSE al variare di m
m_valori = np.linspace(1, 4, 301)  # equivalente a seq(1, 4, by=0.01) in R
mse = np.array([np.mean((prezzo - m * superficie)**2) for m in m_valori])

plt.plot(m_valori, mse, lw=2, color="steelblue")
plt.xlabel("m (pendenza)")
plt.ylabel("MSE")
plt.title("Funzione di costo al variare di m")
m_ottimo = m_valori[np.argmin(mse)]
plt.axvline(m_ottimo, color="red", linestyle="--")
plt.show()
print(f"Il valore di m che minimizza l'errore: {m_ottimo:.2f}")

Ora sappiamo cosa minimizzare: la funzione di costo. Il gradiente ci dice come.

Derivata: la pendenza sotto i piedi

Quando hai una funzione di una sola variabile — pensala come un sentiero che sale e scende — la derivata in un punto ti dice quanto è ripido il sentiero in quel punto. Se la derivata è positiva, stai salendo. Se è negativa, stai scendendo. Se è zero, sei su un tratto piatto: forse una cima, forse un avvallamento.

Esempio concreto: la funzione f(x) = x² descrive una parabola. La sua derivata è f'(x) = 2x. Se sei nel punto x = 3, la derivata vale 6: stai salendo ripidamente. Se sei in x = -1, la derivata vale -2: stai scendendo. In x = 0, la derivata è zero: sei nel punto più basso.

Il gradiente: una bussola multidimensionale

Nella realtà, le funzioni che ci interessano non dipendono da una sola variabile. Un modello di machine learning può avere centinaia, migliaia, o miliardi di parametri. Il paesaggio non è più un sentiero, ma una superficie in uno spazio a molte dimensioni — impossibile da visualizzare, ma perfettamente gestibile dalla matematica.

Il gradiente è il vettore che raccoglie tutte le derivate parziali della funzione rispetto a ciascun parametro. Se la funzione dipende da due variabili (x, y), il gradiente è:

∇f = (∂f/∂x, ∂f/∂y)

Se dipende da mille variabili, il gradiente è un vettore con mille componenti. In ogni caso, il gradiente punta nella direzione di massima salita. Per trovare il minimo, basta andare nella direzione opposta: meno il gradiente.

Ecco la formula fondamentale della discesa del gradiente:

θ_nuovo = θ_vecchio − α · ∇f(θ)

Smontiamola pezzo per pezzo:

• θ rappresenta i parametri del modello — le “manopole” che l’algoritmo regola per migliorare
• ∇f(θ) è il gradiente: indica la direzione di massima salita nel punto attuale
• α (alpha) è il learning rate: la dimensione del passo che facciamo ad ogni iterazione
• Il segno meno ci fa andare nella direzione opposta al gradiente, cioè in discesa

È tutto qui. Calcola dove stai salendo, fai un passo nella direzione opposta, ripeti.

Un esempio numerico in R

Vediamo la discesa del gradiente in azione sulla funzione f(x) = x². Sappiamo che il minimo è in x = 0. L’algoritmo riesce a trovarlo partendo da un punto casuale?

# Discesa del gradiente su f(x) = x^2
# La derivata e' f'(x) = 2x

f <- function(x) x^2         # funzione obiettivo
grad_f <- function(x) 2 * x  # derivata (gradiente in 1D)

x <- 10              # punto di partenza
alpha <- 0.1          # learning rate
n_iter <- 50          # numero di iterazioni
percorso <- numeric(n_iter)

for (i in 1:n_iter) {
  percorso[i] <- x
  x <- x - alpha * grad_f(x)  # la regola fondamentale
}

cat("Punto di partenza: 10\n")
cat("Dopo 50 iterazioni: x =", round(x, 8), "\n")
cat("Valore della funzione:", round(f(x), 10), "\n")

# Visualizzazione del percorso
curve(x^2, from = -11, to = 11, lwd = 2, col = "steelblue",
      main = "Discesa del gradiente su f(x) = x^2",
      xlab = "x", ylab = "f(x)")
points(percorso, percorso^2, col = "red", pch = 19, cex = 0.7)
lines(percorso, percorso^2, col = "red", lty = 2)

Verifichiamo in Python:

import numpy as np
import matplotlib.pyplot as plt

# Discesa del gradiente su f(x) = x^2
f = lambda x: x**2           # funzione obiettivo
grad_f = lambda x: 2 * x     # derivata (gradiente in 1D)

x = 10.0            # punto di partenza
alpha = 0.1          # learning rate
n_iter = 50          # numero di iterazioni
percorso = np.zeros(n_iter)

for i in range(n_iter):
    percorso[i] = x
    x = x - alpha * grad_f(x)  # la regola fondamentale

print(f"Punto di partenza: 10")
print(f"Dopo 50 iterazioni: x = {x:.8f}")
print(f"Valore della funzione: {f(x):.10f}")

# Visualizzazione del percorso
xs = np.linspace(-11, 11, 200)
plt.plot(xs, xs**2, lw=2, color="steelblue")
plt.plot(percorso, percorso**2, "ro--", markersize=4)
plt.title("Discesa del gradiente su f(x) = x²")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.show()

Eseguendo questo codice, si vede l’algoritmo partire da x = 10 e convergere rapidamente verso x = 0. I primi passi sono grandi (la pendenza è ripida), poi si accorciano man mano che ci avviciniamo al fondo della parabola. Dopo 50 iterazioni, x è praticamente zero.

Il learning rate: passi grandi o passi piccoli?

Torniamo alla nostra persona bendata. Quant’è grande il passo che fa ad ogni iterazione? Questa è esattamente la domanda del learning rate (α), e la risposta è meno banale di quanto sembri.

Passi troppo piccoli (α molto basso): la persona si muove con cautela estrema, spostando un piede di pochi centimetri alla volta. Alla fine arriverà in fondo alla valle, ma potrebbe impiegare un’eternità. Nel machine learning, questo significa tempi di addestramento lunghissimi e costi computazionali elevati.

Passi troppo grandi (α troppo alto): la persona fa balzi enormi. Invece di scendere dolcemente nella valle, la scavalca, finisce dall’altra parte, rimbalza indietro, e continua a oscillare senza mai stabilizzarsi. In casi estremi, i salti diventano sempre più grandi e la persona finisce più in alto di dove era partita. Nel machine learning, questo si chiama divergenza: il modello peggiora invece di migliorare.

Passi giusti: un buon learning rate permette di scendere velocemente senza oscillare. Nella pratica, trovare il valore giusto richiede sperimentazione. È uno degli aspetti più artigianali del machine learning.

Convergenza: sapere quando fermarsi

Come sa la persona bendata di essere arrivata? Sente che il terreno è piatto in tutte le direzioni: il gradiente è (quasi) zero. In pratica, l’algoritmo si ferma quando il miglioramento tra un’iterazione e l’altra diventa trascurabile, o quando ha raggiunto un numero massimo di iterazioni.

I criteri di arresto più comuni sono:

• La norma del gradiente scende sotto una soglia minima (il terreno è quasi piatto)
• La differenza tra f(θ) di due iterazioni consecutive è minore di una tolleranza fissata
• Si è raggiunto il numero massimo di iterazioni (budget computazionale esaurito)

L’effetto del learning rate: un confronto visuale

Questo codice R mostra l’effetto di tre diversi valori di learning rate sulla stessa funzione:

# Confronto di tre learning rate sulla funzione f(x) = x^2
gradient_descent <- function(x0, alpha, n_iter = 30) {
  x <- x0
  percorso <- numeric(n_iter)
  for (i in 1:n_iter) {
    percorso[i] <- x
    x <- x - alpha * 2 * x  # theta_new = theta_old - alpha * grad
  }
  return(percorso)
}

x0 <- 8  # stesso punto di partenza per tutti

# Tre learning rate diversi
lento    <- gradient_descent(x0, alpha = 0.01)   # troppo piccolo
giusto   <- gradient_descent(x0, alpha = 0.1)    # buon compromesso
veloce   <- gradient_descent(x0, alpha = 0.9)    # quasi instabile

# Visualizzazione
par(mfrow = c(1, 3))

# alpha = 0.01 (troppo lento)
curve(x^2, from = -10, to = 10, lwd = 2, col = "steelblue",
      main = expression(paste(alpha, " = 0.01 (troppo lento)")))
points(lento, lento^2, col = "red", pch = 19, cex = 0.6)
lines(lento, lento^2, col = "red", lty = 2)

# alpha = 0.1 (giusto)
curve(x^2, from = -10, to = 10, lwd = 2, col = "steelblue",
      main = expression(paste(alpha, " = 0.1 (buon compromesso)")))
points(giusto, giusto^2, col = "darkgreen", pch = 19, cex = 0.6)
lines(giusto, giusto^2, col = "darkgreen", lty = 2)

# alpha = 0.9 (quasi instabile)
curve(x^2, from = -10, to = 10, lwd = 2, col = "steelblue",
      main = expression(paste(alpha, " = 0.9 (quasi instabile)")))
points(veloce, veloce^2, col = "orange", pch = 19, cex = 0.6)
lines(veloce, veloce^2, col = "orange", lty = 2)

par(mfrow = c(1, 1))

Confrontiamo in Python:

import numpy as np
import matplotlib.pyplot as plt

def gradient_descent(x0, alpha, n_iter=30):
    x = x0
    percorso = np.zeros(n_iter)
    for i in range(n_iter):
        percorso[i] = x
        x = x - alpha * 2 * x  # theta_new = theta_old - alpha * grad
    return percorso

x0 = 8.0  # stesso punto di partenza per tutti
lento  = gradient_descent(x0, alpha=0.01)   # troppo piccolo
giusto = gradient_descent(x0, alpha=0.1)    # buon compromesso
veloce = gradient_descent(x0, alpha=0.9)    # quasi instabile

fig, axes = plt.subplots(1, 3, figsize=(14, 4))
xs = np.linspace(-10, 10, 200)
for ax, dati, colore, titolo in zip(axes,
        [lento, giusto, veloce],
        ["red", "darkgreen", "orange"],
        ["\u03b1 = 0.01 (troppo lento)", "\u03b1 = 0.1 (buon compromesso)",
         "\u03b1 = 0.9 (quasi instabile)"]):
    ax.plot(xs, xs**2, lw=2, color="steelblue")
    ax.plot(dati, dati**2, "o--", color=colore, markersize=4)
    ax.set_title(titolo)
plt.tight_layout()
plt.show()

Con α = 0.01 i punti rossi si muovono pigramente: dopo 30 iterazioni siamo ancora lontani dal minimo. Con α = 0.1 la convergenza è rapida e pulita. Con α = 0.9 l’algoritmo oscilla vistosamente a ogni passo, rimbalzando da un lato all’altro della parabola prima di stabilizzarsi — un learning rate appena più alto e divergerebbe del tutto.

Cosa può andare storto: l’intuizione geometrica

Il paesaggio matematico di un modello reale non è una bella parabola simmetrica. È un terreno selvaggio, con valli secondarie, creste, altipiani e forme che sfidano l’immaginazione. Ecco i problemi classici, spiegati con l’analogia del paesaggio.

Minimi locali: le valli secondarie

Immagina un terreno con più avvallamenti: una valle profonda (il minimo globale) e diverse vallette meno profonde (i minimi locali). La persona bendata non ha modo di sapere se la valle in cui si trova è quella più profonda. Sente il terreno piatto sotto i piedi e si ferma, convinta di essere arrivata. Ma potrebbe trovarsi in una valletta poco profonda, mentre il vero minimo è da tutt’altra parte.

Nella pratica, questo è un problema meno grave di quanto si pensasse. Le reti neurali moderne hanno così tanti parametri che i minimi locali tendono ad avere valori della funzione obiettivo simili al minimo globale. È come un terreno con molte valli, ma tutte più o meno alla stessa altitudine: finire in una qualsiasi va bene.

Punti di sella: la sella di cavallo

Un problema più insidioso sono i punti di sella (saddle points). Immagina di essere seduto su una sella di cavallo: se ti muovi avanti o indietro, scendi; se ti muovi a destra o sinistra, sali. In quel punto il gradiente è zero — il terreno sembra piatto — ma non sei in un minimo. Sei su un punto che è minimo in alcune direzioni e massimo in altre.

In spazi ad alta dimensionalità, i punti di sella sono molto più comuni dei minimi locali. Fortunatamente, le varianti moderne della discesa del gradiente (con un po’ di rumore o di momentum, come vedremo) riescono generalmente a sfuggire ai punti di sella.

Valli strette: lo zigzag

Immagina una valle molto stretta e allungata, come un canyon. Il gradiente punta quasi perpendicolarmente alle pareti del canyon, non lungo il canyon verso il fondo. La persona bendata finisce per rimbalzare da una parete all’altra, facendo uno zigzag inefficiente invece di camminare dritta verso il fondo.

Questo accade quando le variabili del problema hanno scale molto diverse: alcune cambiano rapidamente, altre lentamente. È un problema comune nella pratica, e una delle motivazioni principali per gli ottimizzatori avanzati come Adam, che vedremo nella sezione finale.

Da una parabola a ChatGPT

Finora abbiamo visto la discesa del gradiente su una parabola: un problema con una sola variabile. È il caso più semplice possibile. Ma il bello di questo algoritmo è che funziona esattamente allo stesso modo a qualsiasi scala.

La scala dei parametri

Ecco come cresce il numero di parametri man mano che i modelli diventano più complessi:

• Regressione lineare semplice: 2 parametri (pendenza e intercetta). Il paesaggio è una superficie 3D facile da visualizzare.
• Rete neurale per riconoscere cifre scritte a mano: ~100.000 parametri. Il paesaggio ha 100.000 dimensioni.
• ResNet-50 (classificazione immagini, 2015): ~25 milioni di parametri.
• GPT-3 (il predecessore di ChatGPT): 175 miliardi di parametri.
• GPT-4 e modelli di frontiera (2023-2025): si stima oltre un trilione di parametri.

Il principio è identico: calcola il gradiente, fai un passo nella direzione opposta, ripeti. Quello che cambia è la scala del calcolo. Il gradiente di GPT-4 è un vettore con più di mille miliardi di componenti, calcolato su miliardi di frammenti di testo, usando migliaia di processori in parallelo. Ma la formula è la stessa che abbiamo visto sulla parabola.

Dove lo vedi in azione (senza saperlo)

Ogni volta che interagisci con un sistema di intelligenza artificiale, la discesa del gradiente ha lavorato dietro le quinte:

• Netflix e Spotify che ti consigliano cosa guardare o ascoltare: i modelli di raccomandazione sono addestrati con gradient descent su miliardi di interazioni utente
• Google Translate e i traduttori automatici: reti neurali con centinaia di milioni di parametri, ottimizzate con discesa del gradiente su enormi corpora di testi paralleli
• Assistenti vocali (Siri, Alexa): il riconoscimento vocale usa reti neurali profonde, addestrate con lo stesso algoritmo
• Guida autonoma: le reti che riconoscono pedoni, semafori e corsie stradali sono addestrate con varianti della discesa del gradiente
• ChatGPT, Claude, Gemini: i Large Language Model sono il caso più estremo — la discesa del gradiente applicata a miliardi di parametri su trilioni di token di testo

Il messaggio chiave è questo: la potenza dell’AI moderna non sta nella complessità dell’algoritmo di ottimizzazione, ma nella scala. La discesa del gradiente è concettualmente semplice. Quello che ha reso possibile la rivoluzione dell’intelligenza artificiale è la capacità di applicarlo a modelli enormi su quantità enormi di dati, grazie a hardware sempre più potente.

Le evoluzioni: scarpe migliori per il nostro esploratore

La discesa del gradiente “vanilla” — quella che abbiamo visto finora — funziona, ma ha i limiti che abbiamo descritto: può essere lenta, può oscillare, può restare bloccata. Nel corso degli anni, i ricercatori hanno sviluppato varianti che risolvono questi problemi. Senza entrare nelle formule, ecco le idee chiave.

Stochastic Gradient Descent (SGD)

Invece di calcolare il gradiente sull’intero dataset ad ogni passo (computazionalmente costosissimo), SGD lo calcola su un piccolo campione casuale (mini-batch). È come se la persona bendata, invece di tastare l’intero terreno intorno a sé, tastasse solo qualche punto a caso. La stima della pendenza è rumorosa, ma mediamente corretta, e la velocità di calcolo è enormemente maggiore. Il rumore, paradossalmente, è anche utile: aiuta a sfuggire ai minimi locali e ai punti di sella.

Momentum

Immagina una palla che rotola giù per la collina invece di una persona che cammina. La palla accumula velocità: se la pendenza continua nella stessa direzione, accelera. Se la pendenza cambia direzione, la palla rallenta prima di invertire. Questo è il momentum: l’algoritmo “ricorda” la direzione in cui si stava muovendo e ci aggiunge il gradiente attuale. Il risultato è che attraversa più velocemente le zone piatte e oscilla meno nelle valli strette.

Adam: il coltellino svizzero

Adam (Adaptive Moment Estimation) combina l’idea del momentum con un learning rate che si adatta automaticamente per ogni parametro. I parametri che cambiano poco ottengono passi più grandi; quelli che cambiano molto ottengono passi più piccoli. È come se la persona bendata avesse scarpe intelligenti che regolano la lunghezza del passo in base al terreno sotto ogni piede.

Adam è diventato lo standard de facto per addestrare la maggior parte delle reti neurali moderne. È robusto, richiede poca regolazione manuale, e funziona bene in una vasta gamma di problemi. Quasi tutti i modelli che usi quotidianamente — da Spotify a ChatGPT — sono stati addestrati con Adam o con una sua variante.

Ritorno alla montagna

La persona bendata da cui siamo partiti ora ha scarpe migliori. Ha una palla che accumula velocità invece di gambe che fanno passi rigidi. Ha suole che si adattano automaticamente al terreno. E soprattutto, non cammina su una montagna con due o tre dimensioni: cammina su un paesaggio con miliardi di dimensioni.

Ma il principio è esattamente lo stesso. Senti la pendenza. Fai un passo nella direzione in cui scende. Ripeti.

La discesa del gradiente non è un algoritmo spettacolare. Non ha la complessità elegante di un algoritmo genetico o il fascino narrativo delle reti adversariali. È una procedura meccanica, quasi banale. Ma è la procedura meccanica su cui si regge l’intera rivoluzione dell’intelligenza artificiale. Dai suggerimenti di Netflix ai modelli che generano immagini, dalla guida autonoma alla traduzione simultanea, tutto si riduce a questo: una funzione da minimizzare, un gradiente da calcolare, un passo da fare.

La prossima volta che un assistente vocale capisce la tua domanda, o che un traduttore automatico indovina una sfumatura, ricorda: dietro le quinte, una versione molto sofisticata della nostra persona bendata ha camminato per miliardi di passi su un paesaggio con miliardi di dimensioni. E ha trovato una valle abbastanza profonda da essere utile.

Per approfondire

Per inquadrare la discesa del gradiente nel contesto più ampio dell’apprendimento statistico, An Introduction to Statistical Learning di James, Witten, Hastie e Tibshirani è la lettura che consigliamo: rigorosa ma sempre orientata alla pratica.

I ricercatori hanno perfezionato la discesa del gradiente per oltre 150 anni, ma un recente studio ha dimostrato che un suo presupposto di base potrebbe essere sbagliato. Il lavoro ha mostrato che la tecnica può funzionare quasi 3 volte più velocemente se infrange una regola accettata da tempo su come trovare la soluzione ottimale.

La discesa del gradiente usa una “funzione di costo¹” per capire dove si trova il punto ottimo. Gli algoritmi si muovono seguendo il gradiente più ripido della curva per raggiungere il minimo della funzione.

La saggezza consolidata è che l’algoritmo debba muoversi con piccoli passi per non “oltrepassare” la soluzione. Ma il nuovo studio ha scoperto che una sequenza con un grande passo al centro converge più velocemente. Questo approccio ciclico con un “salto gigante” può arrivare al punto ottimo 3 volte più rapidamente.

La ricerca rimette in discussione l’intuizione su come funziona al meglio la discesa del gradiente. Anche se difficilmente cambierà l’uso pratico della tecnica, costringe a riconsiderare la teoria che vi è dietro.

Fonte: Quanta Magazine

1. Una “funzione di costo” è una misura quantitativa che valuta l’adeguatezza delle previsioni generate da un modello rispetto ai dati di addestramento. In termini più precisi, una funzione di costo assegna un valore numerico a ciascuna previsione del modello in base alla discrepanza tra la previsione e il valore reale associato. L’obiettivo della funzione di costo è minimizzare questo valore numerico, indicando una migliore aderenza del modello ai dati di addestramento. In molti algoritmi di apprendimento automatico, la scelta della funzione di costo influisce sulla capacità del modello di apprendere e generalizzare correttamente dai dati. ↩︎

Con la regressione lineare abbiamo imparato a prevedere un numero. Qui però il risultato è un interruttore, acceso o spento, e la retta non è lo strumento giusto: vedremo che arriva perfino a prevedere probabilità negative. Lo strumento giusto è la regressione logistica, uno dei modelli più usati in assoluto, dal marketing alla medicina. Costruiamola insieme, partendo proprio da un esempio di conversioni.

In sintesi: la regressione logistica è il modello statistico che stima la probabilità di un esito binario (converte o no, clicca o no) in base a una o più variabili. Invece di una retta usa la funzione logistica, una curva a S che resta sempre fra 0 e 1. I coefficienti sono espressi in log-odds: elevati a esponente diventano odds ratio, cioè di quante volte si moltiplicano gli odds dell’evento quando una variabile aumenta di un’unità. In R si stima con glm(..., family = binomial) e si ottengono le probabilità con predict(..., type = "response"). Per classificare serve poi una soglia, che con eventi rari va scelta con cura: 0,5 non è quasi mai quella giusta.

Di cosa parleremo:

• Perché una retta non basta?
• Da probabilità a odds a logit: l’equazione logistica
• Come si stima una regressione logistica in R?
• Come si leggono i coefficienti? Gli odds ratio
• Dalle probabilità alle decisioni: dove mettere la soglia?
• Le condizioni per usarla
• Domande frequenti
• Prova tu
• Per approfondire

Perché una retta non basta?

Prendiamo 5.000 sessioni organiche di un e-commerce. Per ciascuna conosciamo tre cose: quante pagine ha visto, se arrivava da smartphone o da desktop, e se la query di partenza conteneva il nome del brand. E sappiamo se la sessione si è chiusa con un acquisto: hanno convertito in 271, il 5,4%. I dati sono simulati, così conosciamo la verità e possiamo controllare se il modello la ritrova.

L’idea più immediata è trattare la conversione come un numero, 1 se c’è stata e 0 se no, e farci passare sopra una retta coi minimi quadrati. Ha perfino un nome, modello lineare di probabilità, e in qualche caso funziona in modo accettabile. Ma guardiamo cosa succede ai nostri dati.

La retta dice che ogni pagina in più vale sempre 1,9 punti percentuali di conversione, sia che si passi da 1 a 2 pagine sia che si passi da 8 a 9. I dati raccontano un’altra storia: chi vede poche pagine converte pochissimo e quasi a prescindere, poi la probabilità accelera. E quando aggiungiamo anche dispositivo e brand le cose peggiorano: il modello lineare assegna a 654 sessioni su 5.000 una probabilità di conversione negativa, fino a −2,2%. Una probabilità sotto zero non ha alcun significato. Dall’altra parte, al profilo migliore (12 pagine, desktop, query brand) assegna il 28,8% quando la logistica, come vedremo, stima il 72,9%.

Il problema è di forma. Una probabilità vive fra 0 e 1, e vicino ai bordi deve per forza «frenare»: non si può salire oltre il 100% né scendere sotto lo zero. Una retta, invece, prosegue all’infinito. Serve una curva che abbia i freni incorporati.

Da probabilità a odds a logit: l’equazione logistica

La regressione logistica risolve il problema con un cambio di scala in due passi. Il primo passo sono gli odds, una parola che chi frequenta le scommesse conosce bene: invece della probabilità che un evento accada, si guarda il rapporto fra la probabilità che accada e quella che non accada.

\(\text{odds} = \frac{p}{1-p}\)

Con una probabilità del 20%, gli odds sono 0,2 / 0,8 = 0,25: «uno a quattro», un successo ogni quattro insuccessi. Con il 50% gli odds valgono 1, e con l’80% salgono a 4. Gli odds non hanno il tetto dell’1: vanno da zero a infinito.

Il secondo passo è prenderne il logaritmo. Il logaritmo degli odds, chiamato logit, toglie anche il pavimento dello zero e può assumere qualunque valore, da meno infinito a più infinito. Ed è proprio su questa scala libera che la regressione logistica mette la sua equazione lineare, identica nella forma a quella della regressione multipla:

\(\ln\left(\frac{p}{1-p}\right) = b_0 + b_1 x_1 + b_2 x_2 + \dots + b_k x_k\)

dove p è la probabilità dell’evento, le x sono le variabili (i predittori) e le b i coefficienti da stimare. Per tornare alla probabilità basta invertire il percorso, e si ottiene la funzione logistica, detta anche sigmoide per la sua forma a S:

\(p = \frac{1}{1 + e^{-(b_0 + b_1 x_1 + \dots + b_k x_k)}}\)

Qualunque valore assuma l’espressione fra parentesi, il risultato resta sempre compreso fra 0 e 1. Ecco i freni incorporati: la logistica è una retta sulla scala dei log-odds, che diventa una curva a S sulla scala delle probabilità.

I coefficienti non si trovano coi minimi quadrati ma con il metodo della massima verosimiglianza: fra tutte le curve possibili, si sceglie quella che rende più probabili i dati che abbiamo effettivamente osservato. Il calcolo è iterativo e lo lasciamo volentieri al software.

Come si stima una regressione logistica in R?

Simuliamo le 5.000 sessioni. Nella realtà i dati arriverebbero da Google Analytics o dal CRM; qui li costruiamo noi, con effetti noti, per poter verificare il risultato:

set.seed(7)
n <- 5000
sessioni <- data.frame(
  pagine = 1 + rpois(n, 2.5),    # pagine viste nella sessione
  mobile = rbinom(n, 1, 0.6),    # 1 = smartphone, 0 = desktop
  brand  = rbinom(n, 1, 0.25)    # 1 = arrivata da una query col nome del brand
)
logit_vero <- -4.4 + 0.35 * sessioni$pagine - 0.5 * sessioni$mobile + 1.2 * sessioni$brand
sessioni$converte <- rbinom(n, 1, plogis(logit_vero))

mean(sessioni$converte)
# [1] 0.0542

La funzione plogis() è proprio la funzione logistica: trasforma il logit vero in una probabilità, e rbinom() lancia per ogni sessione una moneta truccata con quella probabilità. È il motivo per cui nel modello compare family = binomial: ogni sessione è una prova di Bernoulli, il mattone della distribuzione binomiale.

Stimiamo il modello:

modello <- glm(converte ~ pagine + mobile + brand, data = sessioni, family = binomial)
summary(modello)
# Coefficients:
#             Estimate Std. Error z value Pr(>|z|)
# (Intercept) -4.37566    0.18872 -23.187  < 2e-16 ***
# pagine       0.34742    0.03584   9.693  < 2e-16 ***
# mobile      -0.50057    0.12834  -3.900 9.61e-05 ***
# brand        1.19691    0.12868   9.302  < 2e-16 ***
#
#     Null deviance: 2107.0  on 4999  degrees of freedom
# Residual deviance: 1923.8  on 4996  degrees of freedom
# AIC: 1931.8

Il modello ritrova quasi alla perfezione i valori con cui abbiamo costruito i dati: 0,347 contro 0,35 per le pagine, −0,501 contro −0,5 per il mobile, 1,197 contro 1,2 per il brand. Le colonne si leggono come nella regressione lineare: stima, errore standard, la statistica z (qui al posto della t) e il p-value. La devianza è l’equivalente logistico della somma dei quadrati dei residui: scende da 2107 (il modello senza predittori) a 1924, segno che le tre variabili spiegano qualcosa.

Già il segno dei coefficienti dice molto: più pagine e query brand fanno salire la probabilità di conversione, lo smartphone la fa scendere. Ma quanto? Qui la logistica chiede un passo in più.

Come si leggono i coefficienti? Gli odds ratio

I coefficienti sono sulla scala dei log-odds, che nessuno ha l’abitudine di pensare. Il trucco è elevarli a esponente: e elevato al coefficiente è l’odds ratio, il numero per cui si moltiplicano gli odds della conversione quando la variabile aumenta di un’unità, a parità delle altre. Calcoliamoli insieme ai loro intervalli di confidenza:

round(exp(cbind(OR = coef(modello), confint(modello))), 3)
#                OR 2.5 % 97.5 %
# (Intercept) 0.013 0.009  0.018
# pagine      1.415 1.319  1.519
# mobile      0.606 0.471  0.780
# brand       3.310 2.572  4.261

Traduciamo riga per riga:

• pagine: ogni pagina vista in più moltiplica gli odds di conversione per 1,415, cioè li fa crescere del 41,5% circa (con un intervallo fra +32% e +52%);
• mobile: da smartphone gli odds sono il 60,6% di quelli da desktop, circa il 40% in meno;
• brand: una sessione arrivata da una query col nome del brand ha odds 3,3 volte quelli di una sessione non brand.

Nessuno degli intervalli contiene l’1, il valore che significherebbe «nessun effetto».

Quest’ultimo punto merita un grafico. Calcoliamo le probabilità previste per quattro profili di sessione, con type = "response", che restituisce probabilità invece di log-odds:

profili <- data.frame(pagine = c(3, 3, 8, 8),
                      mobile = c(1, 0, 1, 0),
                      brand  = c(0, 1, 0, 1))
round(predict(modello, newdata = profili, type = "response"), 3)
#     1     2     3     4
# 0.021 0.106 0.109 0.401

Una sessione da smartphone, non brand, con 3 pagine viste converte col 2,1% di probabilità. Lo stesso numero di pagine da desktop e da query brand vale il 10,6%. Con 8 pagine, desktop e brand, si arriva al 40,1%.

Verifichiamo il primo valore a mano, per vedere che non c’è magia. Il logit vale −4,376 + 0,347 × 3 − 0,501 × 1 + 1,197 × 0 = −3,834. La probabilità è 1 / (1 + e^3,834) = 1 / (1 + 46,2) = 0,021.

Le quattro curve condividono lo stesso odds ratio per pagina, 1,415. Eppure in punti percentuali l’effetto di una pagina in più cambia moltissimo: per una sessione mobile non brand, passare da 2 a 3 pagine aggiunge 0,6 punti (dall’1,5% al 2,1%); per una sessione mobile da query brand, passare da 8 a 9 ne aggiunge 7,6 (dal 28,9% al 36,5%). È la curva a S al lavoro, ed è il motivo per cui nei report conviene riportare sia l’odds ratio sia qualche probabilità prevista per profili concreti.

Dalle probabilità alle decisioni: dove mettere la soglia?

Spesso dal modello vogliamo una decisione: a quali sessioni mostrare un’offerta, quali utenti inserire in una campagna di remarketing. Per trasformare una probabilità in un sì o un no serve una soglia, e la scelta istintiva è 0,5: se la probabilità supera il 50%, prevediamo una conversione.

Per giudicare il modello in modo onesto, però, non possiamo valutarlo sugli stessi dati con cui l’abbiamo stimato. Dividiamo le sessioni: stimiamo su 3.500 e misuriamo le previsioni sulle altre 1.500, che il modello non ha mai visto.

set.seed(11)
righe <- sample(n, 3500)
addestramento <- sessioni[righe, ]
test <- sessioni[-righe, ]
modello_add <- glm(converte ~ pagine + mobile + brand, data = addestramento, family = binomial)
p_test <- predict(modello_add, newdata = test, type = "response")

table(previsto = p_test > 0.5, reale = test$converte)
#         reale
# previsto    0    1
#    FALSE 1410   89
#    TRUE     1    0
mean((p_test > 0.5) == test$converte)
# [1] 0.94

Accuratezza del 94%: sembra un ottimo risultato. Ma guardiamo la tabella: delle 89 sessioni che hanno convertito davvero, il modello non ne ha individuata nessuna. Ha semplicemente risposto «no» quasi sempre. E con un tasso di conversione del 5,9%, chi risponde sempre «no» senza nessun modello ottiene un’accuratezza del 94,1%, meglio di noi.

Con eventi rari, l’accuratezza è una metrica che inganna. Il modello non è inutile: è la soglia a essere sbagliata. Nei nostri dati quasi nessuna sessione supera il 50% di probabilità, quindi una soglia a 0,5 equivale a non segnalare mai niente. Abbassiamola a 0,1:

table(previsto = p_test > 0.1, reale = test$converte)
#         reale
# previsto    0    1
#    FALSE 1292   62
#    TRUE   119   27

Ora il modello segnala 146 sessioni e ne prende 27 che convertono davvero: il 30% delle conversioni (la sensibilità, o recall). Fra le sessioni segnalate, il 18,5% converte (la precisione), più del triplo del 5,9% di partenza. L’accuratezza scende all’88%, ma il modello è diventato utile.

Il grafico mostra il compromesso. Le sessioni che convertono stanno in media più a destra, ma le due distribuzioni si sovrappongono molto: ogni soglia è uno scambio fra conversioni prese e falsi allarmi. La soglia giusta non la decide la statistica, la decide il costo degli errori: se mostrare un’offerta a chi non comprerà costa poco, conviene una soglia bassa.

Per giudicare il modello indipendentemente dalla soglia si usa spesso l’AUC, l’area sotto la curva ROC: è la probabilità che, presa a caso una sessione che converte e una che non converte, il modello assegni alla prima una probabilità più alta. Vale 0,5 per un modello che tira a indovinare e 1 per uno perfetto. Calcoliamola con i ranghi, la stessa idea del test di Wilcoxon:

r <- rank(p_test)
n1 <- sum(test$converte); n0 <- sum(1 - test$converte)
round((sum(r[test$converte == 1]) - n1 * (n1 + 1) / 2) / (n1 * n0), 3)
# [1] 0.749

Un’AUC di 0,75 è un risultato discreto: con solo tre variabili, il modello ordina correttamente tre coppie su quattro.

Le condizioni per usarla

La regressione logistica chiede meno della regressione lineare (niente normalità dei residui, niente varianza costante), ma qualche condizione resta:

• l’esito è binario: due sole categorie (per tre o più ne parliamo nelle domande frequenti);
• le osservazioni sono indipendenti: dieci sessioni dello stesso utente non sono dieci informazioni indipendenti;
• la relazione è lineare sulla scala del logit: se l’effetto delle pagine cresce fino a un certo punto e poi si appiattisce, va modellato (per esempio con classi di pagine viste);
• i predittori non sono troppo correlati fra loro, il problema della multicollinearità di cui parleremo nel prossimo articolo;
• ci sono abbastanza eventi: una regola pratica diffusa chiede almeno una decina di eventi (nel nostro caso, conversioni) per ogni predittore. Noi ne abbiamo 271 per 3 variabili, ampiamente sopra.

C’è infine una condizione meno nota, e capita di leggere l’esatto contrario: che la regressione logistica si usi «quando i dati sono linearmente separabili». È vero l’opposto: se una variabile separa perfettamente i sì dai no, la logistica va in crisi. La massima verosimiglianza spinge il coefficiente verso l’infinito per rendere la curva un gradino perfetto, e l’errore standard esplode. Succede più spesso di quanto si pensi, anche con dataset famosi.

Domande frequenti

Che differenza c’è fra regressione lineare e regressione logistica?

La regressione lineare prevede una variabile numerica continua, come il traffico o il fatturato. La regressione logistica prevede la probabilità di un esito binario, come converte o non converte. Per farlo modella in modo lineare il logaritmo degli odds e restituisce probabilità sempre comprese fra 0 e 1.

Cos’è l’odds ratio nella regressione logistica?

È l’esponenziale di un coefficiente: indica per quanto si moltiplicano gli odds dell’evento quando la variabile aumenta di un’unità, a parità delle altre. Un odds ratio di 1,4 significa odds più alti del 40%, uno di 0,6 odds più bassi del 40%, uno pari a 1 nessun effetto.

Regressione logistica e regressione logaritmica sono la stessa cosa?

No. Nella regressione logaritmica la variabile da prevedere resta numerica e continua, e la relazione con il predittore passa per un logaritmo (per esempio y = a + b·ln x). Nella regressione logistica la variabile da prevedere è binaria, e il logaritmo riguarda gli odds dell’evento.

Cosa si usa se le categorie sono più di due?

Se le categorie non hanno un ordine (per esempio desktop, mobile e tablet) si usa la regressione logistica multinomiale, in R con multinom() del pacchetto nnet. Se hanno un ordine naturale (basso, medio, alto) si usa la regressione logistica ordinale, in R con polr() del pacchetto MASS.

Qual è la soglia giusta per classificare?

Dipende dal costo dei due tipi di errore e da quanto è frequente l’evento. Con eventi rari, come le conversioni, la soglia di 0,5 porta spesso a non segnalare mai niente. Conviene guardare la tabella delle previsioni per più soglie, oppure l’AUC per valutare il modello indipendentemente dalla soglia.

Quanti dati servono per una regressione logistica?

Conta soprattutto il numero di eventi, cioè dei casi nella categoria meno frequente. Una regola pratica diffusa ne chiede almeno una decina per ogni predittore: con 50 conversioni, meglio non andare oltre quattro o cinque variabili.

Prova tu

Il codice dell’articolo si presta a qualche esperimento.

• Si prova la soglia 0,2 al posto di 0,1: quante conversioni prende il modello, e con quanti falsi allarmi? Si confronta la precisione con quella a 0,1.
• Si toglie il brand dal modello (converte ~ pagine + mobile) e si guarda l’AUC sul test: quanto vale, da sola, l’informazione sulla query di partenza?
• Si porta il coefficiente vero delle pagine da 0,35 a 0,7 nella simulazione: come cambia la forma della curva, e cosa succede alla soglia di 0,5?

L’ultimo esercizio mostra bene il legame fra la forza dei predittori e la difficoltà della classificazione: un modello con effetti forti spinge le probabilità verso i bordi, e lì una soglia vale l’altra.

Nel nostro esempio le tre variabili sono indipendenti per costruzione: le pagine viste non dipendono dal dispositivo, il brand non dipende dalle pagine. Nella realtà non è quasi mai così. Chi arriva da una ricerca col nome del brand tende anche a sfogliare più pagine, e quando i predittori si sovrappongono i coefficienti diventano instabili e difficili da separare. È la multicollinearità, e insieme ad altri due nomi che spaventano più di quanto meritino, l’eteroschedasticità e l’autocorrelazione, è la prossima tappa del nostro viaggio nella regressione.

Per approfondire

Per vedere la regressione logistica nel suo contesto più ampio consiglio Introduzione all’econometria di Stock e Watson: dedica un capitolo intero alla regressione con variabile dipendente binaria, parte proprio dal modello lineare di probabilità e dai suoi limiti, e mostra con esempi concreti perché logit e probit li superano.

Il Machine Learning sta cambiando il modo in cui vediamo il mondo intorno a noi.
Dalla previsione del tempo alla diagnosi medica, dalla raccomandazione di contenuti su una piattaforma di streaming all’identificazione di frodi finanziarie, il Machine Learning è sempre più presente nella nostra vita quotidiana.

Ma cos’è esattamente e come funziona? In questo post ti guiderò attraverso i concetti fondamentali del Machine Learning e ti mostrerò come può essere utilizzato per risolvere problemi reali. Ti mostrerò anche come iniziare ad apprendere il Machine Learning, quali sono le risorse disponibili e come utilizzare questa tecnologia per migliorare la tua vita e il tuo lavoro.

Caveat: Questo articolo è una semplice introduzione a un argomento vastissimo. E’ stato scritto per chi vuole comprendere i concetti di base del Machine Learning, senza necessità di conoscenze tecniche o matematiche avanzate. Al termine del post fornirò una serie di risorse utili a chiunque volesse approfondire l’argomento e continuare un percorso straordinariamente affascinante…

Cos’è il Machine Learning

Il Machine Learning, o apprendimento automatico, è una tecnologia che permette alle macchine di “imparare” dai dati e migliorare le proprie prestazioni senza essere esplicitamente programmate. In altre parole, il Machine Learning consente alle macchine di “imparare” dall’esperienza, proprio come fanno gli esseri umani.

Esistono due tipi principali di Machine Learning: il Machine Learning supervisionato e il Machine Learning non supervisionato.

Nel Machine Learning supervisionato, il modello è “allenato” su un insieme di dati che include esempi di input e output desiderati. Il modello utilizza quindi questi esempi per fare previsioni sui nuovi dati.
Nel Machine Learning non supervisionato, invece, il modello deve “scoprire” da solo le strutture e le relazioni all’interno dei dati senza essere guidato da esempi pre-definiti.

Il Machine Learning è utilizzato in una vasta gamma di applicazioni, dalla previsione del tempo alla diagnosi medica, dalla raccomandazione di contenuti alla identificazione di frodi finanziarie. In generale, l’obiettivo del Machine Learning è quello di automatizzare decisioni e previsioni basate sui dati, migliorando l’efficienza e la precisione del processo.

Tipi di Machine Learning: Machine Learning supervisionato e non supervisionato

Come abbiamo già visto, il Machine Learning può essere suddiviso in due categorie principali: il Machine Learning supervisionato e il Machine Learning non supervisionato.

Il Machine Learning supervisionato è il tipo più comune di apprendimento automatico e si basa su un insieme di dati già etichettati. In altre parole, il modello di apprendimento automatico è “allenato” su un insieme di dati che include esempi di input e output desiderati. Il modello utilizza quindi questi esempi per imparare a fare inferenze su nuovi dati. Ad esempio, un classificatore di posta indesiderata potrebbe essere allenato su un insieme di e-mail etichettate come “spam” o “non spam“, e quindi utilizzato per classificare nuove e-mail in arrivo.

Il Machine Learning non supervisionato, invece, si basa su un insieme di dati non etichettati. In altre parole, il modello di apprendimento automatico deve “imparare” da solo a scoprire strutture e relazioni all’interno dei dati. Un esempio tipico di questo tipo di apprendimento automatico è il clustering, in cui i dati vengono suddivisi in gruppi (cluster) in base alle loro somiglianze.

In generale possiamo dire che il Machine Learning supervisionato utilizza dati etichettati per fare predizioni/classificazioni mentre il Machine Learning non supervisionato utilizza dati non etichettati per fare scoperte o identificare relazioni all’interno dei dati.

I principali algoritmi di Machine Learning supervisionato

I principali algoritmi di Machine Learning supervisionato sono:

• Regressione lineare: utilizzata per previsioni quantitative su una variabile continua. Ad esempio, per previsioni del prezzo di un’abitazione in base alla sua metratura.
  
  Ho scritto dei post specifici sull’argomento, che ritengo possano essere molto utili per una corretta comprensione:
  Correlazione e regressione lineare
  L’analisi di regressione multipla spiegata semplice
  
• Regressione logistica: utilizzata per previsioni di variabili categoriche, ovvero quando l’output è una classe tra due o più possibili. Ad esempio, la previsione per un paziente: soffre di una determinata malattia o meno?
  
• Alberi di decisione: utilizzati per la classificazione e la regressione. Consistono in un grafico di decisione in cui ogni nodo rappresenta una decisione e ogni ramo rappresenta un esito.
  
• Random Forest: una variante degli alberi di decisione dove vengono utilizzati più alberi per fare la previsione e poi si utilizza la media delle previsioni degli alberi.
  
• Gradient Boosting: un algoritmo che utilizza una serie di alberi di decisione in successione per migliorare la previsione.
  
• Support Vector Machine (SVM): utilizzato per la classificazione in cui i dati sono separabili linearmente.
  
• k-Nearest Neighbors (k-NN): utilizzato per la classificazione basato sulla similarità dei dati rispetto ad un punto di riferimento.
  
• Naive Bayes: utilizzato per la classificazione basato su probabilità.

I principali algoritmi di Machine Learning non supervisionato

• Clustering: utilizzato per suddividere i dati in gruppi o cluster in base alle loro somiglianze. L’algoritmo più comune di clustering è l’algoritmo k-means.
  
• Analisi delle componenti principali (PCA): utilizzato per ridurre la dimensionalità dei dati, ovvero per trasformare un insieme di variabili correlate in un insieme di variabili non correlate.
  
• Analisi della densità del dato (DBSCAN): utilizzato per trovare i cluster in base alla densità dei dati.
  
• Analisi delle associazioni (Apriori, FP-Growth): utilizzato per trovare regole di associazione tra le variabili.
  
• Algoritmi di rilevamento di anomalie (One-class SVM, Isolation Forest): utilizzato per rilevare gli elementi che si discostano dalla norma
  
• Analisi della mappa auto-organizzativa (SOM): utilizzato per visualizzare la struttura nascosta nei dati.
  
• Algoritmi di rilevamento di struttura (Spectral Clustering, Hierarchical Clustering): utilizzato per trovare relazioni gerarchiche nei dati.

Questi sono alcuni dei principali algoritmi di Machine Learning non supervisionato, ma ce ne sono molti altri.
Come per il Machine Learning supervisionato, la scelta dell’algoritmo dipende dalle caratteristiche del problema specifico e dalle caratteristiche dei dati.

In pratica, scegliere il giusto algoritmo da applicare alla specifica soluzione è una decisione delicatissima che può segnare il successo o il completo fallimento di un’attività di analisi dati.

Le fasi principali del processo di utilizzo del Machine Learning

1. Raccolta dei dati: La prima fase consiste nel raccogliere i dati necessari per il problema da risolvere. Questi dati devono essere puliti, formattati e preparati per l’elaborazione.
2. Analisi dei dati: Una volta che i dati sono stati raccolti, è importante esplorarli per capire meglio il problema e identificare eventuali relazioni o caratteristiche interessanti.
3. Scelta del modello: La fase successiva consiste nella scelta del modello di apprendimento automatico più appropriato per il problema da risolvere. Esistono molti algoritmi di Machine Learning disponibili, tra cui alberi di decisione, reti neurali e support vector machine (SVM).
4. Addestramento del modello: Una volta selezionato il modello, questo deve essere “allenato” utilizzando i dati di addestramento. Questo processo permette al modello di “imparare” dai dati e di essere in grado di fare previsioni sui dati nuovi.
5. Valutazione del modello: Una volta allenato, il modello deve essere valutato su un insieme di dati di prova per verificare la sua accuratezza.
6. Deploy del modello: Se il modello ha mostrato buone prestazioni, può essere utilizzato per risolvere il problema in questione e portato in ambiente di produzione.
7. Monitoraggio e manutenzione: il modello deve essere monitorato per garantire che continui a funzionare correttamente e eventualmente essere aggiornato o sostituito se le prestazioni diminuiscono.

Come iniziare ad apprendere il Machine Learning: tutorial e risorse

L’apprendimento automatico (Machine Learning) è un campo in rapida evoluzione e ci sono molte risorse disponibili per coloro che vogliono iniziare ad apprenderlo.
Un elenco risulta necessariamente incompleto e soggetto a “gusti” personali, tuttavia si può partire da:

Tutorial: Ci sono numerosissimi tutorial disponibili online che coprono i concetti di base del Machine Learning.
Ad esempio, il sito di scienza dei dati di scikit-learn ha una sezione di tutorial che spiega come utilizzare la libreria per creare alcuni dei modelli più comuni.
https://scikit-learn.org/stable/tutorial/index.html

Libri: Ci sono molti libri sull’argomento, ma alcuni dei classici del settore sono:
“Introduction to Machine Learning” di Alpaydin: https://www.amazon.it/dp/0262028182?tag=consulenzeinf-21&ascsubtag=machine-learning-una-guida-per-i-principianti
“Python Machine Learning” di Raschka e Mirjalili: https://www.packtpub.com/data/python-machine-learning-third-edition

Corsi online: Ci sono molti corsi online che coprono i concetti di base del Machine Learning, come quello eccellente di Andrew Ng su Coursera:
https://www.coursera.org/learn/machine-learning
o il corso di Machine Learning di fast.ai:
https://www.fast.ai/

Tool: Ci sono molti strumenti e librerie che possono essere utilizzati per esplorare i dati e costruire modelli. Alcuni dei più popolari includono:

scikit-learn: una libreria di apprendimento automatico per Python
https://scikit-learn.org/stable/
TensorFlow: una libreria di apprendimento automatico sviluppata da Google
https://www.tensorflow.org/
Keras: un’interfaccia di alto livello per costruire reti neurali in TensorFlow
https://keras.io/
PyTorch: una libreria di apprendimento automatico open-source sviluppata da Facebook
https://pytorch.org/

In generale, consiglio di iniziare con tutorial e corsi online per familiarizzare con i concetti di base e poi di continuare con l’esplorazione di libri e strumenti per sviluppare la comprensione e le abilità.
Per diventare un buon data scientist è importante anche lavorare su dati reali e non solo su tutorial o esercizi. Cercare progetti o competizioni di machine learning può aiutare ad acquisire esperienza concreta.

Sperimentare con il codice: Jupyter Lab e Google Colab

Jupyter Lab e Google Colab sono entrambi strumenti gratuiti e potenti per l’esplorazione dei dati, l’apprendimento e il test di codice per il Machine Learning.

Come utilizzare entrambi i tool per creare ambienti di sviluppo e condividere il proprio lavoro con altri?

Jupyter Lab è la nuova interfaccia per Jupyter Notebook che fornisce un ambiente di sviluppo integrato per lavorare con i notebook. E’ un ambiente di sviluppo interattivo che ti consente di scrivere, eseguire e documentare il codice Python e R all’interno di un browser web.
È particolarmente utile per l’analisi dei dati e per l’apprendimento del Machine Learning.

Per iniziare, devi installare Jupyter Lab sul tuo computer. Può essere fatto facilmente utilizzando Anaconda, una distribuzione Python che include Jupyter Lab e molte altre librerie di scienze dei dati. Una volta installato, puoi avviare Jupyter Lab dalla riga di comando e aprire un nuovo notebook in cui scrivere e eseguire il tuo codice. Jupyter Lab si può usare al link: https://jupyter.org/

Esiste anche la possibilità di testare l’ambiente direttamente nel browser con JupiterLite:

Google Colab, invece, è un ambiente di sviluppo basato sul cloud, che consente di scrivere e eseguire il codice Python e R all’interno di un browser web senza alcuna installazione. È un’opzione molto comoda, perché puoi accedere a Colab da qualsiasi dispositivo con una connessione a Internet e puoi condividere il tuo lavoro con altri semplicemente fornendo un link. Inoltre ti permette di utilizzare una GPU o un TPU per rendere il tuo calcolo più potente. Google Colab si può usare al link: https://colab.research.google.com/

Entrambi gli strumenti ti consentono di creare una sequenza di celle che contengono codice e testo. Il codice può essere eseguito all’interno delle celle e i risultati visualizzati direttamente nel notebook. Ciò rende Jupyter Lab e Google Colab ideali per l’esplorazione dei dati, l’apprendimento del Machine Learning, la condivisione e la documentazione del proprio lavoro.

Per approfondire

Per proseguire il percorso nel Machine Learning consigliamo Introduction to Machine Learning di Ethem Alpaydın, il testo citato in questo articolo, e An Introduction to Statistical Learning di James, Witten, Hastie e Tibshirani, che unisce teoria e pratica con esempi in R.