ResNet 2015: residual learning, reti profonde addestrabili

Una rete a 56 layer fa peggio di una rete a 20 layer, sullo stesso dataset, con lo stesso ottimizzatore, allenata con la stessa cura. Non è overfitting, perché anche il train error sale. Non è vanishing gradient, perché batch normalization e Kaiming init lo hanno già mitigato. È un problema di ottimizzazione: addestrare reti molto profonde, di per sé, non funziona. Nel dicembre 2015 un quartetto di Microsoft Research Asia mostra che basta una skip connection — l’identità sommata all’output di un blocco — per spezzare la maledizione. La rete vincitrice di ILSVRC 2015 ha 152 layer. Top-5 error: 3.57%. La performance umana stimata dalla stessa comunità ImageNet era circa 5.1%.

Perché questo capitolo

Tre anni dopo AlexNet, la comunità di computer vision ha già capito una cosa: in un regime di dati e compute generosi, le reti più profonde tendono a generalizzare meglio. Il problema è che, oltre una certa profondità, le reti smettono di addestrarsi del tutto. ResNet rompe questo limite. Non lo fa con una rivoluzione concettuale — il meccanismo è una somma — ma con una mossa architetturale così semplice da sembrare banale, applicata con disciplina ingegneristica e validata su un benchmark che la comunità guardava ogni anno con attenzione. Il risultato è doppio: il record assoluto su ImageNet 2015 e un pattern architetturale che, dieci anni dopo, è ancora ovunque.

Per chi guarda il deep learning come pratica, il primo motivo per cui questo capitolo conta è che ResNet definisce il backbone visivo di default per tutto ciò che è venuto dopo: object detection (Faster R-CNN, RetinaNet, Mask R-CNN), segmentation (U-Net + ResNet encoder, DeepLab), face recognition, pose estimation, medical imaging. Per quasi un decennio, dire “convolutional backbone” significa dire “una qualche variante di ResNet”. Il secondo motivo è di portata maggiore: la skip connection di ResNet, generalizzata, diventa il residual stream dei transformer (Vaswani et al. 2017 cita esplicitamente He et al. 2016 per giustificare le residual connections nei propri blocchi). La filiazione tecnica è documentata, non è un’analogia: ogni LLM contemporaneo fa fluire informazione attraverso una pila di blocchi che aggiungono il proprio output a uno stream condiviso, esattamente come ResNet.

Il terzo motivo è metodologico. ResNet è un caso paradigmatico di un pattern ricorrente nella ricerca empirica: una difficoltà visibile, attribuita per anni a una causa (vanishing gradient), viene riformulata in termini diversi (problema di ottimizzazione), e la riformulazione apre una soluzione che con la causa originale non c’entrava. Il punto non è che il vanishing gradient non fosse un problema — lo era, e batch normalization lo aveva mitigato — ma che, una volta mitigato, restava un altro problema sotto, che richiedeva una mossa diversa. Distinguere problemi sovrapposti, rimuoverli uno per volta, vedere cosa resta: è la trama del progresso del deep learning negli anni 2014-2018, e ResNet ne è l’episodio chiave.

Contesto

La storia comincia con imagenet-alexnet-2012, dove abbiamo visto la convergenza di tre forze (ImageNet, GPU, cocktail algoritmico) che rende possibile l’esplosione del deep learning in vision. Da AlexNet 2012 in poi, ogni anno la competizione ILSVRC viene vinta da una rete neurale, e ogni anno la rete vincitrice è più profonda di quella precedente. La traiettoria è netta:

• AlexNet 2012, 8 layer, top-5 error 15.3% (Krizhevsky-Sutskever-Hinton, Toronto).
• ZFNet 2013, 8 layer con tuning architetturale, top-5 error 11.7% (Matthew Zeiler e Rob Fergus, NYU).
• VGG 2014, 16 e 19 layer, top-5 error 7.3% per il single model migliore (Karen Simonyan e Andrew Zisserman, Visual Geometry Group dell’Università di Oxford). Paper “Very Deep Convolutional Networks for Large-Scale Image Recognition”, ICLR 2015.
• GoogLeNet 2014, 22 layer organizzati in moduli “Inception” che eseguono in parallelo convoluzioni con kernel di taglie diverse, top-5 error 6.67% (Christian Szegedy e collaboratori a Google Research). Paper “Going Deeper with Convolutions”, CVPR 2015.

Il pattern è chiaro: più layer, più accuratezza. La domanda che la comunità si pone alla fine del 2014 è naturale: si può continuare? Cosa succede a 50 layer? A 100? A 200?

Tra il 2014 e il 2015, due risultati intermedi cambiano il contesto in cui ResNet nascerà.

Primo: batch normalization. Sergey Ioffe e Christian Szegedy, a Google Research, pubblicano nel febbraio 2015 “Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift” (ICML 2015, arXiv:1502.03167). L’idea è normalizzare le attivazioni di ogni layer su mini-batch durante il training, in modo che la distribuzione dei loro input non vari drammaticamente a ogni step di SGD. Pratica apparentemente semplice, effetto enorme: BN consente learning rate più alti, riduce la sensibilità all’inizializzazione dei pesi e mitiga in modo significativo il vanishing gradient. Dopo BN, addestrare una rete a 30-40 layer non è più impossibile. Diventa, in molti casi, possibile.

Secondo: Kaiming initialization. Lo stesso Kaiming He, con Xiangyu Zhang, Shaoqing Ren e Jian Sun, pubblica all’ICCV 2015 “Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification” (arXiv:1502.01852). Il paper introduce uno schema di inizializzazione dei pesi pensato per reti con attivazioni ReLU, che corregge il difetto dell’inizializzazione Xavier (Glorot-Bengio 2010) quando applicata a non-linearità non simmetriche. Kaiming init non risolve il vanishing gradient ma lo posticipa di molti layer, rendendo praticamente addestrabili reti profonde fino a circa 30 layer dove Xavier falliva.

Con BN e Kaiming init disponibili, nel 2015 un dottorando attento può addestrare una rete a 30 layer senza grandi drammi. Provare a 50 layer è un esperimento naturale. Il primo a farlo in modo sistematico è il gruppo di Microsoft Research Asia a Pechino, dove Kaiming He, Xiangyu Zhang, Shaoqing Ren e Jian Sun stanno lavorando sotto la direzione dello stesso Sun, all’epoca capo del Visual Computing Group. Il risultato dell’esperimento è inatteso: una rete plain a 56 layer, addestrata con tutte le accortezze del momento (BN, Kaiming init, SGD con momentum, learning rate scheduling), produce un train error e un test error peggiori di una rete plain a 20 layer sullo stesso CIFAR-10. Non è overfitting (anche il train sale). Non è vanishing gradient (BN lo ha tolto di mezzo). È un’altra cosa.

