Fonction torch.nn.Dropout de PyTorch
Manuel de référence torch.nn de PyTorch
torch.nn.DropoutIl s'agit d'un module de PyTorch utilisé pour la régularisation.
Il évite le surapprentissage en mettant aléatoirement à zéro des éléments d'entrée afin de réduire la co-adaptation entre les neurones.
Définition de fonction
torch.nn.Dropout(p=0.5, inplace=False)
Description des paramètres :
p(float) : Probabilité que chaque élément soit mis à zéro. Valeur par défaut : 0.5.inplace(bool) : s'il faut effectuer l'opération en place. Valeur par défaut : False.
Exemples d'utilisation
Exemple 1 : Utilisation de base
Créer et utiliser une couche Dropout :
Exemple
import torch.nn as nn
# Créer une couche Dropout avec une probabilité de dropout de 0.5
dropout = nn.Dropout(p=0.5)
# Mode d'entraînement (Dropout actif)
dropout.train()
# Créer une entrée
input_tensor = torch.ones(1, 10)
print("Entrée :", input_tensor.squeeze().tolist())
# Effectuer plusieurs fois la passe avant, observer le caractère aléatoire
for i in range(3):
output = dropout(input_tensor)
print(f"Sortie {i+1} :", output.squeeze().tolist())
On peut voir qu'environ la moitié des éléments sont mis à zéro de manière aléatoire à chaque appel.
Exemple 2 : mode entraînement vs mode évaluation
Dropout se comporte différemment pendant l'entraînement et l'évaluation :
Exemple
import torch.nn as nn
dropout = nn.Dropout(p=0.5)
# Mode entraînement
dropout.train()
train_output = dropout(torch.ones(4, 10))
print("Mode entraînement - taux d'activation :", (train_output != 0).float().mean().item())
# Mode évaluation
dropout.eval()
eval_output = dropout(torch.ones(4, 10))
print("Mode évaluation - taux d'activation :", (eval_output != 0).float().mean().item())
print("Sortie en mode évaluation :", eval_output[0].tolist())
Pendant l'évaluation, Dropout n'a aucun effet et la sortie reste inchangée.
Exemple 3 : Utilisation dans les réseaux de neurones
Un réseau entièrement connecté typique avec Dropout :
Exemple
import torch.nn as nn
class DropoutNet(nn.Module):
def __init__(self, input_dim=784, hidden_dim=256, output_dim=10, dropout_rate=0.5):
super(DropoutNet, self).__init__()
self.fc1 = nn.Linear(input_dim, hidden_dim)
self.dropout1 = nn.Dropout(p=dropout_rate)
self.fc2 = nn.Linear(hidden_dim, hidden_dim)
self.dropout2 = nn.Dropout(p=dropout_rate)
self.fc3 = nn.Linear(hidden_dim, output_dim)
self.relu = nn.ReLU()
def forward(self, x):
x = self.relu(self.fc1(x))
x = self.dropout1(x) # Premier Dropout
x = self.relu(self.fc2(x))
x = self.dropout2(x) # Deuxième Dropout
x = self.fc3(x)
return x
model = DropoutNet()
# Mode entraînement
model.train()
input_data = torch.randn(32, 784)
output = model(input_data)
print("Forme de sortie en mode entraînement :", output.shape)
# Mode évaluation
model.eval()
output = model(input_data)
print("Forme de sortie en mode évaluation :", output.shape)
Exemple 4 : Utilisation de Dropout2d dans un CNN
nn.Dropout2dSupprimer des cartes de caractéristiques entières par canal :
Exemple
import torch.nn as nn
# Dropout2d supprime par canal
dropout2d = nn.Dropout2d(p=0.5)
# Entrée : batch=1, canaux=4, hauteur=4, largeur=4
input_tensor = torch.ones(1, 4, 4, 4)
dropout2d.train()
output = dropout2d(input_tensor)
print("Forme de sortie de Dropout2d :", output.shape)
print("Nombre de canaux non nuls :", (output.sum(dim=(2, 3)) != 0).sum().item())
Exemple 5 : Effets de différents taux de dropout
L'effet du taux de dropout sur le réseau :
Exemple
import torch.nn as nn
for p in [0.1, 0.3, 0.5, 0.7]:
dropout = nn.Dropout(p=p)
dropout.train()
# Moyenne sur plusieurs exécutions
total_active = 0
for _ in range(100):
output = dropout(torch.ones(1000))
total_active += (output != 0).float().sum().item()
avg_active = total_active / 100 / 1000
print(f"p={p} - taux d'activation moyen : {avg_active:.2%} (attendu : {1-p:.2%})")
Comparaison des types de dropout
| Type | Méthode de dropout | Scénarios applicables |
|---|---|---|
nn.Dropout |
Mettre à zéro aléatoirement des éléments individuels | Couches entièrement connectées, vecteurs de caractéristiques |
nn.Dropout2d |
Mettre aléatoirement à zéro des canaux entiers | Cartes de caractéristiques de la couche convolutionnelle |
nn.Dropout3d |
Mettre aléatoirement à zéro des canaux 3D entiers | Caractéristiques convolutionnelles 3D |
FAQ
Q1 : Comment choisir le taux de Dropout ?
- 0.1-0.3 : régularisation plus légère, adaptée aux grands ensembles de données
- 0.4-0.5 : valeurs par défaut courantes
- 0.5+ : régularisation plus forte, adaptée aux petits ensembles de données
Q2 : Où faut-il placer le Dropout ?
Généralement placé après la couche entièrement connectée et après la fonction d'activation. Il peut aussi être placé avant la fonction d'activation.
Q3 : Dois-je désactiver le Dropout pendant l'évaluation ?
Oui, lors de l'évaluation, utilisez `model.eval()`model.eval()pour désactiver automatiquement Dropout.
Cas d'utilisation
nn.DropoutLes principaux cas d'utilisation incluent :
- Prévenir le surapprentissage: Réduire la dépendance entre les neurones
- Ensemble de modèles: Approximer l'effet de plusieurs réseaux
- Couches entièrement connectées: Le plus couramment utilisé dans les couches FC
- Dropout de caractéristiques: Améliorer la robustesse du modèle
Remarque : Dropout est activé pendant l'entraînement ; pendant l'évaluation, assurez-vous de passer en mode eval, sinon la sortie sera instable.
Autres extensions