Leaky ReLU

Leaky ReLU (unité linéaire rectifiée avec fuite) est une fonction d’activation qui renvoie son entrée sans la modifier si celle-ci est positive et la multiplie par une petite pente fixe, par exemple 0.01, si elle est négative. Elle modifie la ReLU standard, qui renvoie zéro pour toute entrée négative, afin que les valeurs négatives produisent tout de même une petite sortie et, surtout, un gradient non nul pendant la rétropropagation. Andrew Maas, Awni Hannun et Andrew Ng ont décrit cette fonction en 2013 dans une étude sur les activations rectificatrices des modèles acoustiques de reconnaissance vocale, en utilisant une pente de 0.01. Elle est utilisée dans les modèles d’apprentissage profond où la propagation du gradient est importante, des discriminateurs de réseaux antagonistes génératifs aux anciens détecteurs d’objets YOLO, en passant par les unités de traitement neuronal qui exécutent des modèles quantifiés avec des activations linéaires par morceaux.

Fonctionnement de Leaky ReLU#

Leaky ReLU calcule f(x) = x pour x > 0 et f(x) = αx pour x ≤ 0, où la pente négative α est un hyperparamètre fixe compris entre 0 et 1. Sa dérivée vaut 1 pour les entrées positives et α pour les entrées négatives. Chaque entrée transmet donc une partie du gradient aux poids qui l’ont produite. La pente habituelle varie selon la source et le framework : nn.LeakyReLU de PyTorch utilise 0.01 par défaut, tf.nn.leaky_relu de TensorFlow utilise 0.2 et la couche LeakyReLU de Keras utilise 0.3. Ce code fait passer des entrées négatives par ReLU et Leaky ReLU, puis calcule le gradient de chacune :

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

Le code affiche ReLU(): output [0. 0. 0.], gradient [0. 0. 0.] et LeakyReLU(negative_slope=0.01): output [-0.03 -0.01 -0.005], gradient [0.01 0.01 0.01]. ReLU ne transmet aucun gradient à partir de ces entrées ; la descente de gradient ne peut donc pas modifier les poids qui les ont produites. Leaky ReLU transmet 1 % du gradient amont.

Le problème des ReLU mortes#

Un neurone ReLU meurt lorsque ses poids et son biais changent au point que sa préactivation est négative pour chaque entrée des données d’entraînement. Sa sortie et son gradient sont alors toujours nuls, et ses poids d’entrée ne sont plus jamais mis à jour : le neurone est définitivement perdu pour le réseau neuronal. Un taux d’apprentissage élevé ou une forte mise à jour négative du biais augmente ce risque. Leaky ReLU conserve un petit gradient du côté négatif, de sorte qu’un neurone qui dérive vers la région négative peut encore être ramené :

Le problème des ReLU mortes est différent du problème du gradient évanescent, où les gradients diminuent progressivement en traversant de nombreuses couches de fonctions saturantes comme sigmoid ou tanh.

Leaky ReLU et les fonctions d’activation apparentées#

• ReLU : renvoie des zéros exacts pour les entrées négatives, ce qui rend les activations clairsemées et le calcul peu coûteux, mais peut entraîner la mort de neurones. Leaky ReLU renonce à cette parcimonie exacte pour fournir un gradient partout.
• ReLU paramétrique (PReLU) : apprend la pente négative pendant l’entraînement, généralement une valeur par canal, au lieu de la fixer. Kaiming He et ses collègues ont initialisé la pente à 0.25, qui est également la valeur par défaut de nn.PReLU de PyTorch.
• SiLU et GELU : courbes lisses qui passent légèrement sous zéro pour les entrées négatives et ne présentent aucun angle aigu en zéro. SiLU est la fonction par défaut des modèles YOLO modernes, tandis que GELU est courante dans les transformers. Toutes deux nécessitent une exponentielle par valeur, alors que Leaky ReLU ne requiert qu’une comparaison et une multiplication.

Utilisation de Leaky ReLU#

• Discriminateurs DCGAN : l’architecture DCGAN utilisait Leaky ReLU avec une pente de 0.2 dans chaque couche du discriminateur. Le générateur reçoit ainsi des gradients utiles même pour les images rejetées par le discriminateur, et de nombreux GAN ultérieurs ont conservé ce choix.
• Premiers détecteurs YOLO : le YOLO d’origine utilisait Leaky ReLU avec une pente de 0.1 dans toutes les couches sauf la dernière, tout comme YOLOv2 et YOLOv3. YOLOv5 l’a utilisée jusqu’à sa version 4.0 de janvier 2021, qui l’a remplacée par SiLU.
• Réseaux d’attention sur graphes : ces réseaux neuronaux sur graphes appliquent Leaky ReLU avec une pente de 0.2 pour calculer le poids d’attention que chaque nœud doit accorder à ses voisins.
• Accélérateurs d’IA en périphérie : les unités de traitement neuronal entières qui exécutent des modèles quantifiés peuvent intégrer une activation linéaire par morceaux à la convolution précédente. Le DPU Xilinx d’AMD le fait pour ReLU et Leaky ReLU, mais exécute sigmoid, et donc SiLU, sur le CPU hôte.

Les fichiers YAML des modèles Ultralytics YOLO acceptent une clé activation qui remplace SiLU, la fonction par défaut, dans chaque bloc de convolution standard. YOLO26 peut donc être entraîné avec activation: nn.LeakyReLU(0.1015625) pour correspondre à la pente fixe du DPU, égale à 26/256.