A parallelo, c’è un terzo lavoro che entra nel contesto: Highway Networks. Rupesh Kumar Srivastava, Klaus Greff e Jürgen Schmidhuber (allora all’IDSIA, l’istituto di intelligenza artificiale del Ticino fondato da Schmidhuber stesso) pubblicano nel maggio 2015 “Highway Networks” (arXiv:1505.00387, poi ICML 2015 workshop e NIPS 2015 estensione). L’idea: aggiungere a ogni layer una gate apprendibile che decide quanto del segnale “salta” il layer e quanto invece lo attraversa. Formalmente, l’output di un Highway block è $y = T(x) \cdot H(x) + (1 - T(x)) \cdot x$, dove $T(x)$ è una funzione gate apprendibile (tipicamente una sigmoid) e $H(x)$ è la trasformazione del layer. Quando $T(x) \approx 0$, il layer è bypassato e il segnale passa identico. Quando $T(x) \approx 1$, il layer agisce in pieno. Il paper Highway dimostra che reti fino a 100 layer si addestrano in modo stabile, qualcosa che plain network non riuscivano a fare.

Highway Networks è un predecessore concettuale diretto di ResNet, ed è sul tavolo nei mesi in cui He e colleghi sviluppano la propria idea. Schmidhuber, negli anni successivi, rivendicherà una priorità parziale, sottolineando che Highway è uscito sette mesi prima e introduce per primo il concetto di skip connection differenziabile in reti molto profonde. La distinzione tecnica resta importante: Highway usa gates apprese (la rete decide quanto bypassare); ResNet rimuove le gates e fissa la skip all’identità. La semplificazione di ResNet — niente gates, solo somma — si rivelerà più stabile, più facile da addestrare e altrettanto efficace, e diventerà lo standard. Le due idee sono parenti, non identiche.

Figura in preparazione

Pre-ResNet timeline 2012-2015. Horizontal axis with markers and brief annotations: AlexNet (Sept 2012, 8 layers, 15.3% top-5), ZFNet (2013, 8 layers, 11.7%), VGG (Sept 2014, 16-19 layers, 7.3%), GoogLeNet (Sept 2014, 22 layers, 6.67%), Batch Normalization (Feb 2015, Ioffe-Szegedy), Kaiming init (Feb 2015, He et al.), Highway Networks (May 2015, Srivastava-Greff-Schmidhuber), ResNet (Dec 2015, He-Zhang-Ren-Sun, 152 layers, 3.57% top-5). Above the line: red horizontal band representing “trainable depth ceiling” rising from ~10 to ~30 to ~150. Clean editorial style, English labels

I quattro autori di ResNet meritano un ritratto rapido. Kaiming He (informatico cinese, 1984-) era allora researcher a Microsoft Research Asia, dove era arrivato dopo il PhD alla Chinese University of Hong Kong. Aveva già vinto il Marr Prize (premio per il best paper a ICCV) nel 2009 per un lavoro su image dehazing. Dopo ResNet, lascerà MSRA nel 2016 per Facebook AI Research (FAIR), dove lavorerà su Mask R-CNN, RetinaNet, MoCo, MAE; nel 2024 si trasferirà al MIT come professore. È uno degli autori più citati dell’AI moderna, con un secondo Marr Prize ricevuto nel 2017 proprio per il paper ResNet. Xiangyu Zhang (informatico cinese), allora dottorando associato a MSRA in collaborazione con Xi’an Jiaotong University, dopo il 2016 cofonderà il gruppo di ricerca di Megvii (azienda cinese di computer vision specializzata in face recognition). Shaoqing Ren (informatico cinese), anche lui giovane researcher MSRA, è co-autore con He di Faster R-CNN; passerà successivamente a USTC. Jian Sun (informatico cinese, 1976-2022) era il direttore del Visual Computing Group di MSRA, mentore della generazione che ha prodotto ResNet, Faster R-CNN e diverse altre architetture seminali. Lascerà MSRA nel 2016 per diventare chief scientist di Megvii, dove influenzerà in profondità la ricerca industriale cinese di vision. Muore prematuramente nel giugno 2022, a 46 anni. Il paper ResNet è il loro lavoro più visibile insieme.

MSRA, fondato da Microsoft a Pechino nel 1998, è negli anni 2010 uno dei laboratori industriali più produttivi del mondo in computer vision e speech. Da MSRA escono in questo decennio lavori che plasmano l’intero campo: ResNet, Faster R-CNN, deep learning per speech recognition (Microsoft è uno dei tre laboratori che producono i primi sistemi DNN-HMM nel 2010-2012). Il ruolo di MSRA come ponte tra accademia cinese e industria globale è una parte non scritta della storia del deep learning moderno.

L’intuizione

Angolo del paradosso: imparare l’identità è difficile

Il primo angolo per capire ResNet parte dal paradosso del peggioramento con la profondità. Mettiamo da parte per un attimo l’architettura specifica e ragioniamo astrattamente. Supponiamo di avere una rete plain a 20 layer che raggiunge un certo errore di training, diciamo 8%. Costruiamo ora una rete plain a 56 layer aggiungendo 36 layer in cima alla rete a 20. Per costruzione, esiste una soluzione plausibile per la rete a 56 layer che riproduce esattamente la rete a 20: i primi 20 layer fanno quello che facevano nella rete corta, e gli ultimi 36 layer realizzano la funzione identità ($y = x$). Se la rete a 56 layer apprendesse questa configurazione, avrebbe esattamente lo stesso errore della rete a 20: 8%.

Empiricamente, la rete a 56 layer non lo fa. Raggiunge un errore peggiore, diciamo 11%. Questo è il fatto sorprendente. Non è una limitazione di rappresentazione: la soluzione “rete a 20 + 36 identità” è esprimibile in modo banale dai parametri. È una limitazione di ottimizzazione: l’algoritmo SGD non riesce a trovare quella soluzione, neanche dopo molte epoche. Il problema, allora, non è cosa la rete profonda può rappresentare, ma cosa SGD riesce a far emergere durante il training.

