GeGLU

Définition

GeGLU (Gated Linear Unit with GELU activation) est une variante des fonctions d'activation pour les couches Feed-Forward Network (FFN) des Transformers, proposee par Noam Shazeer (Google, 2020). Elle remplace la simple projection lineaire suivi d'une activation (comme ReLU ou GELU) par une operation 'gated' : la sortie est le produit element-wise d'une branche lineaire et d'une branche activee par GELU. La formule GeGLU : GeGLU(x, W, V, b, c) = GELU(xW + b) * (xV + c), ou deux projections lineaires independantes (W et V) sont apprises, et leurs outputs sont multiplies element-wise apres application de GELU sur l'une d'elles. SwiGLU est la variante avec Swish a la place de GELU, legerement favorisee experimentalement. L'avantage des activations gated : elles permettent au reseau de 'controler' dynamiquement quelles informations passent au travers de la couche FFN. La porte (gate) apprend a selectionner les features pertinentes, ameliorant la capacite du modele a tout niveau de perplexite par rapport aux activations simples. LLaMA 2 et LLaMA 3 utilisent SwiGLU (tres proche de GeGLU) dans leurs couches FFN avec une dimension intermediaire de 4 * 2/3 * d_model (au lieu de 4 * d_model pour les FFN standard) pour maintenir un budget de parametres equivalent. Mistral, Gemma, Phi-3 utilisent egalement SwiGLU. C'est devenu le standard de facto pour les LLMs modernes. En termes de performance, GeGLU/SwiGLU surpassent ReLU et GELU standard de maniere consistante : des gains de 0.5-1% de perplexite sont typiquement observes sur les datasets de pre-entrainement, ce qui se traduit par de meilleures performances sur les benchmarks en aval. Le cout supplementaire (une projection lineaire additionnelle par couche FFN) est minimal en termes de compute.

Implementation GeGLU vs GELU

import torch
import torch.nn as nn
import torch.nn.functional as F

class StandardFFN(nn.Module):
    def __init__(self, d_model, d_ff):
        super().__init__()
        self.w1 = nn.Linear(d_model, d_ff)
        self.w2 = nn.Linear(d_ff, d_model)
    def forward(self, x):
        return self.w2(F.gelu(self.w1(x)))

class GeGLUFFN(nn.Module):
    def __init__(self, d_model, d_ff):
        super().__init__()
        # Note: 2 projections pour la gate mechanism
        self.w1 = nn.Linear(d_model, d_ff)  # Gate
        self.v = nn.Linear(d_model, d_ff)   # Value
        self.w2 = nn.Linear(d_ff, d_model)  # Output
    def forward(self, x):
        return self.w2(F.gelu(self.w1(x)) * self.v(x))  # Gated!

Activations gated dans les LLMs

Activation	Formule	Modeles
ReLU	max(0, x)	GPT-2, GPT-3
GELU	x * phi(x)	BERT, GPT-J
SwiGLU	Swish(xW) * xV	LLaMA 2/3, Mistral
GeGLU	GELU(xW) * xV	Gemma, PaLM

Articles liés

Expert en cybersécurité offensive et intelligence artificielle. Pentest, audit et développement IA sur-mesure.

Services

Ressources

Projets & Outils

Contact

Nous contacter

Mentions légales Confidentialité Politique éditoriale Plan du site ⭐ Source préférée

Un projet cybersécurité ?

Expert dispo · Réponse 24h

Devis