Accueil › Glossaire › ReLU

ReLU (Rectified Linear Unit)

ReLU (Rectified Linear Unit) est la fonction d’activation la plus utilisée en deep learning. Sa formule est d’une simplicité trompeuse : ReLU(x) = max(0, x). Si l’entrée est positive, elle passe telle quelle. Si elle est négative, elle est remplacée par zéro. Cette opération élémentaire a rendu possible l’entraînement des réseaux de neurones profonds modernes.

Avant ReLU, les réseaux de neurones utilisaient la sigmoïde et la tanh comme fonctions d’activation. Ces fonctions souffrent du problème de gradient évanescent (vanishing gradient) : leurs dérivées tendent vers zéro dans les régions de saturation, empêchant les couches profondes d’apprendre. ReLU résout ce problème de manière radicale : sa dérivée est 1 pour toutes les valeurs positives, maintenant un flux de gradient constant à travers les couches. C’est ce qui a permis de passer de réseaux de 2-3 couches à des architectures de 50, 100, voire 1000+ couches.

Comment fonctionne ReLU

Le principe est mécanique : les valeurs positives passent sans modification, les valeurs négatives sont mises à zéro. C’est l’équivalent d’un redressement demi-onde en électronique (half-wave rectification), d’où le nom « rectified ».

import numpy as np

def relu(x):
    return np.maximum(0, x)

x = np.array([-3, -1, 0, 1, 3])
print(relu(x))  # [0, 0, 0, 1, 3]

La dérivée est tout aussi simple : 0 pour les entrées négatives, 1 pour les positives. En x=0, la fonction n’est pas formellement dérivable, mais par convention la dérivée est fixée à 0 (ou parfois 0,5). En pratique, la probabilité d’une entrée exactement à 0 est infinitésimale, ce qui rend cette non-dérivabilité théorique sans conséquence.

Pourquoi ReLU a révolutionné le deep learning

Résolution du vanishing gradient

La sigmoïde et la tanh saturent pour les valeurs extrêmes : leur dérivée s’approche de 0. Lors de la rétropropagation, les gradients sont multipliés couche par couche. Si chaque couche multiplie par un nombre proche de zéro, le gradient qui arrive aux premières couches est infinitésimal, et elles cessent d’apprendre. C’est le vanishing gradient.

ReLU élimine ce problème pour les valeurs positives : la dérivée est constamment 1. Le gradient traverse les couches sans atténuation. C’est ce qui a rendu possible les réseaux très profonds comme ResNet (152 couches, 2015).

Parcimonie naturelle (sparsity)

Dans un réseau initialisé aléatoirement, environ 50 % des neurones reçoivent des entrées négatives et produisent donc une sortie de 0. Le réseau est naturellement parcimonieux : seule une fraction des neurones est active pour une entrée donnée. Cette parcimonie réduit la complexité effective du réseau, améliore la généralisation et accélère le calcul.

Efficacité computationnelle

ReLU ne nécessite qu’une comparaison (x > 0 ?). La sigmoïde exige une exponentielle, et la tanh deux exponentielles. Sur des milliards de neurones évalués à chaque itération d’entraînement, cette différence de coût computationnel est significative. ReLU permet d’entraîner des réseaux plus larges et plus profonds dans le même budget de temps.

Équivariance d’intensité

Nair et Hinton (2010) ont argumenté que ReLU possède une propriété d’équivariance d’intensité utile pour la reconnaissance d’images : multiplier l’image d’entrée par une constante k multiplie aussi la sortie par k. Cette propriété est fausse pour la sigmoïde ou la tanh, où la relation entre entrée et sortie est non linéaire dans toute la plage.

Le problème du « Dying ReLU »

C’est la faiblesse principale de ReLU. Si un neurone reçoit systématiquement des entrées négatives (par exemple après une mise à jour de poids malheureuse), sa sortie est toujours 0, son gradient est toujours 0, et il ne peut plus apprendre. Ce neurone est « mort » : il ne contribue plus au réseau et ne peut pas se réactiver.

Dans un réseau typique, des praticiens rapportent des taux de neurones morts de 9 à 21 % par couche après 30 epochs avec un learning rate de 3×10⁻⁴. Des observations récentes (2025-2026) montrent que dans des architectures profondes, jusqu’à 46 % des gradients d’activation peuvent être exactement zéro avec ReLU standard.