He e colleghi rileggono questa osservazione e fanno un passo che, in retrospettiva, sembra ovvio. Se il problema è che SGD fatica ad apprendere l’identità nei layer aggiuntivi, costruiamo l’architettura in modo che l’identità sia il default. Anziché chiedere a un blocco di apprendere una mappa generica $H(x)$, gli chiediamo di apprendere il residuo rispetto all’identità:

$F(x) = H(x) - x$

L’output del blocco diventa allora:

$H(x) = F(x) + x$

In codice, questo significa: prendi l’input $x$, fallo passare attraverso due o tre layer convoluzionali (che producono $F(x)$), e poi somma $x$ all’output. La somma è la skip connection. La trasformazione che la rete deve apprendere — $F$ — è ora il residuo, non la mappa completa.

Il vantaggio è asimmetrico ma cruciale. Se la mappa “giusta” per quel blocco è l’identità, basta che $F$ tenda a zero: i pesi convoluzionali devono solo essere piccoli. Annullare i pesi è facile per SGD (la regolarizzazione $L_2$ li spinge naturalmente verso zero). Imparare attivamente l’identità in una rete plain è invece molto più difficile, perché richiede una combinazione non banale di pesi convoluzionali per ricostruire $y = x$.

In parole povere, ResNet rimuove l’attrito del caso degenere. Se un layer non serve, basta che faccia poco, e l’identità del passaggio è garantita dalla skip. La rete profonda, nel peggiore dei casi, può “comportarsi come una rete più corta” senza sforzo. Nel migliore dei casi, i blocchi residuali aggiungono raffinamenti progressivi alla rappresentazione dello stream. Questo è il meccanismo concettuale.

Angolo del gradient flow: autostrade per i gradienti

Il secondo angolo è quello del gradient flow durante backpropagation. In una rete plain profonda, il gradiente della loss rispetto a un parametro di un layer iniziale è il prodotto di molte derivate parziali in catena: la chain rule fa scorrere il gradiente attraverso tutti i layer intermedi, e ogni passaggio lo moltiplica per una matrice jacobiana. Se queste jacobiane hanno autovalori sistematicamente piccoli, il gradiente decresce esponenzialmente con la profondità (vanishing gradient); se sono sistematicamente grandi, esplode. Batch normalization mitiga in parte il problema mantenendo le attivazioni in un range stabile, ma non lo elimina.

In una rete residuale, la struttura $y = F(x) + x$ cambia il calcolo. La derivata di $y$ rispetto a $x$ è:

$\frac{\partial y}{\partial x} = \frac{\partial F(x)}{\partial x} + I$

dove $I$ è la matrice identità. Quando si applica la chain rule attraverso una pila di blocchi residuali, in ogni passaggio compare questo termine $+I$ accanto al jacobiano del residuo. Il gradiente, riscritto in modo equivalente, ha una componente che fluisce direttamente dall’output verso l’input lungo la “scorciatoia” delle skip connections, indipendentemente da quanto piccoli siano i jacobiani dei blocchi residuali. In termini operativi, anche se ogni $\frac{\partial F}{\partial x}$ è piccolo, il termine identità garantisce che il gradiente che arriva ai layer iniziali non vada a zero.

L’analogia spesso usata: le skip connections sono autostrade per il gradiente. I blocchi residuali sono uscite e ingressi su quelle autostrade. Se uno dei blocchi è “intasato” (jacobiano piccolo), il gradiente prosegue lungo l’autostrada principale. Solo quando tutti i blocchi sono problemi, l’autostrada smette di essere utile — ma nella pratica, con BN e inizializzazione adeguata, i blocchi non collassano tutti contemporaneamente.

Marcatura di classe: questa decomposizione è una descrizione matematica, non un’analogia metaforica. Il termine $+I$ nel jacobiano della funzione residuale è esattamente quello, e l’effetto sul gradient flow è dimostrabile sia analiticamente sia empiricamente (i gradienti misurati nei layer iniziali di ResNet hanno norme stabili anche a profondità 100+, mentre nelle equivalenti reti plain decadono visibilmente). Questo angolo è quello che il paper “Identity Mappings in Deep Residual Networks” (He et al. ECCV 2016) formalizza in dettaglio.

Figura in preparazione

Two intuitions side by side. Left panel “The identity is hard to learn”: a plain block with 3 stacked conv layers transforming x into H(x), with caption below “to leave x unchanged, the network must actively learn an identity through nonlinear weights — hard for SGD”. Right panel “Residual block makes identity easy”: same 3 conv layers producing F(x), with a curved arrow from input x bypassing them and meeting an addition node, output H(x) = F(x) + x, caption “to leave x unchanged, F just needs to be near zero — easy for SGD with weight decay”. Clean editorial style, English labels

La meccanica

Il problema empirico: figura 1 del paper

La sezione 4.1 del paper ResNet apre con un grafico che è entrato nella memoria della comunità. Su CIFAR-10, gli autori addestrano due reti plain identiche per costruzione tranne che per la profondità: una a 20 layer e una a 56 layer. Stesso optimizer, stessa learning rate schedule, stessa inizializzazione, stesso BN, stessa data augmentation. La curva di training error in funzione delle epoche mostra che la rete a 56 layer si stabilizza su un train error più alto della rete a 20. La curva di test error segue lo stesso pattern.

Questo grafico è la base empirica dell’intero paper. Il messaggio è netto: il problema non è la regolarizzazione o la generalizzazione (in tal caso il train error sarebbe sceso e solo il test sarebbe rimasto alto). Il problema è l’addestramento stesso. La rete profonda non riesce a raggiungere il regime di errore della rete corta.

Gli autori ripetono lo stesso esperimento sostituendo il blocco plain con il blocco residuale, e ottengono il pattern atteso: ResNet-20 e ResNet-56 si addestrano entrambe correttamente, e ResNet-56 raggiunge un errore inferiore a ResNet-20. La curva è “dritta”: più profondo = meglio, come dovrebbe essere se la teoria delle reti profonde funziona.

Figura in preparazione

Plain vs Residual training curves recreation. Two side-by-side plots. Left plot “Plain networks”: x-axis epochs (0 to 60k iterations), y-axis training error %. Two curves: plain-20 (lower, settles around 7%), plain-56 (higher, settles around 11%). Caption “deeper plain network is worse”. Right plot “Residual networks”: same axes. Two curves: ResNet-20 (settles around 8%), ResNet-56 (settles around 6%). Caption “deeper residual network is better”. Clean editorial style, English labels, CIFAR-10 dataset note

Il blocco residuale base

