Accueil › Glossaire › Activation Function

Fonction d’activation (Activation Function)

Une fonction d’activation est une transformation mathématique appliquée à la sortie de chaque neurone d’un réseau de neurones. Elle introduit la non-linéarité qui permet au réseau d’apprendre des relations complexes entre les entrées et les sorties, au-delà de simples combinaisons linéaires.

Sans fonction d’activation, un réseau de neurones, peu importe le nombre de couches, se réduit à une simple fonction linéaire. Empiler 100 couches linéaires revient mathématiquement à une seule couche. C’est la fonction d’activation qui « brise » cette linéarité et donne au réseau profond sa capacité d’approximation universelle : avec une seule couche cachée et une fonction d’activation non linéaire, un réseau peut en théorie approximer n’importe quelle fonction continue.

Pourquoi les fonctions d’activation sont essentielles

Imaginons un réseau sans fonction d’activation. Couche 1 : y₁ = W₁×x + b₁. Couche 2 : y₂ = W₂×y₁ + b₂ = W₂×(W₁×x + b₁) + b₂ = (W₂×W₁)×x + (W₂×b₁ + b₂). Le résultat est toujours une transformation linéaire de x. Deux couches se réduisent à une seule. Cent couches aussi. La profondeur est inutile.

Avec une fonction d’activation f non linéaire : couche 1 : y₁ = f(W₁×x + b₁). Couche 2 : y₂ = f(W₂×y₁ + b₂). Cette fois, la composition de fonctions non linéaires crée une transformation complexe que chaque couche enrichit. C’est ce qui permet aux réseaux profonds de reconnaître des visages, comprendre du texte ou jouer aux échecs.

Les principales fonctions d’activation

Sigmoïde (Logistique)

La sigmoïde compresse n’importe quelle valeur réelle en une sortie entre 0 et 1 :

σ(x) = 1 / (1 + e⁻ˣ)

La courbe est en forme de S : les valeurs très négatives tendent vers 0, les très positives vers 1, et la transition est douce autour de 0. C’est la fonction historique des réseaux de neurones, utilisée dans le perceptron moderne et la régression logistique.

Son usage principal est la couche de sortie des classifieurs binaires, où la sortie est interprétée comme une probabilité d’appartenance à la classe positive. Cependant, elle souffre du problème de gradient évanescent (vanishing gradient) : pour des valeurs très positives ou très négatives, la dérivée est quasi nulle, ce qui bloque l’apprentissage des couches profondes. C’est pourquoi elle est rarement utilisée dans les couches cachées des réseaux profonds.

Tanh (Tangente hyperbolique)

La tanh est une version centrée sur zéro de la sigmoïde :

tanh(x) = (eˣ - e⁻ˣ) / (eˣ + e⁻ˣ)

Plage de sortie : [-1, +1]. L’avantage sur la sigmoïde est le centrage sur zéro : les gradients ne sont pas contraints à aller dans une seule direction, ce qui facilite l’optimisation. Ses gradients sont aussi plus forts que ceux de la sigmoïde. Cependant, elle souffre toujours du vanishing gradient dans les régions de saturation (valeurs très positives ou très négatives). En pratique, tanh est préférée à la sigmoïde pour les couches cachées quand ReLU n’est pas applicable.

ReLU (Rectified Linear Unit)

ReLU est la fonction d’activation par défaut des couches cachées depuis 2012. 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. Malgré cette simplicité, ReLU a révolutionné le deep learning pour plusieurs raisons. Elle élimine le vanishing gradient pour les valeurs positives (la dérivée est constante à 1). Elle est extrêmement rapide à calculer (une simple comparaison, pas d’exponentielle). Et elle crée de la parcimonie : une partie des neurones est « éteinte » (sortie = 0), ce qui réduit la complexité effective du réseau.

Le problème de ReLU est le « dying ReLU » : si un neurone reçoit systématiquement des entrées négatives, sa sortie est toujours 0, son gradient est toujours 0, et il ne peut plus apprendre. Ce neurone est « mort ». Les variantes Leaky ReLU (pente de 0,01 pour les valeurs négatives) et PReLU (pente apprise) résolvent ce problème.

Softmax