Les facteurs qui aggravent le dying ReLU sont un learning rate trop élevé (les mises à jour de poids dépassent le seuil et poussent les neurones en territoire négatif permanent), l’absence de normalisation (les activations dérivent hors de la plage utile) et une mauvaise initialisation des poids. L’initialisation de He (Kaiming initialization), spécifiquement conçue pour ReLU, atténue significativement ce problème en calibrant la variance initiale des poids en fonction du nombre de neurones d’entrée.

Les variantes de ReLU

Leaky ReLU

Leaky ReLU attribue une petite pente (typiquement 0,01) aux valeurs négatives au lieu de les annuler :

Leaky ReLU(x) = x si x > 0, sinon α × x (avec α = 0.01)

Le neurone ne meurt jamais car son gradient n’est jamais exactement 0. Des praticiens rapportent que le passage de ReLU à Leaky ReLU réduit les incidents de couches bloquées de 14 % à 2 % dans des projets variés (vision et NLP). La fraction de gradients exactement nuls passe de 46 % à 33 % dans des transformers de 24 couches.

PReLU (Parametric ReLU)

PReLU rend la pente des valeurs négatives apprise pendant l’entraînement plutôt que fixée :

PReLU(x) = x si x > 0, sinon α × x (α appris)

He et al. (2015) ont montré que PReLU permet de surpasser les performances humaines sur ImageNet, démontrant l’impact du choix de la fonction d’activation pour les réseaux très profonds. L’avantage est que le réseau détermine lui-même la pente optimale pour chaque couche.

ELU (Exponential Linear Unit)

ELU utilise une courbe exponentielle pour les valeurs négatives :

ELU(x) = x si x > 0, sinon α × (eˣ - 1)

La transition est lisse (pas de cassure en 0), les sorties moyennes sont plus proches de zéro, et le gradient ne s’annule jamais. ELU converge souvent plus vite que ReLU, mais le calcul de l’exponentielle le rend plus coûteux. SELU (Scaled ELU) est une version auto-normalisante qui maintient automatiquement les activations proches d’une moyenne nulle et d’une variance unitaire, réduisant le besoin de normalisation de couche.

GELU (Gaussian Error Linear Unit)

GELU est le standard des architectures transformer. Utilisé dans BERT (2018) et les modèles GPT, il effectue une transition douce plutôt qu’un seuil dur :

GELU(x) ≈ 0.5 × x × (1 + tanh(√(2/π) × (x + 0.044715 × x³)))

Les valeurs légèrement négatives ne sont pas brutalement annulées mais progressivement atténuées. Cette douceur améliore l’entraînement des transformers. Dans les benchmarks, les réseaux utilisant GELU maintiennent leur stabilité numérique jusqu’à environ 500 couches, là où ReLU commence à produire des valeurs NaN autour de 300 couches.

Swish et SwiGLU

Swish, découvert par des chercheurs de Google, est une fonction auto-gated : Swish(x) = x × σ(x) où σ est la sigmoïde. Elle surpasse ReLU sur de nombreux benchmarks de deep learning. SwiGLU, utilisé dans LLaMA, Mistral, Gemma et d’autres LLM récents, combine Swish avec un mécanisme de porte linéaire. C’est actuellement l’une des fonctions d’activation les plus performantes pour les architectures LLM.

Histoire de ReLU

1941 : Alston Householder utilise la fonction de redressement comme abstraction mathématique des réseaux neuronaux biologiques. C’est la première apparition connue de la fonction max(0, x) dans un contexte neuronal. 1969 : Kunihiko Fukushima utilise ReLU dans le contexte de l’extraction de caractéristiques visuelles dans des réseaux hiérarchiques. 2000 : Hahnloser et al. argumentent que ReLU approxime la relation biologique entre les taux de décharge neuronaux et le courant d’entrée, et démontrent sa stabilité pour les dynamiques de réseaux récurrents. 2009 : Jarrett et al. notent que la rectification est critique pour la reconnaissance d’objets dans les CNN. 2010 : Nair et Hinton proposent formellement ReLU comme une bonne approximation de la fonction softplus (log(1 + eˣ)) et démontrent ses performances empiriques dans les machines de Boltzmann restreintes. 2011 : Glorot et al. argumentent systématiquement les avantages de ReLU (similarité biologique, gradient non évanescent, parcimonie, coût de calcul) et montrent que les réseaux profonds avec ReLU fonctionnent bien sans pré-entraînement non supervisé. 2012 : AlexNet utilise ReLU et remporte ImageNet avec une marge écrasante. Le deep learning moderne commence.