Per le ResNet di profondità modesta (ResNet-18 e ResNet-34), il blocco residuale è semplice. Due layer convoluzionali con kernel 3x3, ciascuno seguito da batch normalization e ReLU. La skip connection somma l’input direttamente all’output del secondo BN, e una ReLU finale è applicata dopo la somma. In pseudocodice:

def basic_block(x, filters):
    identity = x
    out = conv3x3(x, filters)
    out = batch_norm(out)
    out = relu(out)
    out = conv3x3(out, filters)
    out = batch_norm(out)
    out = out + identity   # skip connection
    out = relu(out)
    return out

Quando il numero di canali del blocco cambia rispetto all’input (per esempio, all’inizio di una nuova “stage” della rete dove i canali raddoppiano), la skip connection non può sommare direttamente: input e output hanno dimensioni diverse. In quel caso si usa una projection shortcut, una convoluzione 1x1 che mappa l’input alle dimensioni dell’output:

def basic_block_with_projection(x, in_filters, out_filters, stride):
    if in_filters != out_filters or stride != 1:
        identity = conv1x1(x, out_filters, stride)
        identity = batch_norm(identity)
    else:
        identity = x
    out = conv3x3(x, out_filters, stride)
    out = batch_norm(out)
    out = relu(out)
    out = conv3x3(out, out_filters)
    out = batch_norm(out)
    out = out + identity
    out = relu(out)
    return out

Il paper discute tre opzioni per la shortcut quando le dimensioni differiscono: (A) zero-padding (mantiene la skip senza parametri ma copre solo casi semplici), (B) projection solo quando le dimensioni cambiano, (C) projection sempre. L’opzione B è il default e dà il miglior compromesso tra accuratezza e parametri.

Il blocco bottleneck

Per ResNet più profonde (50, 101, 152 layer), un blocco a due conv 3x3 sarebbe troppo costoso in parametri e flops. Il paper introduce il bottleneck block, una struttura a tre layer:

1. Una conv 1x1 che riduce il numero di canali (es. da 256 a 64). È il “bottleneck”: comprime la rappresentazione.
2. Una conv 3x3 sui canali ridotti. Fa la maggior parte del lavoro spaziale.
3. Una conv 1x1 che riespande i canali (es. da 64 a 256). Restituisce la dimensione originale.
4. La skip connection somma l’input direttamente all’output del terzo layer (o tramite projection se le dimensioni differiscono).

In pseudocodice:

def bottleneck_block(x, mid_filters, out_filters):
    identity = x
    out = conv1x1(x, mid_filters)        # comprime
    out = batch_norm(out); out = relu(out)
    out = conv3x3(out, mid_filters)      # lavora
    out = batch_norm(out); out = relu(out)
    out = conv1x1(out, out_filters)      # riespande
    out = batch_norm(out)
    out = out + identity                 # skip
    out = relu(out)
    return out

Il vantaggio è quantitativo. Un blocco basic con due conv 3x3 a 256 canali ha circa $2 \times 3 \times 3 \times 256 \times 256 \approx 1.18$ milioni di parametri. Un bottleneck con conv 1x1 (256→64), conv 3x3 (64→64), conv 1x1 (64→256) ha $256 \times 64 + 3 \times 3 \times 64 \times 64 + 64 \times 256 \approx 70000$ parametri. Riduzione di un ordine di grandezza, a parità di canali in input/output. Questo permette di costruire reti molto profonde senza esplodere in parametri.

Figura in preparazione

Basic block vs bottleneck block side by side. Left “Basic block (ResNet-18, 34)”: vertical stack of boxes from input x: conv 3x3 64ch, BN, ReLU, conv 3x3 64ch, BN. Curved skip arrow from x to addition node. Output y. Right “Bottleneck block (ResNet-50, 101, 152)”: vertical stack from input x: conv 1x1 64ch (compress from 256), BN, ReLU, conv 3x3 64ch, BN, ReLU, conv 1x1 256ch (expand), BN. Curved skip arrow from x to addition node. Output y. Annotations on dimensions and parameter counts. Clean editorial style, English labels

Le architetture

Il paper propone cinque varianti standard, tutte con la stessa “scaffolding” generale: una conv iniziale 7x7 con stride 2, un max-pool 3x3 con stride 2, quattro stages ciascuno con un certo numero di blocchi residuali (la dimensione dei feature map dimezza tra uno stage e il successivo, mentre il numero di canali raddoppia), e in cima una global average pooling seguita da un layer fully-connected per le 1000 classi di ImageNet.

Variante	Blocchi per stage	Tipo blocco	Layer totali	Parametri	Flops (per immagine)
ResNet-18	2-2-2-2	basic	18	11.7 M	1.8 GFLOPs
ResNet-34	3-4-6-3	basic	34	21.8 M	3.6 GFLOPs
ResNet-50	3-4-6-3	bottleneck	50	25.6 M	4.1 GFLOPs
ResNet-101	3-4-23-3	bottleneck	101	44.5 M	7.6 GFLOPs
ResNet-152	3-8-36-3	bottleneck	152	60.2 M	11.3 GFLOPs

Per confronto: VGG-19 ha circa 144 milioni di parametri e 19.6 GFLOPs per immagine. ResNet-152 è più profonda e meno costosa di VGG-19, grazie ai bottleneck.

Il “152” del nome conta i layer parametrici (convoluzionali e fully-connected): 1 conv iniziale, 50 blocchi bottleneck a tre conv ciascuno (= 150), 1 fully-connected finale. Totale 152.

Risultati ILSVRC 2015

I numeri del paper sono diventati canonici. Sul validation set di ImageNet:

• ResNet-50 single model: 5.25% top-5 error (10-crop testing).
• ResNet-101 single model: 4.60% top-5 error.
• ResNet-152 single model: 4.49% top-5 error.
• Ensemble di 6 modelli ResNet (di varie profondità): 3.57% top-5 error.

Per contestualizzare: il vincitore ILSVRC 2014 (GoogLeNet) era a 6.67% top-5. Il miglioramento single-model di ResNet-152 (4.49%) rispetto a GoogLeNet è di oltre 2 punti, in un regime dove il margine annuale era tipicamente di 1-2 punti. L’ensemble a 3.57% scende sotto la soglia di performance umana stimata sullo stesso task (~5.1%), come misurato da Olga Russakovsky e collaboratori in “ImageNet Large Scale Visual Recognition Challenge” (IJCV 2015), dove un annotatore umano ben addestrato ottiene errori in quel range.

