Fonction d’activation GELU : formule, intuition et usages en deep learning

Les fonctions d’activation décident quels signaux traversent un réseau de neurones et lesquels sont bloqués. Un mauvais choix peut rendre l’apprentissage trop lent ou nuire à la capacité de généralisation. ReLU a longtemps été le choix par défaut car elle est rapide et suffisante pour la plupart des tâches.

GELU (Gaussian Error Linear Unit) a changé la donne. C’est aujourd’hui la fonction d’activation derrière certains des modèles les plus performants jamais construits, dont BERT et GPT.

Dans cet article, nous verrons l’intuition derrière GELU, sa formule, comment elle se compare aux autres fonctions d’activation et où l’utiliser concrètement.

Si vous débutez totalement avec les fonctions d’activation en apprentissage automatique, lisez notre guide du débutant sur la Rectified Linear Unit (ReLU).

Qu’est-ce que la fonction d’activation GELU ?

GELU, ou Gaussian Error Linear Unit, est une fonction d’activation qui pondère les entrées selon leur magnitude via une approche lisse et probabiliste.

La plupart des fonctions d’activation décident de laisser passer ou non le signal. ReLU, par exemple, met à zéro toutes les valeurs négatives et laisse le reste inchangé. GELU fonctionne différemment. Au lieu d’un seuil dur, elle met à l’échelle les entrées de manière continue selon qu’elles sont grandes ou petites, ce qui signifie que même de petites valeurs négatives peuvent encore contribuer à la sortie.

La différence avec ReLU est que GELU est lisse et continue partout. Pas d’angle vif à zéro ni de transitions brutales. Cette continuité compte à l’entraînement car elle fournit à l’optimiseur des gradients plus propres.

L’intuition derrière GELU

Voyez GELU comme un filtre qui ne traite pas toutes les entrées de la même manière.

ReLU est tranchante : toute valeur négative est mise à zéro, systématiquement. À l’inverse, GELU se demande : « quelle est la probabilité que cette valeur d’entrée soit utile ? » Les valeurs nettement grandes et positives passent presque inchangées. Les petites valeurs, y compris négatives, sont atténuées plutôt que coupées net.

Au final, on obtient une courbe lisse qui atténue les signaux moins pertinents sans les éliminer complètement.

Imaginez que vous passiez en revue une pile de candidatures. Un filtre strict écarterait toute personne sans diplôme, sans exception. Un filtre plus intelligent considérerait malgré tout des profils proches, car une expérience pertinente peut compenser. GELU fonctionne comme ce filtre plus intelligent : elle ne tranche pas de façon binaire, mais pondère chaque entrée selon sa magnitude pour décider de la laisser plus ou moins passer.

Cette mise à l’échelle progressive et probabiliste fait la particularité de GELU. Pas de transitions brusques et pas de neurones « morts » : seulement une décision lisse d’atténuation ou de passage pour chaque valeur d’entrée.

Formule de GELU

La formule exacte de GELU repose sur la fonction de répartition (CDF) de la loi normale standard, écrite :

Fonction de répartition de la loi normale

où x est la valeur d’entrée et Φ(x) la probabilité qu’une variable aléatoire suivant une loi normale centrée réduite soit inférieure ou égale à x. En clair, Φ(x) indique à quel point la valeur d’entrée est « normale » ou attendue — et c’est cette probabilité que GELU utilise pour mettre l’entrée à l’échelle.

Plus l’entrée est élevée, plus Φ(x) se rapproche de 1 : l’entrée passe alors presque inchangée. Plus elle est faible, plus Φ(x) tend vers 0 : l’entrée est alors fortement atténuée.

L’approximation utilisée en pratique

Le souci avec la formule exacte est que calculer Φ(x) coûte cher : cela implique la fonction d’erreur, qui n’a pas de forme fermée simple et reste lente à grande échelle.

Les frameworks de deep learning utilisent donc cette approximation :

Formule d’approximation de GELU

