Deep Learning (DL)

Il deep learning (DL) è un ramo del machine learning (ML) che addestra reti neurali con molti livelli sovrapposti per apprendere direttamente da dati grezzi come pixel, forme d'onda audio e testo. «Deep» si riferisce proprio alla profondità: ogni livello trasforma l'output del precedente, così la rete costruisce autonomamente la propria gerarchia di caratteristiche, dai bordi alle texture fino agli oggetti interi in un'immagine, senza che gli ingegneri debbano progettare manualmente tali caratteristiche. Il deep learning alimenta la moderna computer vision, il riconoscimento vocale, i modelli linguistici di grandi dimensioni (LLM) e l'IA generativa.

Come funziona il deep learning#

Una rete neurale è una catena di livelli. Ogni livello moltiplica il proprio input per una matrice di pesi appresi, aggiunge un bias e passa il risultato attraverso una funzione di attivazione non lineare come ReLU. La non linearità rende utile la profondità: senza di essa, qualsiasi sequenza di livelli si riduce a un'unica trasformazione lineare.

L'addestramento regola i pesi affinché gli output della rete corrispondano alle etichette di addestramento. A ogni passaggio, un batch di dati attraversa la rete in avanti; una funzione di perdita valuta l'errore; la retropropagazione calcola quanto ogni peso ha contribuito all'errore; infine, un ottimizzatore come la discesa stocastica del gradiente (SGD) o Adam sposta leggermente ogni peso nella direzione che lo riduce. Ripetere il processo per molte epoche trasforma pesi casuali in caratteristiche utili. L'esempio PyTorch qui sotto addestra un singolo livello lineare e una rete a tre livelli su punti etichettati in base alla loro posizione interna o esterna a un cerchio:

import torch
from torch import nn

torch.manual_seed(0)

# Points inside a circle are class 1: no straight line separates the classes
x = torch.rand(1000, 2) * 2 - 1
y = (x.pow(2).sum(dim=1) < 0.5).float().unsqueeze(1)

# A single linear layer versus stacked layers with nonlinear activations
models = {
    "linear": nn.Linear(2, 1),
    "deep": nn.Sequential(nn.Linear(2, 16), nn.ReLU(), nn.Linear(16, 16), nn.ReLU(), nn.Linear(16, 1)),
}
for name, model in models.items():
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    for step in range(500):
        loss = nn.functional.binary_cross_entropy_with_logits(model(x), y)
        optimizer.zero_grad()
        loss.backward()  # backpropagation computes gradients for every layer
        optimizer.step()
    accuracy = ((model(x) > 0) == y).float().mean()
    print(f"{name}: {accuracy:.1%} accuracy")

Il modello lineare raggiunge il 60.8%, circa la quota di punti esterni al cerchio, perché un confine rettilineo non può racchiudere una regione. Il modello profondo raggiunge il 99.9%: i suoi livelli nascosti curvano il confine decisionale in base a una curva appresa dai dati. Ultralytics YOLO26 viene addestrato con lo stesso ciclo, ma su scala molto più ampia; model.train() esegue passaggi forward, calcolo della perdita e retropropagazione su immagini etichettate, usando una GPU quando disponibile.

Deep learning e machine learning#

Il deep learning è un sottoinsieme del machine learning e le due discipline differiscono soprattutto per la provenienza delle caratteristiche. Gli algoritmi classici, come gli alberi decisionali, le macchine a vettori di supporto e gli alberi potenziati con il gradiente, apprendono da caratteristiche definite dalle persone, come l'importo di una transazione o il conteggio di una parola. Le reti profonde apprendono autonomamente le caratteristiche, perciò dominano su dati non strutturati come immagini, audio e testo. Questa capacità ha un costo: i modelli profondi richiedono in genere molti più dati etichettati, vengono addestrati su GPU o altri acceleratori e rendono meno trasparente il proprio ragionamento. Sui dati tabellari, gli alberi potenziati con il gradiente come XGBoost restano concorrenti validi; l'apprendimento per trasferimento riduce il divario nei dati dei modelli profondi partendo da una rete preaddestrata su un dataset di grandi dimensioni.

Architetture principali#

• Reti neurali convoluzionali (CNN): fanno scorrere piccoli filtri appresi sull'immagine, riconoscendo lo stesso schema in qualsiasi punto del fotogramma. Le CNN sono alla base del rilevamento degli oggetti e della segmentazione delle immagini in tempo reale.
• Reti neurali ricorrenti (RNN): elaborano le sequenze un passaggio alla volta, mantenendo uno stato nascosto. Varianti come le LSTM hanno dominato il riconoscimento vocale e la traduzione prima dei Transformer.
• Transformer: usano l'autoattenzione per mettere in relazione ogni elemento di una sequenza con tutti gli altri, in parallelo. Introdotti nel 2017, alimentano gli LLM e i Vision Transformer (ViT).
• Modelli di diffusione: apprendono a rimuovere il rumore passo dopo passo, consentendo di generare immagini, video e audio a partire da rumore casuale.

Una breve storia#

Le idee alla base del deep learning risalgono a decenni fa. La retropropagazione è diventata popolare grazie a un articolo del 1986 di David Rumelhart, Geoffrey Hinton e Ronald Williams, ma le reti sono rimaste poco profonde finché non si sono affermati contemporaneamente tre fattori: grandi dataset etichettati come ImageNet, GPU abbastanza veloci da addestrarli e tecniche come le attivazioni ReLU e il dropout. Nel 2012, AlexNet ha ridotto il tasso di errore top-5 su ImageNet al 15,3%, contro il 26,2% del risultato successivo, e nel giro di una notte il settore si è orientato verso le reti profonde. Hinton, Yann LeCun e Yoshua Bengio hanno ricevuto il Turing Award nel 2018 per questo lavoro, mentre il Nobel per la fisica del 2024 è stato assegnato a Hinton e John Hopfield per le scoperte che rendono possibile il machine learning con reti neurali artificiali. La profondità delle reti è continuata ad aumentare: le connessioni residue hanno permesso a ResNet di addestrare reti con 152 livelli e un ensemble di queste reti ha vinto la sfida di classificazione ImageNet del 2015, con un tasso di errore top-5 del 3,57%.