![\"Infografica:](\"https:\/\/www.gironi.it\/blog\/wp-content\/uploads\/2026\/03\/slide-esploratore-bendato.jpg\")
<\/figure>\n\n\n\n\n\n\n\nDa Cauchy alle reti neurali: una breve storia<\/h2>\n\n\n\n
L’idea di seguire la pendenza per trovare un minimo ha radici sorprendentemente antiche. Nel 1847<\/strong>, il matematico francese Augustin-Louis Cauchy pubblica un metodo per risolvere sistemi di equazioni che, nella sostanza, \u00e8 gi\u00e0 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\u00f9 di un secolo alla loro comparsa — ma aveva formalizzato il principio che ancora oggi alimenta l’intelligenza artificiale.<\/p>\n\n\n\n Per oltre un secolo l’idea resta confinata alla matematica pura. La svolta arriva nel 1951<\/strong>, quando Herbert Robbins e Sutton Monro propongono una versione stocastica<\/strong> del metodo: invece di calcolare il gradiente sull’intero problema, lo si stima su un campione casuale. \u00c8 il seme di quello che oggi chiamiamo Stochastic Gradient Descent<\/em> (SGD) — ne parleremo nella sezione finale. Pochi anni dopo, nel 1958<\/strong>, Frank Rosenblatt costruisce il perceptron<\/strong>, il primo modello di apprendimento automatico che usa la discesa del gradiente per imparare dai dati. L’entusiasmo \u00e8 enorme, ma dura poco: nel 1969 Minsky e Papert dimostrano i limiti del perceptron, e l’interesse per le reti neurali crolla. \u00c8 il cosiddetto inverno dell’intelligenza artificiale<\/em>.<\/p>\n\n\n\n La rinascita arriva nel 1986<\/strong>, quando David Rumelhart, Geoffrey Hinton e Ronald Williams pubblicano l’algoritmo di backpropagation<\/strong>: un modo efficiente per calcolare il gradiente in reti neurali con molti strati. \u00c8 la chiave che sblocca il deep learning. Da quel momento, la discesa del gradiente non \u00e8 pi\u00f9 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<\/strong>, con l’ottimizzatore Adam<\/strong> — che ritroveremo nella sezione finale di questo articolo. Quasi due secoli separano Cauchy da Adam, eppure il principio \u00e8 rimasto lo stesso: senti la pendenza, fai un passo nella direzione opposta.<\/p>\n\n\n\n Prima di scendere, dobbiamo sapere cosa<\/strong> stiamo minimizzando. La persona bendata cerca il punto pi\u00f9 basso della valle — ma nel machine learning, cos’\u00e8 esattamente quella valle?<\/p>\n\n\n\n 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 \u00e8 il pi\u00f9 semplice possibile: una retta che passa per l’origine, prezzo = m × superficie<\/strong>, dove m<\/em> \u00e8 l’unico parametro da regolare.<\/p>\n\n\n\n Per ogni valore di m<\/em>, il modello fa una previsione. Se m<\/em> \u00e8 troppo basso, le previsioni sottostimano i prezzi reali; se \u00e8 troppo alto, li sovrastimano. Abbiamo bisogno di un numero che ci dica quanto<\/em> il modello sta sbagliando: \u00e8 la funzione di costo<\/strong> (o loss function<\/em>, come dicono gli anglosassoni).<\/p>\n\n\n\n La funzione di costo pi\u00f9 usata \u00e8 l’errore quadratico medio<\/strong> (MSE, Mean Squared Error<\/em>): 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:<\/p>\n\n\n\n MSE(m) = (1\/n) ∑i<\/sub> (prezzoi<\/sub> − m × superficiei<\/sub>)²<\/strong><\/p>\n\n\n\n Se plottiamo MSE(m) al variare di m<\/em>, otteniamo una curva a forma di parabola: la stessa parabola che useremo tra poco come esempio della discesa del gradiente. Non \u00e8 una coincidenza — la parabola \u00e8 la funzione di costo<\/strong>, e il suo punto pi\u00f9 basso \u00e8 il valore di m<\/em> che rende il modello migliore possibile.<\/p>\n\n\n\n Gli esempi che seguono sono disponibili sia in R che in Python — ognuno segua il linguaggio con cui ha pi\u00f9 familiarit\u00e0.<\/p>\n\n\n\n Calcoliamo in R la funzione di costo per il nostro esempio delle case:<\/p>\n\n\n\n Verifichiamo in Python:<\/p>\n\n\n\n Ora sappiamo cosa minimizzare: la funzione di costo. Il gradiente ci dice come<\/em>.<\/p>\n\n\n\n Quando hai una funzione di una sola variabile — pensala come un sentiero che sale e scende — la derivata<\/strong> in un punto ti dice quanto \u00e8 ripido il sentiero in quel punto. Se la derivata \u00e8 positiva, stai salendo. Se \u00e8 negativa, stai scendendo. Se \u00e8 zero, sei su un tratto piatto: forse una cima, forse un avvallamento.<\/p>\n\n\n\n Esempio concreto: la funzione f(x) = x² descrive una parabola. La sua derivata \u00e8 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 \u00e8 zero: sei nel punto pi\u00f9 basso.<\/p>\n\n\n\n Nella realt\u00e0, le funzioni che ci interessano non dipendono da una sola variabile. Un modello di machine learning pu\u00f2 avere centinaia, migliaia, o miliardi di parametri. Il paesaggio non \u00e8 pi\u00f9 un sentiero, ma una superficie in uno spazio a molte dimensioni — impossibile da visualizzare, ma perfettamente gestibile dalla matematica.<\/p>\n\n\n\n Il gradiente<\/strong> \u00e8 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 \u00e8:<\/p>\n\n\n\n ∇f = (∂f\/∂x, ∂f\/∂y)<\/strong><\/p>\n\n\n\n Se dipende da mille variabili, il gradiente \u00e8 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<\/strong>.<\/p>\n\n\n\n Ecco la formula fondamentale della discesa del gradiente:<\/p>\n\n\n\n θnuovo<\/sub> = θvecchio<\/sub> − α · ∇f(θ)<\/strong><\/p>\n\n\n\n Smontiamola pezzo per pezzo:<\/p>\n\n\n\n \u00c8 tutto qui. Calcola dove stai salendo, fai un passo nella direzione opposta, ripeti.<\/p>\n\n\n\n Vediamo la discesa del gradiente in azione sulla funzione f(x) = x². Sappiamo che il minimo \u00e8 in x = 0. L’algoritmo riesce a trovarlo partendo da un punto casuale?<\/p>\n\n\n\n Verifichiamo in Python:<\/p>\n\n\n\n Eseguendo questo codice, si vede l’algoritmo partire da x = 10 e convergere rapidamente verso x = 0. I primi passi sono grandi (la pendenza \u00e8 ripida), poi si accorciano man mano che ci avviciniamo al fondo della parabola. Dopo 50 iterazioni, x \u00e8 praticamente zero.<\/p>\n\n\n\n Torniamo alla nostra persona bendata. Quant’\u00e8 grande il passo che fa ad ogni iterazione? Questa \u00e8 esattamente la domanda del learning rate<\/strong> (α), e la risposta \u00e8 meno banale di quanto sembri.<\/p>\n\n\n\n Passi troppo piccoli<\/strong> (α molto basso): la persona si muove con cautela estrema, spostando un piede di pochi centimetri alla volta. Alla fine arriver\u00e0 in fondo alla valle, ma potrebbe impiegare un’eternit\u00e0. Nel machine learning, questo significa tempi di addestramento lunghissimi e costi computazionali elevati.<\/p>\n\n\n\n Passi troppo grandi<\/strong> (α 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\u00f9 grandi e la persona finisce pi\u00f9 in alto di dove era partita. Nel machine learning, questo si chiama divergenza<\/em>: il modello peggiora invece di migliorare.<\/p>\n\n\n\n Passi giusti<\/strong>: un buon learning rate permette di scendere velocemente senza oscillare. Nella pratica, trovare il valore giusto richiede sperimentazione. \u00c8 uno degli aspetti pi\u00f9 artigianali del machine learning.<\/p>\n\n\n\n Come sa la persona bendata di essere arrivata? Sente che il terreno \u00e8 piatto in tutte le direzioni: il gradiente \u00e8 (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.<\/p>\n\n\n\n I criteri di arresto pi\u00f9 comuni sono:<\/p>\n\n\n\n Questo codice R mostra l’effetto di tre diversi valori di learning rate sulla stessa funzione:<\/p>\n\n\n\n Confrontiamo in Python:<\/p>\n\n\n\n Con α = 0.01 i punti rossi si muovono pigramente: dopo 30 iterazioni siamo ancora lontani dal minimo. Con α = 0.1 la convergenza \u00e8 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\u00f9 alto e divergerebbe del tutto.<\/p>\n\n\n\n Il paesaggio matematico di un modello reale non \u00e8 una bella parabola simmetrica. \u00c8 un terreno selvaggio, con valli secondarie, creste, altipiani e forme che sfidano l’immaginazione. Ecco i problemi classici, spiegati con l’analogia del paesaggio.<\/p>\n\n\n\n Immagina un terreno con pi\u00f9 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 \u00e8 quella pi\u00f9 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 \u00e8 da tutt’altra parte.<\/p>\n\n\n\n Nella pratica, questo \u00e8 un problema meno grave di quanto si pensasse. Le reti neurali moderne hanno cos\u00ec tanti parametri che i minimi locali tendono ad avere valori della funzione obiettivo simili al minimo globale. \u00c8 come un terreno con molte valli, ma tutte pi\u00f9 o meno alla stessa altitudine: finire in una qualsiasi va bene.<\/p>\n\n\n\n Un problema pi\u00f9 insidioso sono i punti di sella<\/strong> (saddle points<\/em>). 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 \u00e8 zero — il terreno sembra piatto — ma non sei in un minimo. Sei su un punto che \u00e8 minimo in alcune direzioni e massimo in altre.<\/p>\n\n\n\n In spazi ad alta dimensionalit\u00e0, i punti di sella sono molto pi\u00f9 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.<\/p>\n\n\n\n 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.<\/p>\n\n\n\n Questo accade quando le variabili del problema hanno scale molto diverse: alcune cambiano rapidamente, altre lentamente. \u00c8 un problema comune nella pratica, e una delle motivazioni principali per gli ottimizzatori avanzati come Adam, che vedremo nella sezione finale.<\/p>\n\n\n\n Finora abbiamo visto la discesa del gradiente su una parabola: un problema con una sola variabile. \u00c8 il caso pi\u00f9 semplice possibile. Ma il bello di questo algoritmo \u00e8 che funziona esattamente allo stesso modo a qualsiasi scala.<\/p>\n\n\n\n Ecco come cresce il numero di parametri man mano che i modelli diventano pi\u00f9 complessi:<\/p>\n\n\n\n Il principio \u00e8 identico: calcola il gradiente, fai un passo nella direzione opposta, ripeti. Quello che cambia \u00e8 la scala del calcolo. Il gradiente di GPT-4 \u00e8 un vettore con pi\u00f9 di mille miliardi di componenti, calcolato su miliardi di frammenti di testo, usando migliaia di processori in parallelo. Ma la formula \u00e8 la stessa che abbiamo visto sulla parabola.<\/p>\n\n\n\n Ogni volta che interagisci con un sistema di intelligenza artificiale, la discesa del gradiente ha lavorato dietro le quinte:<\/p>\n\n\n\n Il messaggio chiave \u00e8 questo: la potenza dell’AI moderna non sta nella complessit\u00e0 dell’algoritmo di ottimizzazione, ma nella scala<\/strong>. La discesa del gradiente \u00e8 concettualmente semplice. Quello che ha reso possibile la rivoluzione dell’intelligenza artificiale \u00e8 la capacit\u00e0 di applicarlo a modelli enormi su quantit\u00e0 enormi di dati, grazie a hardware sempre pi\u00f9 potente.<\/p>\n\n\n\n La discesa del gradiente “vanilla” — quella che abbiamo visto finora — funziona, ma ha i limiti che abbiamo descritto: pu\u00f2 essere lenta, pu\u00f2 oscillare, pu\u00f2 restare bloccata. Nel corso degli anni, i ricercatori hanno sviluppato varianti che risolvono questi problemi. Senza entrare nelle formule, ecco le idee chiave.<\/p>\n\n\n\n Invece di calcolare il gradiente sull’intero dataset ad ogni passo (computazionalmente costosissimo), SGD lo calcola su un piccolo campione casuale (mini-batch<\/em>). \u00c8 come se la persona bendata, invece di tastare l’intero terreno intorno a s\u00e9, tastasse solo qualche punto a caso. La stima della pendenza \u00e8 rumorosa, ma mediamente corretta, e la velocit\u00e0 di calcolo \u00e8 enormemente maggiore. Il rumore, paradossalmente, \u00e8 anche utile: aiuta a sfuggire ai minimi locali e ai punti di sella.<\/p>\n\n\n\n Immagina una palla che rotola gi\u00f9 per la collina invece di una persona che cammina. La palla accumula velocit\u00e0: se la pendenza continua nella stessa direzione, accelera. Se la pendenza cambia direzione, la palla rallenta prima di invertire. Questo \u00e8 il momentum: l’algoritmo “ricorda” la direzione in cui si stava muovendo e ci aggiunge il gradiente attuale. Il risultato \u00e8 che attraversa pi\u00f9 velocemente le zone piatte e oscilla meno nelle valli strette.<\/p>\n\n\n\n Adam<\/strong> (Adaptive Moment Estimation<\/em>) combina l’idea del momentum con un learning rate che si adatta automaticamente per ogni parametro. I parametri che cambiano poco ottengono passi pi\u00f9 grandi; quelli che cambiano molto ottengono passi pi\u00f9 piccoli. \u00c8 come se la persona bendata avesse scarpe intelligenti che regolano la lunghezza del passo in base al terreno sotto ogni piede.<\/p>\n\n\n\n Adam \u00e8 diventato lo standard de facto per addestrare la maggior parte delle reti neurali moderne. \u00c8 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.<\/p>\n\n\n\n La persona bendata da cui siamo partiti ora ha scarpe migliori. Ha una palla che accumula velocit\u00e0 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.<\/p>\n\n\n\n Ma il principio \u00e8 esattamente lo stesso. Senti la pendenza. Fai un passo nella direzione in cui scende. Ripeti.<\/p>\n\n\n\n La discesa del gradiente non \u00e8 un algoritmo spettacolare. Non ha la complessit\u00e0 elegante di un algoritmo genetico o il fascino narrativo delle reti adversariali. \u00c8 una procedura meccanica, quasi banale. Ma \u00e8 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.<\/p>\n\n\n\n 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.<\/p>\n","protected":false},"excerpt":{"rendered":"Di cosa parleremo<\/h3>\n
\n
La matematica, spiegata geometricamente<\/h2>\n\n\n\n
La funzione di costo: misurare quanto sbaglia il modello<\/h3>\n\n\n\n
# Funzione di costo: prevedere il prezzo di una casa\nsuperficie <- c(50, 70, 90, 120, 150)\nprezzo <- c(150, 200, 260, 340, 400) # migliaia di euro\n\n# Modello: prezzo = m * superficie\n# Funzione di costo MSE al variare di m\nm_valori <- seq(1, 4, by = 0.01)\nmse <- sapply(m_valori, function(m) mean((prezzo - m * superficie)^2))\n\nplot(m_valori, mse, type = \"l\", lwd = 2, col = \"steelblue\",\n xlab = \"m (pendenza)\", ylab = \"MSE\",\n main = \"Funzione di costo al variare di m\")\nm_ottimo <- m_valori[which.min(mse)]\nabline(v = m_ottimo, col = \"red\", lty = 2)\ncat(\"Il valore di m che minimizza l'errore:\", round(m_ottimo, 2), \"\\n\")<\/code><\/pre>\n\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Funzione di costo: prevedere il prezzo di una casa\nsuperficie = np.array([50, 70, 90, 120, 150])\nprezzo = np.array([150, 200, 260, 340, 400]) # migliaia di euro\n\n# Modello: prezzo = m * superficie\n# Funzione di costo MSE al variare di m\nm_valori = np.linspace(1, 4, 301) # equivalente a seq(1, 4, by=0.01) in R\nmse = np.array([np.mean((prezzo - m * superficie)**2) for m in m_valori])\n\nplt.plot(m_valori, mse, lw=2, color=\"steelblue\")\nplt.xlabel(\"m (pendenza)\")\nplt.ylabel(\"MSE\")\nplt.title(\"Funzione di costo al variare di m\")\nm_ottimo = m_valori[np.argmin(mse)]\nplt.axvline(m_ottimo, color=\"red\", linestyle=\"--\")\nplt.show()\nprint(f\"Il valore di m che minimizza l'errore: {m_ottimo:.2f}\")<\/code><\/pre>\n\n\n\nDerivata: la pendenza sotto i piedi<\/h3>\n\n\n\n
![\"Grafico](\"https:\/\/www.gironi.it\/blog\/wp-content\/uploads\/2026\/03\/slide-derivata-pendenza.jpg\")
<\/figure>\n\n\n\nIl gradiente: una bussola multidimensionale<\/h3>\n\n\n\n
\n
![\"Schema](\"https:\/\/www.gironi.it\/blog\/wp-content\/uploads\/2026\/03\/slide-anatomia-passo.jpg\")
<\/figure>\n\n\n\nUn esempio numerico in R<\/h3>\n\n\n\n
# Discesa del gradiente su f(x) = x^2\n# La derivata e' f'(x) = 2x\n\nf <- function(x) x^2 # funzione obiettivo\ngrad_f <- function(x) 2 * x # derivata (gradiente in 1D)\n\nx <- 10 # punto di partenza\nalpha <- 0.1 # learning rate\nn_iter <- 50 # numero di iterazioni\npercorso <- numeric(n_iter)\n\nfor (i in 1:n_iter) {\n percorso[i] <- x\n x <- x - alpha * grad_f(x) # la regola fondamentale\n}\n\ncat(\"Punto di partenza: 10\\n\")\ncat(\"Dopo 50 iterazioni: x =\", round(x, 8), \"\\n\")\ncat(\"Valore della funzione:\", round(f(x), 10), \"\\n\")\n\n# Visualizzazione del percorso\ncurve(x^2, from = -11, to = 11, lwd = 2, col = \"steelblue\",\n main = \"Discesa del gradiente su f(x) = x^2\",\n xlab = \"x\", ylab = \"f(x)\")\npoints(percorso, percorso^2, col = \"red\", pch = 19, cex = 0.7)\nlines(percorso, percorso^2, col = \"red\", lty = 2)<\/code><\/pre>\n\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Discesa del gradiente su f(x) = x^2\nf = lambda x: x**2 # funzione obiettivo\ngrad_f = lambda x: 2 * x # derivata (gradiente in 1D)\n\nx = 10.0 # punto di partenza\nalpha = 0.1 # learning rate\nn_iter = 50 # numero di iterazioni\npercorso = np.zeros(n_iter)\n\nfor i in range(n_iter):\n percorso[i] = x\n x = x - alpha * grad_f(x) # la regola fondamentale\n\nprint(f\"Punto di partenza: 10\")\nprint(f\"Dopo 50 iterazioni: x = {x:.8f}\")\nprint(f\"Valore della funzione: {f(x):.10f}\")\n\n# Visualizzazione del percorso\nxs = np.linspace(-11, 11, 200)\nplt.plot(xs, xs**2, lw=2, color=\"steelblue\")\nplt.plot(percorso, percorso**2, \"ro--\", markersize=4)\nplt.title(\"Discesa del gradiente su f(x) = x\u00b2\")\nplt.xlabel(\"x\")\nplt.ylabel(\"f(x)\")\nplt.show()<\/code><\/pre>\n\n\n\nIl learning rate: passi grandi o passi piccoli?<\/h2>\n\n\n\n
![\"Confronto](\"https:\/\/www.gironi.it\/blog\/wp-content\/uploads\/2026\/03\/slide-learning-rate.jpg\")
<\/figure>\n\n\n\nConvergenza: sapere quando fermarsi<\/h3>\n\n\n\n
\n
L’effetto del learning rate: un confronto visuale<\/h3>\n\n\n\n
# Confronto di tre learning rate sulla funzione f(x) = x^2\ngradient_descent <- function(x0, alpha, n_iter = 30) {\n x <- x0\n percorso <- numeric(n_iter)\n for (i in 1:n_iter) {\n percorso[i] <- x\n x <- x - alpha * 2 * x # theta_new = theta_old - alpha * grad\n }\n return(percorso)\n}\n\nx0 <- 8 # stesso punto di partenza per tutti\n\n# Tre learning rate diversi\nlento <- gradient_descent(x0, alpha = 0.01) # troppo piccolo\ngiusto <- gradient_descent(x0, alpha = 0.1) # buon compromesso\nveloce <- gradient_descent(x0, alpha = 0.9) # quasi instabile\n\n# Visualizzazione\npar(mfrow = c(1, 3))\n\n# alpha = 0.01 (troppo lento)\ncurve(x^2, from = -10, to = 10, lwd = 2, col = \"steelblue\",\n main = expression(paste(alpha, \" = 0.01 (troppo lento)\")))\npoints(lento, lento^2, col = \"red\", pch = 19, cex = 0.6)\nlines(lento, lento^2, col = \"red\", lty = 2)\n\n# alpha = 0.1 (giusto)\ncurve(x^2, from = -10, to = 10, lwd = 2, col = \"steelblue\",\n main = expression(paste(alpha, \" = 0.1 (buon compromesso)\")))\npoints(giusto, giusto^2, col = \"darkgreen\", pch = 19, cex = 0.6)\nlines(giusto, giusto^2, col = \"darkgreen\", lty = 2)\n\n# alpha = 0.9 (quasi instabile)\ncurve(x^2, from = -10, to = 10, lwd = 2, col = \"steelblue\",\n main = expression(paste(alpha, \" = 0.9 (quasi instabile)\")))\npoints(veloce, veloce^2, col = \"orange\", pch = 19, cex = 0.6)\nlines(veloce, veloce^2, col = \"orange\", lty = 2)\n\npar(mfrow = c(1, 1))<\/code><\/pre>\n\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef gradient_descent(x0, alpha, n_iter=30):\n x = x0\n percorso = np.zeros(n_iter)\n for i in range(n_iter):\n percorso[i] = x\n x = x - alpha * 2 * x # theta_new = theta_old - alpha * grad\n return percorso\n\nx0 = 8.0 # stesso punto di partenza per tutti\nlento = gradient_descent(x0, alpha=0.01) # troppo piccolo\ngiusto = gradient_descent(x0, alpha=0.1) # buon compromesso\nveloce = gradient_descent(x0, alpha=0.9) # quasi instabile\n\nfig, axes = plt.subplots(1, 3, figsize=(14, 4))\nxs = np.linspace(-10, 10, 200)\nfor ax, dati, colore, titolo in zip(axes,\n [lento, giusto, veloce],\n [\"red\", \"darkgreen\", \"orange\"],\n [\"\\u03b1 = 0.01 (troppo lento)\", \"\\u03b1 = 0.1 (buon compromesso)\",\n \"\\u03b1 = 0.9 (quasi instabile)\"]):\n ax.plot(xs, xs**2, lw=2, color=\"steelblue\")\n ax.plot(dati, dati**2, \"o--\", color=colore, markersize=4)\n ax.set_title(titolo)\nplt.tight_layout()\nplt.show()<\/code><\/pre>\n\n\n\nCosa pu\u00f2 andare storto: l’intuizione geometrica<\/h2>\n\n\n\n
![\"Tre](\"https:\/\/www.gironi.it\/blog\/wp-content\/uploads\/2026\/03\/slide-insidie-topografiche.jpg\")
<\/figure>\n\n\n\nMinimi locali: le valli secondarie<\/h3>\n\n\n\n
Punti di sella: la sella di cavallo<\/h3>\n\n\n\n
Valli strette: lo zigzag<\/h3>\n\n\n\n
Da una parabola a ChatGPT<\/h2>\n\n\n\n
La scala dei parametri<\/h3>\n\n\n\n
\n
Dove lo vedi in azione (senza saperlo)<\/h3>\n\n\n\n
\n
Le evoluzioni: scarpe migliori per il nostro esploratore<\/h2>\n\n\n\n
Stochastic Gradient Descent (SGD)<\/h3>\n\n\n\n
Momentum<\/h3>\n\n\n\n
Adam: il coltellino svizzero<\/h3>\n\n\n\n
Ritorno alla montagna<\/h2>\n\n\n\n