Softmax est la fonction standard pour la couche de sortie des classifieurs multi-classes. Elle transforme un vecteur de valeurs brutes (logits) en une distribution de probabilités dont la somme vaut 1 :

softmax(xᵢ) = eˣⁱ / Σⱼ eˣʲ

Si un réseau doit classifier une image en 1000 catégories (comme ImageNet), la couche de sortie a 1000 neurones et softmax transforme leurs 1000 valeurs brutes en 1000 probabilités. La classe avec la probabilité la plus élevée est la prédiction du réseau.

La différence clé avec la sigmoïde : les probabilités softmax sont interdépendantes (elles somment à 1). Si la probabilité d’une classe augmente, celle des autres diminue. Avec la sigmoïde, chaque sortie est indépendante, ce qui convient à la classification multi-label (un exemple peut appartenir à plusieurs classes simultanément).

GELU (Gaussian Error Linear Unit)

GELU est la fonction d’activation utilisée dans la plupart des architectures transformer modernes, notamment BERT (2018) et les modèles GPT. C’est une version lissée de ReLU qui multiplie l’entrée par la probabilité qu’elle soit positive sous une distribution gaussienne :

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

Contrairement à ReLU qui applique un seuil dur à zéro, GELU fait une transition douce. 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.

SwiGLU, utilisé dans LLaMA, Mistral et d’autres LLM récents, est une variante gated qui combine Swish (une version paramétrique de GELU) avec un mécanisme de porte linéaire. Elle est actuellement l’une des fonctions d’activation les plus performantes pour les architectures de LLM.

Tableau comparatif

Comment choisir la bonne fonction d’activation

La règle qui couvre 90 % des cas pratiques est simple.

Pour les couches cachées : utilisez ReLU par défaut. Si vous observez des neurones morts (dying ReLU), passez à Leaky ReLU ou PReLU. Si vous travaillez avec des transformers, utilisez GELU.

Pour la couche de sortie : classification binaire → sigmoïde. Classification multi-classes → softmax. Régression (prédiction d’une valeur continue) → pas de fonction d’activation (identité) ou tanh si la sortie doit être bornée.

Pour le reinforcement learning : réseaux de valeur Q → sortie linéaire (les Q-values peuvent être n’importe quel nombre réel). Réseaux de politique (actions discrètes) → softmax. Actions continues → tanh (sortie bornée entre -1 et 1).

Le problème du gradient évanescent

Le vanishing gradient est le problème historique qui a freiné le deep learning pendant des décennies. Quand la sigmoïde ou la tanh sature (entrées très positives ou très négatives), leur dérivée tend vers zéro. 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 : elles n’apprennent plus.

ReLU résout ce problème car sa dérivée est 1 pour toutes les valeurs positives, ce qui maintient un flux de gradient constant à travers les couches. C’est la raison principale pour laquelle les réseaux profonds (10, 50, 100+ couches) sont devenus possibles avec ReLU, alors qu’ils étaient impraticables avec la sigmoïde. La technique de connexion résiduelle (skip connections) apporte une solution complémentaire en créant des chemins directs pour le gradient.

Inspiration biologique

Les fonctions d’activation s’inspirent du fonctionnement des neurones biologiques. Un neurone biologique reçoit des signaux via ses dendrites, les intègre dans son corps cellulaire, et « fire » (émet un potentiel d’action) si la stimulation totale dépasse un certain seuil. Ce comportement tout-ou-rien est la base de la fonction de Heaviside utilisée dans le perceptron original de Rosenblatt.

Cependant, la réalité biologique est plus nuancée. Le taux de décharge d’un neurone augmente progressivement avec l’intensité du stimulus, ce qui ressemble davantage à une sigmoïde qu’à un seuil binaire. Et un neurone ne peut pas dépasser un certain taux de décharge maximal, ce qui justifie l’utilisation de fonctions à sortie bornée (sigmoïde, tanh). Les fonctions d’activation modernes comme ReLU s’éloignent davantage de la biologie (pas de borne supérieure, pas de sortie négative) mais sont plus efficaces pour l’optimisation numérique.

Propriétés clés d’une bonne fonction d’activation