Quand utiliser ReLU et quand l’éviter

Utilisez ReLU comme choix par défaut pour les couches cachées de tout réseau de neurones (CNN, MLP, autoencoders). C’est le point de départ correct pour 90 % des projets. Passez à Leaky ReLU si vous observez des neurones morts (plus de 5 % de neurones avec sortie constamment à zéro) ou si votre réseau a plus de 50 couches. Utilisez GELU pour les architectures transformer. Utilisez SwiGLU pour les LLM de grande taille.

N’utilisez jamais ReLU dans la couche de sortie : utilisez sigmoïde pour la classification binaire, softmax pour la classification multi-classes, ou pas de fonction d’activation (linéaire) pour la régression.

ReLU dans les architectures célèbres

AlexNet (2012) : le réseau qui a déclenché la révolution du deep learning. Krizhevsky, Sutskever et Hinton ont utilisé ReLU dans leurs couches cachées et ont rapporté que l’entraînement convergeait six fois plus vite qu’avec la tanh. La victoire écrasante d’AlexNet sur ImageNet (erreur top-5 réduite de 26 % à 15,3 %) a convaincu la communauté que le deep learning fonctionnait, et ReLU est devenu le choix par défaut.

VGGNet (2014) : réseau de 16 à 19 couches utilisant exclusivement ReLU. A démontré que la profondeur (avec ReLU) améliore systématiquement les performances en vision par ordinateur.

ResNet (2015) : réseau de 152 couches combinant ReLU avec des connexions résiduelles. Les skip connections permettent au gradient de contourner les couches, ce qui, combiné à ReLU, élimine le vanishing gradient même pour des réseaux extrêmement profonds. ResNet a remporté ImageNet 2015 avec un taux d’erreur de 3,57 %, surpassant les performances humaines estimées à environ 5 %.

Les architectures plus récentes ont progressivement migré vers des variantes de ReLU. Les CNN modernes utilisent souvent Leaky ReLU ou PReLU. Les transformers utilisent GELU. Les LLM de dernière génération privilégient SwiGLU. Mais le principe fondamental reste le même : une fonction simple qui laisse passer les signaux utiles et bloque le reste.

Comparaison mathématique avec sigmoïde et tanh

La sigmoïde σ(x) = 1/(1+e⁻ˣ) a une dérivée maximale de 0,25 (en x=0). À chaque couche, le gradient est multiplié par au plus 0,25. Après 10 couches, le gradient est au mieux 0,25¹⁰ ≈ 0,000001. C’est le vanishing gradient en action.

La tanh a une dérivée maximale de 1 (en x=0), mais elle sature rapidement pour les grandes valeurs. En pratique, la dérivée moyenne effective est bien inférieure à 1, et le vanishing gradient se produit aussi, quoique moins sévèrement qu’avec la sigmoïde.

ReLU a une dérivée de exactement 1 pour toutes les valeurs positives. Après 10 couches, le gradient est 1¹⁰ = 1. Pas d’atténuation. C’est cette propriété mathématique simple qui change tout. Le gradient peut aussi exploser (dérivée constante de 1 sans borne supérieure), mais la normalisation de couche (BatchNorm, LayerNorm) contrôle ce risque.

Implémentation

# NumPy
import numpy as np
relu = lambda x: np.maximum(0, x)
leaky_relu = lambda x, a=0.01: np.where(x > 0, x, a * x)

# PyTorch
import torch.nn as nn
model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),               # ReLU standard
    nn.Linear(256, 128),
    nn.LeakyReLU(0.01),      # Leaky ReLU
    nn.Linear(128, 10)
)

# Keras
from tensorflow import keras
model = keras.Sequential([
    keras.layers.Dense(256, activation='relu', input_shape=(784,)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

Pour l’initialisation de He (recommandée avec ReLU) en PyTorch, qui calibre la variance des poids en fonction du nombre d’entrées du neurone pour éviter que les activations n’explosent ou ne s’effondrent :

import torch.nn as nn

layer = nn.Linear(784, 256)
nn.init.kaiming_normal_(layer.weight, mode='fan_in', nonlinearity='relu')