Cette approximation utilise tanh, rapide et très bien prise en charge par le matériel moderne. Le résultat est quasiment identique à la formule exacte sur l’intervalle d’entrées pertinent en pratique, raison pour laquelle des frameworks comme PyTorch et TensorFlow l’emploient par défaut.

Bien sûr, vous n’avez pas besoin de mémoriser ces formules. Mais savoir qu’une approximation existe — et pourquoi — aide à comprendre ce qui se passe réellement quand vous appelez GELU dans votre code.

GELU vs autres fonctions d’activation

Chaque fonction d’activation traite les entrées différemment, et ces différences se reflètent dans la qualité d’apprentissage de votre modèle.

Voici d’abord une visualisation des différences avant l’explication détaillée :

Courbe : GELU vs autres fonctions d’activation

Sigmoïde

La sigmoïde comprime toutes les entrées entre 0 et 1. Elle est lisse, mais souffre d’un problème connu : l’extinction des gradients. Pour des entrées très grandes ou très petites, le gradient tend vers zéro, ce qui empêche les couches profondes d’apprendre. GELU évite ce problème car son gradient reste pertinent sur un intervalle d’entrées plus large.

Tanh

Tanh est similaire à la sigmoïde mais centrée sur zéro, avec des sorties entre -1 et 1. Elle gère mieux les entrées négatives que la sigmoïde, mais souffre tout de même d’extinction des gradients aux extrêmes. GELU fournit une courbe de sortie plus lisse et un flux de gradients plus stable dans les réseaux profonds.

ReLU

ReLU est rapide et simple : les valeurs positives passent inchangées, les négatives sont mises à zéro. Le seuil abrupt à zéro cause le problème des neurones « morts » : des neurones recevant constamment des valeurs négatives cessent d’être mis à jour. GELU évite cela en atténuant les entrées négatives au lieu de les couper.

Leaky ReLU

Leaky ReLU corrige le problème des neurones morts en laissant passer une petite fraction des entrées négatives. C’est mieux que ReLU, mais la transition à zéro reste brutale. GELU produit une courbe globalement plus lisse, ce qui tend à mieux fonctionner dans des architectures profondes où la qualité des gradients est primordiale.

Pour résumer, voici les différences entre ces cinq fonctions d’activation :

Tableau : GELU vs autres fonctions d’activation

Pourquoi GELU est utilisée dans les transformers

Les transformers sont des réseaux de neurones profonds. Et plus un réseau est profond, plus la qualité des gradients compte.

Des modèles comme BERT et GPT empilent des dizaines de couches. À cette profondeur, de petits problèmes de flux de gradients se cumulent. Si votre fonction d’activation produit des gradients instables ou quasi nuls dans certaines régions, les couches amont se mettent à peine à jour pendant l’entraînement et apprennent peu.

GELU évite cela en gardant des gradients lisses et non nuls sur un intervalle d’entrées plus large. Il n’y a pas de coupure comme la frontière zéro de ReLU, donc l’optimiseur reçoit un signal plus propre à chaque couche, pas seulement près de la sortie.

Il existe une autre raison pour laquelle GELU s’intègre bien aux architectures de type transformer. 

Les transformers traitent les entrées via des mécanismes d’attention qui produisent une large gamme de valeurs d’activation — positives comme négatives. Une fonction d’activation lisse gère mieux cette diversité qu’une fonction à transitions brusques.

Dans l’article fondateur de BERT, les auteurs ont choisi GELU plutôt que ReLU et ont rapporté de meilleurs résultats sur leurs benchmarks. GPT a suivi la même voie. Depuis, GELU est devenue l’activation par défaut dans la plupart des architectures basées sur des transformers, non pas parce qu’elle est nouvelle, mais parce qu’elle fonctionne mieux à l’échelle de ces modèles.

GELU en pratique

Utiliser GELU dans vos modèles est aussi simple que d’employer n’importe quelle autre fonction d’activation. PyTorch et TensorFlow la prennent en charge nativement.

PyTorch

Avec PyTorch, vous pouvez appliquer GELU comme module autonome ou en ligne dans la définition du modèle. Voici un bloc feedforward simple utilisant GELU :