Non-linéarité : c’est la propriété fondamentale. Sans elle, la profondeur du réseau est inutile. Dérivabilité : la rétropropagation nécessite le calcul du gradient, donc la fonction doit être dérivable (au moins presque partout, ReLU n’est pas dérivable en 0 mais cela ne pose pas de problème en pratique). Gradient non nul : les régions où le gradient est nul ou quasi nul empêchent l’apprentissage (vanishing gradient). Efficacité de calcul : la fonction est appelée des milliards de fois pendant l’entraînement, chaque microseconde compte. ReLU (une comparaison) est bien plus rapide que la sigmoïde (une exponentielle). Centrage sur zéro : les fonctions centrées sur zéro (tanh, Leaky ReLU) facilitent l’optimisation car les gradients ne sont pas biaisés dans une seule direction.

Leaky ReLU et ses variantes

Le problème du « dying ReLU » survient quand un neurone reçoit systématiquement des entrées négatives : sa sortie est toujours 0, son gradient est 0, et il ne peut plus jamais se réactiver. Leaky ReLU résout ce problème en attribuant une petite pente (typiquement 0,01) aux valeurs négatives :

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

PReLU (Parametric ReLU) va plus loin en rendant cette pente apprise pendant l’entraînement plutôt que fixée. Kaiming He et al. ont montré en 2015 que PReLU permet de surpasser les performances humaines sur ImageNet, démontrant l’importance du choix de la fonction d’activation pour les réseaux très profonds.

ELU (Exponential Linear Unit) utilise une courbe exponentielle pour les valeurs négatives, ce qui produit des sorties plus proches de zéro en moyenne et améliore la convergence. SELU (Scaled ELU) est une version auto-normalisante qui maintient automatiquement les activations proches d’une moyenne de zéro et d’une variance unitaire, réduisant le besoin de normalisation de couche explicite.

Implémentation en Python

import numpy as np

# Sigmoïde
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Tanh
def tanh(x):
    return np.tanh(x)

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

# Leaky ReLU
def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

# Softmax
def softmax(x):
    exp_x = np.exp(x - np.max(x))  # Stabilité numérique
    return exp_x / exp_x.sum()

# Exemples
x = np.array([-2.0, -1.0, 0.0, 1.0, 2.0])
print("Sigmoid :", sigmoid(x))    # [0.12, 0.27, 0.50, 0.73, 0.88]
print("Tanh    :", tanh(x))       # [-0.96, -0.76, 0.00, 0.76, 0.96]
print("ReLU    :", relu(x))       # [0, 0, 0, 1, 2]
print("Leaky   :", leaky_relu(x)) # [-0.02, -0.01, 0, 1, 2]

logits = np.array([2.0, 1.0, 0.1])
print("Softmax :", softmax(logits))  # [0.659, 0.242, 0.099]

En PyTorch et TensorFlow/Keras, les fonctions d’activation sont des modules intégrés que vous appliquez directement dans la définition de votre réseau :

# PyTorch
import torch.nn as nn
model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),           # Activation couche cachée
    nn.Linear(256, 10),
    nn.Softmax(dim=1)    # Activation couche de sortie
)

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

Évolution historique

Années 1950-1980 : fonction de Heaviside (seuil binaire) dans le perceptron de Rosenblatt. Pas de gradient, pas de rétropropagation possible. Années 1980-2000 : sigmoïde et tanh dominent grâce à leur dérivabilité, permettant la rétropropagation mais limitant la profondeur des réseaux à cause du vanishing gradient. 2012 : AlexNet utilise ReLU et remporte ImageNet avec une marge écrasante, déclenchant la révolution du deep learning. La communauté réalise que ReLU, malgré sa simplicité, est la clé pour entraîner des réseaux profonds. 2015 : ResNet combine ReLU avec des connexions résiduelles pour entraîner des réseaux de 152 couches, un exploit impossible avec les fonctions d’activation précédentes. 2018 : BERT utilise GELU, qui devient le standard des transformers. 2023+ : SwiGLU et ses variantes dominent les architectures LLM (LLaMA, Mistral, Gemma), offrant un gain de performance mesurable par rapport à GELU sur les benchmarks de modélisation du langage.