Leaky ReLU

Leaky ReLU (unità lineare rettificata con perdita) è una funzione di attivazione che restituisce invariato l'input quando è positivo e lo moltiplica per una piccola pendenza fissa, come 0.01, quando è negativo. Modifica la ReLU standard, che restituisce zero per ogni input negativo, in modo che i valori negativi producano comunque un piccolo output e, cosa ancora più importante, un gradiente non nullo durante la retropropagazione. Andrew Maas, Awni Hannun e Andrew Ng hanno descritto questa funzione nel 2013, in uno studio sulle attivazioni rettificatrici applicate ai modelli acustici per il riconoscimento vocale, usando una pendenza di 0.01. È usata nei modelli di apprendimento profondo in cui il flusso dei gradienti è importante: dai discriminatori delle reti generative avversarie ai rilevatori di oggetti YOLO meno recenti e alle unità di elaborazione neurale che eseguono modelli quantizzati con attivazioni lineari a tratti.

Come funziona Leaky ReLU#

Leaky ReLU calcola f(x) = x per x > 0 e f(x) = αx per x ≤ 0, dove la pendenza negativa α è un iperparametro fisso compreso tra 0 e 1. La derivata è 1 per gli input positivi e α per quelli negativi, perciò ogni input trasmette ai pesi che lo hanno prodotto una parte del gradiente. La pendenza usuale varia a seconda della fonte e del framework: nn.LeakyReLU di PyTorch usa 0.01 per impostazione predefinita, tf.nn.leaky_relu di TensorFlow usa 0.2 e il livello LeakyReLU di Keras usa 0.3. Questo codice fa passare gli input negativi attraverso ReLU e Leaky ReLU e calcola il gradiente di ciascuna:

import torch
from torch import nn

# Negative pre-activations, the inputs a ReLU unit turns into zeros
x = torch.tensor([-3.0, -1.0, -0.5], requires_grad=True)

for activation in (nn.ReLU(), nn.LeakyReLU(negative_slope=0.01)):
    y = activation(x)
    y.sum().backward()  # gradient that flows back toward the weights
    print(f"{activation}: output {y.detach().numpy()}, gradient {x.grad.numpy()}")
    x.grad = None

Stampa ReLU(): output [0. 0. 0.], gradient [0. 0. 0.] e LeakyReLU(negative_slope=0.01): output [-0.03 -0.01 -0.005], gradient [0.01 0.01 0.01]. ReLU non propaga alcun gradiente da questi input, quindi la discesa del gradiente non può modificare i pesi che li hanno prodotti; Leaky ReLU, invece, propaga l'1% del gradiente a monte.

Il problema delle ReLU inattive#

Un neurone ReLU si inattiva quando i suoi pesi e il suo bias cambiano tanto da rendere negativa la pre-attivazione per tutti gli input dei dati di addestramento. Il suo output e il suo gradiente sono quindi sempre zero e i pesi in ingresso non vengono più aggiornati: il neurone è perso in modo permanente per la rete neurale. Un'intensità di apprendimento elevata o un grande aggiornamento negativo del bias aumentano la probabilità che ciò accada. Leaky ReLU mantiene un piccolo gradiente sul lato negativo, quindi un neurone che si sposta nella regione negativa può ancora essere riportato indietro:

Il problema delle ReLU inattive è diverso dal problema del gradiente evanescente, in cui i gradienti si riducono gradualmente passando attraverso molti livelli di funzioni saturanti come sigmoid o tanh.

Leaky ReLU a confronto con le attivazioni correlate#

• ReLU: restituisce esattamente zero per gli input negativi, rendendo le attivazioni sparse e il calcolo economico, ma consentendo ai neuroni di inattivarsi. Leaky ReLU rinuncia alla sparsità esatta per garantire un gradiente ovunque.
• ReLU parametrica (PReLU): apprende la pendenza negativa durante l'addestramento, in genere un valore per canale, invece di fissarla. Kaiming He e colleghi hanno inizializzato la pendenza a 0.25, valore predefinito anche di nn.PReLU di PyTorch.
• SiLU e GELU: curve morbide che scendono leggermente sotto zero per gli input negativi e non presentano un angolo netto in corrispondenza dello zero. SiLU è la funzione predefinita nei moderni modelli YOLO e GELU è comune nei Transformer. Entrambe richiedono un'esponenziale per valore, mentre Leaky ReLU richiede solo un confronto e una moltiplicazione.

Dove si usa Leaky ReLU#

• Discriminatori DCGAN: l'architettura DCGAN usava Leaky ReLU con una pendenza di 0.2 in ogni livello del discriminatore; così il generatore riceve gradienti utili anche per le immagini rifiutate dal discriminatore, scelta mantenuta da molti GAN successivi.
• Primi rilevatori YOLO: lo YOLO originale usava Leaky ReLU con una pendenza di 0.1 in tutti i livelli tranne l'ultimo, come YOLOv2 e YOLOv3; YOLOv5 l'ha usata fino alla versione v4.0 del gennaio 2021, quando è stata sostituita da SiLU.
• Reti di attenzione sui grafi: queste reti neurali a grafo applicano Leaky ReLU con una pendenza di 0.2 per valutare quanto ogni nodo debba prestare attenzione ai nodi vicini.
• Acceleratori Edge AI: le unità di elaborazione neurale intere che eseguono modelli quantizzati possono integrare un'attivazione lineare a tratti nella convoluzione precedente. La DPU Xilinx di AMD lo fa per ReLU e Leaky ReLU, ma esegue sigmoid e quindi SiLU sulla CPU host.

I file YAML dei modelli Ultralytics YOLO accettano una chiave activation che sostituisce SiLU, la funzione predefinita, in ogni blocco convoluzionale standard; così YOLO26 può essere addestrato con activation: nn.LeakyReLU(0.1015625) per corrispondere alla pendenza fissa della DPU pari a 26/256.