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.

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. ↩︎

Si tratta di un algoritmo di Apprendimento Automatico Supervisionato che può essere utilizzato per modellare la probabilità di una determinata classe o evento. Viene utilizzato quando i dati sono linearmente separabili – cioè se esiste una linea o un piano che possono essere utilizzati per separare i dati in diverse classi in modo univoco – e l’esito è binario o dicotomico.
Ciò significa che la regressione logistica viene solitamente utilizzata per problemi di classificazione binaria (Sì/No, Corretto/Sbagliato, Vero/Falso, ecc.),

Nel corso di questo post mostrerò come eseguire una regressione logistica binomiale per creare un modello di classificazione, al fine di prevedere risposte binarie su un determinato insieme di predittori.

Come funziona la regressione logistica e i passi per costruirla

La regressione logistica è una tecnica di modellizzazione statistica utilizzata per prevedere la probabilità di un evento binario (ad esempio, sì/no, vero/falso) in base a un insieme di variabili indipendenti.

A differenza della regressione lineare, che è utilizzata per prevedere valori continui, la regressione logistica utilizza la funzione logistica per “modellizzare” la probabilità dell’evento osservato.

La regressione logistica utilizza la funzione logistica, anche conosciuta come sigmoide, per produrre la probabilità di un evento.
La funzione logistica produce un valore compreso tra 0 e 1, che può essere interpretato come una probabilità.
Dopo che il modello è stato addestrato, si può utilizzare per fare previsioni su nuovi dati, fornendo una stima della probabilità di un evento.

I passi per costruire una regressione logistica sono i seguenti:

1. Selezionare e raccogliere i dati: raccogli i dati che desideri utilizzare per prevedere l’evento binario e seleziona le variabili indipendenti che ritieni pertinenti per la tua analisi.
2. Pulire e preparare i dati: controlla i dati per eventuali valori mancanti o errati e assicurati che i dati siano adeguatamente formattati per l’analisi.
3. Costruire il modello: utilizza la funzione logistica per costruire il modello sui dati di training. La funzione logistica è una funzione “S-shaped” che restituisce valori compresi tra 0 e 1, che possono essere interpretati come probabilità.
4. Valutare il modello: Utilizza i dati di test per valutare l’accuratezza del modello. Ci sono varie metriche che si possono utilizzare per la valutazione, come l’accuratezza, la precisione e il recall.
5. Interpretare i risultati: analizza i coefficienti del modello per capire l’importanza relativa delle variabili indipendenti e per capire meglio come i valori delle variabili influiscono sulla probabilità dell’evento.
6. Utilizzare il modello per fare previsioni: utilizza il modello per fare previsioni sui nuovi dati in base alle variabili indipendenti fornite.

Questi sono ovviamente i passi generali per costruire una regressione logistica. Tuttavia, in alcune situazioni potrebbe essere necessario fare ulteriori operazioni o aggiustamenti, come ad esempio utilizzare metodi di regularizzazione per evitare problemi di overfitting, oppure utilizzare la cross-validation per avere una stima più affidabile dell’accuratezza del modello.

Un esempio in R: calcolare la probabilità di sopravvivenza sul Titanic

Pe fare un esempio pratico molto semplificato, ho scaricato un dataset tra i più noti e usati, quello relativo ai passeggeri del Titanic, che contiene informazioni sui passeggeri del famoso naufragio del Titanic, tra cui età, sesso, classe sociale e se i passeggeri sopravvissero o meno all’incidente.

Io l’ho preso da questo indirizzo e l’ho salvato in locale come titanic.csv

nb: il dataset Titanic è disponibile anche nella biblioteca di dati di Kaggle (kaggle.com) e nella raccolta di dataset UCI Machine Learning (archive.ics.uci.edu/ml/datasets.php).

Non ho bisogno in questo caso di pulire i dati, perchè utilizzo un set di dati “sicuro” e ampiamente testato.
Ovviamente, in un caso d’uso “reale” i dati andranno accuratamente esaminati, studiati, e “trattati” in fase preliminare…

Ecco allora un codice d’esempio in R:

