Fonction torch.nn.GELU de PyTorch
Manuel de référence torch.nn de PyTorch
torch.nn.GELUIl s'agit de la fonction d'activation Gaussian Error Linear Unit dans PyTorch.
C'est la fonction d'activation par défaut de l'architecture Transformer, avec de meilleures performances et des gradients plus lisses par rapport à ReLU.
Définition de fonction
torch.nn.GELU(approximate='none')
Description des paramètres :
approximate(str) : Algorithme d'approximation. Optionnel'none'、'tanh'. Valeur par défaut :'none'。
Principe mathématique
La formule mathématique de GELU :
GELU(x) = x * Φ(x)
où Φ(x) est la fonction de répartition (CDF) de la loi normale standard.
Lors de l'utilisation de l'approximation tanh :
GELU(x) ≈ 0.5x * (1 + tanh(√(2/π) * (x + 0.044715 * x³)))
Exemples d'utilisation
Exemple 1 : Utilisation de base
Créer et utiliser l'activation GELU :
Exemple
import torch.nn as nn
# Créer une couche d'activation GELU
gelu = nn.GELU()
# Entrée de test
x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
# Passe avant
output = gelu(x)
print("Input:", x.tolist())
print("Sortie :", output.tolist())
print("nObservation : les valeurs négatives ont une légère activation (non nulle), les valeurs positives continuent de croître")
Exemple 2 : Comparaison de différentes fonctions d'activation
Comparez GELU, ReLU, Sigmoid :
Exemple
import torch.nn as nn
x = torch.linspace(-4, 4, 21)
# Différentes fonctions d'activation
gelu = nn.GELU()
relu = nn.ReLU()
sigmoid = nn.Sigmoid()
tanh = nn.Tanh()
print("x GELU ReLU Sigmoid Tanh")
print("-" * 50)
for i in range(0, 21, 3):
xi = x[i:i+3]
print(f"{xi[0]:6.2f} {gelu(xi)[0]:8.4f} {relu(xi)[0]:8.4f} {sigmoid(xi)[0]:8.4f} {tanh(xi)[0]:8.4f}")
Exemple 3 : Utilisation dans un Transformer
Couche FFN typique d'un Transformer :
import torch.nn as nn
class FeedForward(nn.Module):
def __init__(self, d_model, dim_feedforward=2048, dropout=0.1):
super(FeedForward, self).__init__()
self.linear1 = nn.Linear(d_model, dim_feedforward)
self.dropout = nn.Dropout(dropout)
self.activation = nn.GELU()
self.linear2 = nn.Linear(dim_feedforward, d_model)
def forward(self, x):
x = self.linear1(x)
x = self.activation(x)
x = self.dropout(x)
x = self.linear2(x)
return x
# Test du FFN
ffn = FeedForward(d_model=512, dim_feedforward=2048)
x = torch.randn(32, 100, 512) # (batch, seq, d_model)
output = ffn(x)
print("Forme d'entrée :", x.shape)
print("Forme de sortie :", output.shape)
Exemple 4 : Utilisation de l'approximation tanh
Utilisez l'approximation tanh pour accélérer le calcul :
Exemple
import torch.nn as nn
# Version exacte
gelu_exact = nn.GELU(approximate='none')
# Version d'approximation tanh
gelu_approx = nn.GELU(approximate='tanh')
x = torch.randn(1000)
output_exact = gelu_exact(x)
output_approx = gelu_approx(x)
# Calculer la différence
diff = (output_exact - output_approx).abs().max().item()
print(f"Différence max: {diff:.8f}")
# Comparaison des performances
import time
for _ in range(100):
_ = gelu_exact(x)
start = time.time()
for _ in range(1000):
_ = gelu_exact(x)
time_exact = time.time() - start
start = time.time()
for _ in range(1000):
_ = gelu_approx(x)
time_approx = time.time() - début
print(f"Temps de la version exacte : {time_exact:.4f}s")
print(f"Temps de la version approximative : {time_approx:.4f}s")
Comparaison des fonctions d'activation
| Fonction d'activation | Fonctionnalités | Scénarios applicables |
|---|---|---|
nn.GELU |
Lisse, valeurs négatives non nulles, valeur par défaut de Transformer | Transformer、BERT、GPT |
nn.ReLU |
Simple, activation parcimonieuse, neurones morts | CNN, apprentissage profond général |
nn.SiLU |
Lisse, auto-verrouillage | MobileNet、EfficientNet |
Questions courantes
Q1 : Quels sont les avantages de GELU par rapport à ReLU ?
- Les valeurs négatives ont une légère activation, l'information n'est pas perdue
- Des gradients plus lisses, utiles pour l'entraînement
- Meilleures performances dans les Transformers
Q2 : Quand utiliser la version approximative ?
Lorsque la vitesse d'inférence est requise et que les exigences de précision ne sont pas strictes, l'approximation tanh est plus rapide.
Q3 : GELU peut-il être utilisé dans la couche de sortie ?
Généralement non utilisé dans la couche de sortie. Utilisez Softmax pour les tâches de classification et la fonction identité pour les tâches de régression.
Cas d'utilisation
nn.GELULes principaux scénarios d'application incluent :
- Architecture Transformer: des modèles tels que BERT, GPT
- Réseaux de neurones profonds: situations nécessitant une activation lisse
- Modèles pré-entraînés: modèles NLP modernes
Astuce : GELU est la fonction d'activation la plus couramment utilisée dans le domaine du NLP et est un équipement standard pour Transformer.
Autres extensions