ResNet vince ILSVRC 2015 in tutti e cinque i task della competizione: classification, localization, detection, ImageNet detection, ImageNet localization. Vince anche COCO 2015 (Common Objects in Context, il benchmark di Microsoft per object detection e segmentation) con margine ampio sui secondi classificati. Il dominio è netto e trasversale.

Il paper è accettato a CVPR 2016 e riceve il Best Paper Award. È, al momento di scrittura di questa wiki, uno dei paper più citati di tutta l’AI (oltre 200000 citazioni stimate da Google Scholar nel 2024), in coda solo a una manciata di lavori storici.

Figura in preparazione

ImageNet error timeline 2010-2017. Horizontal axis years 2010-2017, vertical axis top-5 error %. Bars or markers at each year with annotation: 2010 NEC-UIUC 28.2% (SIFT+SVM), 2011 Xerox 25.8% (SIFT+Fisher Vectors+SVM), 2012 AlexNet 16.4% (8 layers, first CNN winner), 2013 ZFNet 11.7% (8 layers), 2014 VGG 7.3% / GoogLeNet 6.67% (16-22 layers), 2015 ResNet ensemble 3.57% (152 layers), 2016 trimps-soushen 2.99%, 2017 SENet 2.25%. Horizontal dashed line at 5.1% labeled “estimated human top-5 error (Russakovsky et al.)”. Color coding: pre-CNN era one color, CNN era another. Clean editorial style, English labels

Identity Mappings in Deep Residual Networks (2016)

Il follow-up di He, Zhang, Ren e Sun pubblicato a ECCV 2016 (“Identity Mappings in Deep Residual Networks”, arXiv:1603.05027) raffina il blocco residuale. La modifica principale è spostare batch normalization e ReLU prima delle conv invece che dopo, una variante chiamata pre-activation:

def preact_bottleneck(x, mid_filters, out_filters):
    identity = x
    out = batch_norm(x); out = relu(out)
    out = conv1x1(out, mid_filters)
    out = batch_norm(out); out = relu(out)
    out = conv3x3(out, mid_filters)
    out = batch_norm(out); out = relu(out)
    out = conv1x1(out, out_filters)
    return out + identity

Il vantaggio teorico: la skip connection ora è una pura identità dall’input all’output (nessuna ReLU finale a deformarla), e questo rende il gradient flow ancora più pulito. Il vantaggio pratico: il paper mostra che con pre-activation si possono addestrare reti fino a 1001 layer su CIFAR-10 senza divergere, e che pre-act ResNet-152 ottiene un piccolo ma consistente miglioramento su ImageNet rispetto al post-activation originale.

Il dato dei 1001 layer è quello che ha colpito l’immaginario. Empiricamente, il vantaggio di andare oltre 152 layer su ImageNet è marginale o nullo: la rete impara, ma non impara meglio. Il dato dimostra però la proprietà di addestrabilità del blocco residuale identity: la profondità non è più un limite tecnico, è un limite di rendimento marginale.

Esempi

Esempio 1: pseudocodice di una ResNet-50 completa

def resnet50(input_image, num_classes=1000):
    # Stem: conv iniziale 7x7 stride 2, poi max-pool
    x = conv7x7(input_image, 64, stride=2)
    x = batch_norm(x); x = relu(x)
    x = max_pool3x3(x, stride=2)

    # Stage 1: 3 bottleneck blocks, 64 channels
    x = bottleneck_block(x, mid=64, out=256, project=True)
    for _ in range(2):
        x = bottleneck_block(x, mid=64, out=256)

    # Stage 2: 4 bottleneck blocks, 128 channels, downsample
    x = bottleneck_block(x, mid=128, out=512, project=True, stride=2)
    for _ in range(3):
        x = bottleneck_block(x, mid=128, out=512)

    # Stage 3: 6 bottleneck blocks, 256 channels, downsample
    x = bottleneck_block(x, mid=256, out=1024, project=True, stride=2)
    for _ in range(5):
        x = bottleneck_block(x, mid=256, out=1024)

    # Stage 4: 3 bottleneck blocks, 512 channels, downsample
    x = bottleneck_block(x, mid=512, out=2048, project=True, stride=2)
    for _ in range(2):
        x = bottleneck_block(x, mid=512, out=2048)

    # Head: global average pooling + fully connected
    x = global_avg_pool(x)
    logits = fully_connected(x, num_classes)
    return logits

L’intera architettura entra in poche decine di righe. Questa compattezza è parte di ciò che ha reso ResNet immediatamente adottabile: reimplementarla in PyTorch o TensorFlow è il lavoro di un pomeriggio per uno studente. Il paper non richiede tecniche esotiche di training: SGD con momentum 0.9, weight decay 0.0001, learning rate iniziale 0.1 con riduzione a 0.01 e 0.001 quando il loss si stabilizza, batch size 256. Tutto standard.

Esempio 2: il paradosso del peggioramento, in numeri

Per dare concretezza al paradosso, immaginiamo i numeri ipotetici di un esperimento CIFAR-10 (ordine di grandezza coerente col paper):

Architettura	Layer	Train error	Test error
Plain-20	20	6.8%	8.9%
Plain-32	32	7.5%	9.5%
Plain-44	44	8.3%	10.4%
Plain-56	56	9.0%	11.0%
ResNet-20	20	6.7%	8.8%
ResNet-32	32	5.8%	7.5%
ResNet-44	44	5.3%	7.2%
ResNet-56	56	4.8%	6.9%
ResNet-110	110	4.0%	6.4%

Due colonne, due dinamiche opposte. Plain peggiora monotonicamente con la profondità: train error sale, test error sale. ResNet migliora: train error scende, test error scende. La differenza è il blocco residuale. La causa scartata: non è overfitting (train error scende anche per le ResNet più profonde, e per le plain sale insieme al test). La causa identificata: ottimizzazione, mitigata dalla skip.

Esempio 3: gradient flow, decomposizione formale

Consideriamo una pila di tre blocchi residuali. Indichiamo con $x_0$ l’input alla pila, e con $x_1, x_2, x_3$ gli output dei tre blocchi:

$x_1 = F_1(x_0) + x_0$ $x_2 = F_2(x_1) + x_1$ $x_3 = F_3(x_2) + x_2$

Sostituendo in cascata, possiamo riscrivere $x_3$ in funzione di $x_0$:

$x_3 = x_0 + F_1(x_0) + F_2(x_1) + F_3(x_2)$