# Carico le librerie
library(ggplot2)
library(caret)

# Carico i dati nel dataset titanic
# Sostituisco il percorso con quello nel mio pc
titanic <- read.csv("/ilmiopath/titanic.csv")

# Visualizzo le prime 10 righe
head(titanic, 10)

# Creo le variabili dummy per i campi categorici
titanic$Sex <- as.factor(titanic$Sex)
titanic$Survived <- as.factor(titanic$Survived)

# Creo un model di regressione logistica
model <- glm(Survived ~ Pclass + Sex + Age + SibSp + Parch + Fare + Embarked, data = titanic, family = binomial(link = "logit"))

# Mostro il modello
summary(model)


# Come predire la probabilita' di sopravvivenza di un caso di esempio
example <- data.frame(Pclass = 3, Sex = "male", Age = 32, SibSp = 0, Parch = 0, Fare = 8.05, Embarked = "S")
predict(model, newdata = example, type = "response")

# Visualizzo graficamente le probabilita' di sopravvivenza in base alla classe
ggplot(titanic, aes(x = Pclass, fill = factor(Survived))) + 
  geom_bar(position = "fill") +
  labs(x = "Classe", y = "Probabilita' di sopravvivenza") +
  scale_fill_discrete(name = "Sopravvissuto", labels = c("No", "Si"))

In questo caso, notiamo come un uomo di 32 anni in terza classe avrebbe avuto l’8,5% circa di probabilità di sopravvivere.
Graficamente, abbiamo poi modo di visualizzare la probabilità di sopravvivenza in base alla classe del posto.

Un po’ di matematica: l’equazione logit

Come abbiamo visto, l’equazione logit è un’equazione matematica che viene usata nella regressione logistica per descrivere la relazione tra la variabile dipendente (che può assumere solo valori binari) e una o più variabili indipendenti (chiamate anche predittori o covariate).

In generale la forma dell’equazione logit è la seguente:

dove:

p è la probabilità che la variabile dipendente assuma il valore “1”
logit(p) è chiamato logaritmo del rapporto di probabilità (log-odds)
b_0, b_1, b_2, …, b_n sono i coefficienti del modello (chiamati anche pesi o parametri)
x_1, x_2, …, x_n sono le variabili indipendenti (predittori o covariate)

In sintesi, l’equazione logit descrive come la probabilità di un evento (es. una risposta binaria) dipenda dai valori delle variabili indipendenti, attraverso i pesi del modello.

Tiriamo le somme

La regressione logistica è un potente modello statistico che può aiutare a prevedere il risultato di un evento in base a un insieme di variabili indipendenti. E’ facile da usare ed interpretare, e può essere utilizzato in molti ambiti, dalla medicina alla finanza.

Rappresenta uno strumento efficace per risolvere problemi di classificazione binaria perché consente di modellare la relazione tra la variabile dipendente binaria e una o più variabili indipendenti.

Consente di:

• Modellare la relazione tra una variabile dipendente binaria e una o più variabili indipendenti.
• Prevedere la probabilità che la variabile dipendente assuma un valore specifico (es. 1 o 0) in base ai valori delle variabili indipendenti.
• Utilizzare queste previsioni di probabilità per classificare nuovi casi in base a una soglia predefinita (ad esempio, se la probabilità di un caso di essere classificato come 1 è superiore a 0.5, allora viene classificato come 1, altrimenti come 0)
• Interpretare i pesi del modello (coefficienti) per comprendere quali variabili indipendenti sono più importanti per la classificazione.

Risorse per approfondire

I titoli e le risorse a disposizione sono innumerevoli. Qualche segnalazione:

• “Applied Logistic Regression” di David W. Hosmer, Jr., Stanley Lemeshow, Rodney X. Sturdivant (in lingua inglese)
• “Introduction to Statistical Learning” di Gareth James, Daniela Witten, Trevor
• https://www.analyticsvidhya.com/blog/2015/10/basics-logistic-regression/
• https://machinelearningmastery.com/logistic-regression-for-machine-learning/

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.com/Introduction-Machine-Learning-Adaptive-Computation/dp/0262028182
“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.