import torch
import torch.nn as nn

class FeedForwardBlock(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.act = nn.GELU()
        self.fc2 = nn.Linear(hidden_dim, input_dim)

    def forward(self, x):
        return self.fc2(self.act(self.fc1(x)))

block = FeedForwardBlock(input_dim=512, hidden_dim=2048)
x = torch.randn(8, 512)
output = block(x)

nn.GELU() est placée entre les deux couches linéaires, exactement là où on la trouve dans la sous-couche feedforward d’un transformer. L’activation s’exécute après la première projection et avant la seconde.

TensorFlow

Dans TensorFlow, GELU est disponible via l’API Keras :

import tensorflow as tf
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(2048, input_shape=(512,)),
    keras.layers.Activation("gelu"),
    keras.layers.Dense(512)
])

x = tf.random.normal((8, 512))
output = model(x)

Vous pouvez aussi la passer directement en argument chaîne de caractères à une couche Dense :

keras.layers.Dense(2048, activation="gelu")

Les deux approches produisent le même résultat.

Où placer GELU dans un réseau

GELU se place comme toute autre fonction d’activation : juste après une transformation linéaire et avant la couche suivante. Dans les transformers, cela signifie dans la sous-couche feedforward, entre les deux projections denses. Dans d’autres réseaux profonds, placez-la après votre couche linéaire ou convolutionnelle, pour mettre à l’échelle la sortie avant de la propager.

Avantages de GELU

Si vous êtes encore là, vous connaissez les principaux atouts de GELU par rapport aux autres fonctions d’activation. Voici un bref récapitulatif :

• Activation lisse : GELU produit une courbe continue et différentiable, sans transitions brusques, offrant à l’optimiseur des informations plus propres à chaque étape.
• Meilleur flux de gradients : GELU ne met pas à zéro les entrées négatives, les gradients peuvent donc encore se propager à travers les neurones recevant des valeurs négatives. Cela réduit le risque de neurones « morts » à l’entraînement.
• Meilleures performances dans les modèles profonds : Dans des architectures profondes comme les transformers, l’effet cumulatif de gradients plus lisses se traduit souvent par de meilleurs résultats d’entraînement par rapport à des fonctions plus simples.

Limites de GELU

GELU n’est pas le bon choix dans toutes les situations. Voici quelques limites à garder en tête :

• Coût de calcul supérieur à ReLU : GELU implique soit la fonction d’erreur, soit une approximation basée sur tanh, toutes deux plus coûteuses que le simple seuil de ReLU. Dans les grands modèles à nombreuses couches, cela peut peser.

• Moins intuitive : Des fonctions comme ReLU sont faciles à raisonner : les positives passent, les négatives non. L’atténuation probabiliste de GELU est plus difficile à interpréter.

• Pas toujours nécessaire : Pour des réseaux peu profonds ou des tâches simples, GELU n’offre pas forcément d’avantages marquants. ReLU ou Leaky ReLU donneront souvent des performances similaires pour un coût moindre.

En conclusion, si vous construisez un transformer ou une autre architecture profonde, GELU est un excellent choix par défaut. Sinon, comparez avant de vous engager.

Conclusion

GELU n’est pas une amélioration universelle ni une solution passe-partout remplaçant ReLU. C’est un choix de conception réfléchi, pertinent dans des contextes précis — réseaux profonds et modèles de type transformer.

Si vous travaillez avec BERT, GPT ou tout modèle basé sur des transformers, vous utilisez déjà GELU — consciemment ou non. Vous savez désormais pourquoi.

Pour le reste, le choix de la fonction d’activation est une affaire de compromis. Aucune fonction ne gagne à tous les coups, et comprendre le rôle de chacune vous permet de décider en connaissance de cause plutôt que par habitude.

Si vous trouvez encore les différences entre fonctions d’activation déroutantes, inscrivez-vous à notre Machine Learning Engineer Track pour être prêt pour une carrière en machine learning et MLOps.