Cioè l’output finale è la somma dell’input originale e di tutti i contributi residuali calcolati lungo il percorso. Questa è la forma additiva che giustifica il nome “residual stream”: $x_0$ scorre lungo la pila, e ogni blocco aggiunge un termine.

Calcoliamo ora la derivata della loss $L$ rispetto a $x_0$ tramite chain rule:

$\frac{\partial L}{\partial x_0} = \frac{\partial L}{\partial x_3} \cdot \frac{\partial x_3}{\partial x_0}$

Espandendo la seconda derivata usando la forma additiva:

$\frac{\partial x_3}{\partial x_0} = I + \frac{\partial F_1(x_0)}{\partial x_0} + \frac{\partial F_2(x_1)}{\partial x_0} + \frac{\partial F_3(x_2)}{\partial x_0}$

dove $I$ è la matrice identità. Il termine $I$ garantisce un flusso minimo di gradiente da $x_3$ a $x_0$: anche se tutti gli altri jacobiani sono piccoli o vicini a zero, il gradiente non si annulla. Questa proprietà non vale per le reti plain, dove la chain rule produce solo un prodotto di jacobiani senza termine identità: se uno qualsiasi è piccolo, il gradiente collassa.

Il paper “Identity Mappings” formalizza questa proprietà e mostra che, con pre-activation, la skip connection è esattamente identità (nessuna deformazione da BN/ReLU finale), e il termine $I$ è preservato letteralmente, non solo come approssimazione.

Esempio 4: ResNet come backbone per object detection

Un caso d’uso concreto è Faster R-CNN, l’architettura per object detection di Ren-He-Girshick-Sun (NIPS 2015). Faster R-CNN usa una rete pre-addestrata per estrarre feature dell’immagine, sopra cui costruisce una Region Proposal Network e un classificatore per box. Quando il backbone è VGG-16, l’accuracy mAP su PASCAL VOC è ~73%. Sostituendo VGG-16 con ResNet-101 (stesso codice di Faster R-CNN, solo backbone cambiato), l’accuracy sale a ~85% mAP. Sostituendo con ResNet-152, sale ulteriormente.

Il pattern è generale: per quasi ogni task di vision dell’epoca (detection, segmentation, pose estimation), sostituire VGG con ResNet produce un guadagno di diversi punti percentuali “gratis”, senza modifiche al codice di task-specifico. Questa sostituibilità è una proprietà che ResNet ha ereditato da VGG (entrambe forniscono feature gerarchiche multi-scala) e ha amplificato (più profonde, meno parametri, gradienti più stabili). È la ragione operativa per cui ResNet diventa il backbone universale negli anni 2016-2020.

Figura in preparazione

Architecture comparison aligned vertically. Three columns side by side, all aligned at the input on top: VGG-19 (left, 19 sequential conv blocks, no skips), GoogLeNet (middle, 22 layers organized in Inception modules with parallel branches), ResNet-152 (right, 152 layers as stacked bottleneck blocks with skip connections drawn as curved arrows for first few then continued with vertical dots). Same horizontal scale so depth differences are visible. Bottom of each column: parameter count and GFLOPs. Caption “from sequential plain networks to skip-connected residual stream”. Clean editorial style, English labels

Eredità oggi

[DATATO 2026-04]

Filiazione documentata in computer vision

Negli anni 2016-2020 ResNet diventa il backbone visivo di default e genera una serie di varianti che si possono considerare sue dirette discendenti. Wide ResNet (Sergey Zagoruyko e Nikos Komodakis, BMVC 2016) mostra che reti meno profonde ma più larghe (più canali per layer) ottengono prestazioni simili o superiori a parità di parametri, suggerendo che la profondità estrema non è la sola leva utile. DenseNet (Gao Huang, Zhuang Liu, Laurens van der Maaten, Kilian Weinberger, Best Paper CVPR 2017) generalizza la skip connection: ogni layer riceve come input la concatenazione degli output di tutti i layer precedenti. È una variante della stessa intuizione (preservare l’accesso ai segnali iniziali) realizzata con concat invece che somma. ResNeXt (Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, Kaiming He, CVPR 2017) introduce la cardinalità: ogni bottleneck block è un’aggregazione di trasformazioni parallele, simile in spirito agli Inception modules di GoogLeNet ma uniforme. SE-ResNet (Hu, Shen, Sun, CVPR 2018, vincitore ILSVRC 2017 con 2.25% top-5) aggiunge meccanismi di squeeze-and-excitation per riscalare adattivamente i canali. Tutte queste sono filiazioni dirette: ognuna parte da ResNet, ne modifica un aspetto, conserva la struttura residuale.

Nel periodo 2020-2022 il paradigma CNN viene sfidato da Vision Transformer (Dosovitskiy et al. ICLR 2021, “An Image is Worth 16x16 Words”). ViT abbandona convoluzioni e skip residuali a favore di patch + transformer. I primi ViT performano peggio di ResNet su dataset di taglia ImageNet, ma scalano meglio su dataset più grandi (JFT-300M). La risposta della linea CNN è ConvNeXt (Zhuang Liu, Hanzi Mao, Chao-Yuan Wu, Christoph Feichtenhofer, Trevor Darrell, Saining Xie, CVPR 2022), che rivisita ResNet con tecniche prese in prestito dai transformer (kernel più grandi, layer norm invece di batch norm, GELU invece di ReLU, fewer activations) e dimostra che una CNN modernizzata resta competitiva con ViT a parità di parametri. Anche ConvNeXt mantiene la struttura residuale di ResNet: le skip connections sono cuore inalienabile.

Filiazione concettuale verso i transformer

Il legame con i transformer è una filiazione tecnica documentata, non un’analogia. Il paper “Attention Is All You Need” di Vaswani et al. (NIPS 2017) cita esplicitamente He et al. 2016 per giustificare l’uso di residual connections nei propri encoder e decoder block. Ogni transformer block ha la struttura:

$x' = x + \text{Attention}(\text{LayerNorm}(x))$ $x'' = x' + \text{FFN}(\text{LayerNorm}(x'))$

L’input fluisce in uno stream lungo la pila di blocchi, e ogni blocco aggiunge il proprio output residuale. Questa è precisamente la stessa struttura di ResNet, con le differenze che (i) le sotto-rete residuali sono attention e feed-forward invece di convoluzioni, e (ii) la normalizzazione è LayerNorm o RMSNorm invece di BatchNorm, e tipicamente è applicata “pre” invece di “post” (eredità della pre-activation di He 2016). Il concetto di residual stream che si studierà in residual-stream (in preparazione) (in preparazione, Parte IX) è la formalizzazione di questa intuizione: lo stream è il vettore che scorre lungo la pila, e i blocchi sono operazioni di aggiornamento additivo. Ogni LLM moderno — GPT, Claude, Llama, Gemini — eredita questa struttura.

In altri ambiti: U-Net (Ronneberger-Fischer-Brox, MICCAI 2015), l’architettura di riferimento per segmentation di immagini biomediche, usa skip connections tra encoder e decoder che sono parenti concettuali (più che dirette) delle skip ResNet. Diffusion models (DDPM 2020 e successori) usano U-Net residuali come backbone di denoising. Speech models moderni come Whisper usano transformer residuali per encoding e decoding. Il pattern “stream centrale + blocchi che aggiungono” è uno dei pochi davvero universali nel deep learning post-2015.

Il contributo specifico di ResNet, in retrospettiva

A dieci anni di distanza, è possibile separare ciò che ResNet ha effettivamente contribuito da ciò che si attribuisce erroneamente a essa. ResNet ha contribuito:

1. La dimostrazione empirica che una skip connection identity, senza gates, è sufficiente a rendere addestrabili reti profonde fino a 150+ layer.
2. Il blocco bottleneck come pattern per controllare i parametri in reti molto profonde.
3. Il record assoluto su ImageNet 2015 e la dimostrazione che le CNN possono raggiungere o superare la performance umana stimata su benchmark visivi standardizzati.
4. Un backbone di riferimento universale per il decennio 2016-2025.
5. La formalizzazione della struttura residual stream che sarà adottata dai transformer.

ResNet non ha:

1. Risolto definitivamente il vanishing gradient (lo ha mitigato strutturalmente; BN, init e altri trucchi restano necessari).
2. Reso le reti arbitrariamente profonde utili (oltre 150-200 layer su ImageNet i guadagni sono marginali).
3. Inventato le skip connections in assoluto (Highway Networks le aveva sette mesi prima, in forma con gates; LSTM le aveva nel 1997 in forma temporale; alcune architetture vision ancor prima usavano connessioni skip in modo specifico).
4. Eliminato il bisogno di tecniche complementari (data augmentation, regolarizzazione, learning rate scheduling restano cruciali).

La distinzione conta perché molte narrazioni divulgative attribuiscono a ResNet l’intera trasformazione del deep learning post-2015. La verità più sottile è che ResNet ha rimosso un blocco specifico (l’addestrabilità delle reti molto profonde) e ha consacrato un pattern (skip connections additive) che era in maturazione e che è poi diventato universale.

Dove si rompe

Diminishing returns sulla profondità

Il primo limite emerge proprio dal lavoro stesso degli autori. ResNet-1001 su CIFAR-10 (paper Identity Mappings 2016) è addestrabile, ma non porta vantaggio significativo su ResNet-110 sullo stesso dataset. Su ImageNet, ResNet-152 e ResNet-200 sono praticamente equivalenti: il guadagno per layer aggiunto si appiattisce drasticamente. Il messaggio è netto: la profondità da sola non è una leva infinita. Oltre una certa soglia (che dipende dal dataset e dal task), aggiungere layer aumenta il costo senza migliorare la prestazione.

Le architetture successive (Wide ResNet, ResNeXt, ConvNeXt) interpretano questo limite suggerendo altre dimensioni da sfruttare: larghezza, cardinalità, kernel size. La profondità resta importante ma non sufficiente. Il pattern “deeper is better” di 2012-2015 si è scoperto avere un soffitto.

Costo computazionale

ResNet-152 richiede circa 11.3 GFLOPs per immagine di forward pass e ha 60 milioni di parametri. Per inference su singola immagine in tempo reale, è un costo significativo. Per training su ImageNet, è un costo maggiore: il paper originale riporta circa 8 GPU per diversi giorni. Confrontato con MobileNet (Howard et al. 2017, ottimizzato per mobile, ~0.5 GFLOPs e 4M parametri) o EfficientNet (Tan-Le 2019, scaling bilanciato di profondità/larghezza/risoluzione), ResNet è oggi considerata “pesante” per molti scenari edge. Restano in uso ResNet-18 e ResNet-50 come baseline standard, ma la frontiera del deployment ha esplorato altre direzioni.

Sostituzione parziale da Vision Transformer

Dal 2020 in poi, Vision Transformer (ViT) e successori (Swin Transformer, DeiT, BEiT) hanno eroso il dominio di ResNet su task di scala molto grande. Su dataset di taglia JFT-300M o LAION-aligned, ViT scala meglio di CNN. Su dataset di taglia ImageNet (1.3M immagini), ResNet e ViT sono comparabili a parità di parametri se ViT è addestrato con tecniche moderne (DeiT mostra che con augmentation aggressiva e knowledge distillation, ViT compete con ResNet su ImageNet senza dataset esterni). Sotto ImageNet (regime low-data), ResNet resta competitivo grazie all’inductive bias delle convoluzioni. Il quadro post-2022 è ibrido: ResNet (e i suoi figli ConvNeXt) restano backbone validi in molti scenari, ma non sono più “il” default unico.

Mito: “ResNet ha risolto il vanishing gradient”

Una semplificazione comune nelle narrazioni divulgative. La verità è più articolata. Il vanishing gradient era stato già fortemente mitigato da batch normalization (febbraio 2015) e Kaiming initialization (febbraio 2015), entrambi prima di ResNet (dicembre 2015). Senza BN, anche ResNet avrebbe difficoltà ad addestrare 100+ layer. ResNet aggiunge un meccanismo strutturale (la skip connection) che rende l’ottimizzazione più stabile e che mitiga il gradient flow al limite, ma non è un sostituto di BN: nei paper originali, ResNet è sempre con BN. Le due tecniche sono complementari.

Mito: “skip connection = batch normalization”

Un altro mito da scartare. Skip connection e batch normalization fanno cose diverse. BN normalizza statisticamente le attivazioni durante il training; skip connection ridefinisce l’output del blocco come somma di input e residuo. La prima cambia la distribuzione dei segnali; la seconda cambia la struttura compositiva. Entrambe sono utili, e reti ben addestrabili in profondità tipicamente le combinano. Sostituirle l’una con l’altra non funziona: una rete plain con BN resta difficile da addestrare oltre 30-40 layer; una rete residuale senza BN è instabile.

Disputa di priorità: Highway Networks

Schmidhuber, in successive note pubbliche e in interviste, ha sostenuto che Highway Networks (Srivastava-Greff-Schmidhuber, maggio 2015) ha priorità concettuale sulla skip connection profonda. La rivendicazione è in parte legittima: Highway è uscito sette mesi prima e introduce per primo l’idea di un meccanismo differenziabile per bypassare layer in reti molto profonde. La distinzione tecnica resta importante: Highway usa gates apprese ($T(x)$ è una sigmoid parametrica), ResNet rimuove le gates e fissa la skip all’identità. La semplificazione di ResNet si è rivelata più stabile nel training e altrettanto efficace, e ha vinto come standard. È un caso istruttivo di come “meno è meglio” in architettura: rimuovere una libertà eccessiva (la gate) può migliorare l’ottimizzazione. Le due idee sono parenti concettuali ma diverse sufficientemente da non essere intercambiabili. La disputa è legittima storiograficamente, ma non riduce il contributo specifico di ResNet.

Bottleneck non è universale

Il bottleneck block è ottimizzato per reti molto profonde con molti canali (256, 512, 1024, 2048). Su reti meno profonde o con meno canali, il bottleneck può essere subottimale: la riduzione 1x1 introduce un overhead che non si ripaga. ResNet-18 e ResNet-34, che usano blocchi basic, hanno per immagine un costo computazionale per layer simile a un blocco bottleneck di ResNet-50, anche se i parametri totali sono minori. La scelta basic vs bottleneck è guidata dalla profondità target.

Limiti di interpretabilità

ResNet, come tutte le CNN profonde, è una black box. I tentativi di interpretare cosa “vedono” i layer (visualizzazione di feature, class activation maps di Zhou et al. 2016, Grad-CAM di Selvaraju et al. 2017) producono risultati suggestivi ma non costituiscono una teoria predittiva del comportamento del modello. La trasparenza meccanicistica degli LLM moderna (che si studierà in mech-interp-intro (in preparazione), in preparazione, Parte IX) non si è realizzata in modo equivalente per le CNN.

Collegamenti

• imagenet-alexnet-2012 — predecessore diretto e contesto: AlexNet apre l’era CNN, ResNet la matura. La triade dati+compute+algoritmi è la stessa lente.
• reti-neurali-80-90 — il problema del vanishing gradient ha radici storiche profonde. La sua mitigazione passa per LSTM, ReLU, BN e infine skip connections residuali.
• seq2seq-2014 — anche nelle reti per sequenze, le LSTM gestiscono un problema analogo (gradient flow attraverso passi temporali) con un meccanismo di gates additive che ha parentela concettuale con la struttura residuale.
• attention-bahdanau-2014 — l’attention di Bahdanau e la skip connection di ResNet sono entrambe meccanismi che riducono la lunghezza del path di flusso dell’informazione tra input e output. Convergono nei transformer.
• transformer-2017 (in preparazione, Parte I) — ogni transformer block applica residual connections nello stesso senso di ResNet. Filiazione tecnica documentata da citazione esplicita di He et al. 2016 in Vaswani et al. 2017.
• bert-gpt-2018-2019 (in preparazione, Parte I) — i grandi modelli pre-trained ereditano la struttura residuale dai transformer, e quindi indirettamente da ResNet.
• batch-normalization (in preparazione, Parte VIII) — la tecnica di Ioffe-Szegedy 2015 che mitiga il vanishing gradient e abilita l’addestramento di reti profonde, prerequisito di fatto per ResNet.
• cnn-architetture (in preparazione, Parte VIII) — panorama delle architetture CNN da LeNet a EfficientNet, dove ResNet occupa il posto centrale.
• regolarizzazione (in preparazione, Parte VIII) — weight decay, dropout, BN: tecniche complementari alle skip residuali per addestrare reti profonde.
• residual-stream (in preparazione, Parte IX) — la formalizzazione della struttura “stream + blocchi additivi” come modello mentale per i transformer, eredità diretta di ResNet.
• transformer-block (in preparazione, Parte IX) — anatomia del blocco transformer, dove le residual connections compaiono identiche a quelle di ResNet.

Per andare oltre

• He K., Zhang X., Ren S., Sun J., “Deep Residual Learning for Image Recognition”, CVPR 2016 (Best Paper Award), arXiv:1512.03385 (dicembre 2015). Il paper originale. Lettura obbligata: 12 pagine, denso ma chiaro, con la figura del paradosso plain-56-vs-20 in apertura della sezione 4.1.
• He K., Zhang X., Ren S., Sun J., “Identity Mappings in Deep Residual Networks”, ECCV 2016, arXiv:1603.05027 (marzo 2016). Il follow-up con pre-activation, l’analisi formale del gradient flow e l’esperimento ResNet-1001 su CIFAR-10.
• Srivastava R.K., Greff K., Schmidhuber J., “Highway Networks”, arXiv:1505.00387 (maggio 2015). Il predecessore concettuale con gates apprese. Utile per capire la distinzione tecnica tra Highway e ResNet, e per la disputa di priorità.
• Ioffe S., Szegedy C., “Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift”, ICML 2015, arXiv:1502.03167 (febbraio 2015). La tecnica complementare senza la quale ResNet non sarebbe addestrabile a 150+ layer.
• He K., Zhang X., Ren S., Sun J., “Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification”, ICCV 2015, arXiv:1502.01852 (febbraio 2015). Il paper di Kaiming initialization, dello stesso quartetto, dieci mesi prima di ResNet.
• Russakovsky O. et al., “ImageNet Large Scale Visual Recognition Challenge”, IJCV 2015, arXiv:1409.0575. La descrizione canonica del benchmark ILSVRC, con la stima della performance umana (~5.1% top-5) che ResNet ensemble supera nel 2015.
• Huang G., Liu Z., van der Maaten L., Weinberger K.Q., “Densely Connected Convolutional Networks” (DenseNet), CVPR 2017 (Best Paper Award), arXiv:1608.06993. La generalizzazione delle skip connections con concat invece di somma.
• Liu Z., Mao H., Wu C.-Y., Feichtenhofer C., Darrell T., Xie S., “A ConvNet for the 2020s” (ConvNeXt), CVPR 2022, arXiv:2201.03545. Il revival CNN con tecniche prese in prestito dai transformer, dimostrazione che la struttura residuale di ResNet resta vitale.
• Vaswani A. et al., “Attention Is All You Need”, NIPS 2017, arXiv:1706.03762. Il paper transformer, con citazione esplicita di He et al. 2016 per giustificare le residual connections nei propri block.