Fonction PyTorch torch.nn.AdaptiveAvgPool2d
Manuel de référence torch.nn de PyTorch
torch.nn.AdaptiveAvgPool2dIl s'agit du module de pooling moyen adaptatif dans PyTorch.
Il peut appliquer un pooling sur des cartes de caractéristiques d'entrée de n'importe quelle taille vers une taille cible spécifiée sans calculer manuellement kernel_size et stride.
Définition de fonction
torch.nn.AdaptiveAvgPool2d(output_size)
Description des paramètres :
output_size(int ou tuple) : taille de sortie. Peut être (H, W) ou un seul int (carré).
Exemples d'utilisation
Exemple 1 : Utilisation de base
Appliquez le pooling sur la carte de caractéristiques pour obtenir une taille fixe :
Exemple
import torch
import torch.nn as nn
# pooling vers 1x1
adaptive_pool = nn.AdaptiveAvgPool2d(1)
# entrées de tailles différentes
x1 = torch.randn(1, 64, 32, 32)
x2 = torch.randn(1, 64, 16, 16)
x3 = torch.randn(1, 64, 8, 8)
out1 = adaptive_pool(x1)
out2 = adaptive_pool(x2)
out3 = adaptive_pool(x3)
print("32x32 ->", out1.shape)
print("16x16 ->", out2.shape)
print("8x8 ->", out3.shape)
print("nToutes les sorties sont regroupées en 1x1")
import torch.nn as nn
# pooling vers 1x1
adaptive_pool = nn.AdaptiveAvgPool2d(1)
# entrées de tailles différentes
x1 = torch.randn(1, 64, 32, 32)
x2 = torch.randn(1, 64, 16, 16)
x3 = torch.randn(1, 64, 8, 8)
out1 = adaptive_pool(x1)
out2 = adaptive_pool(x2)
out3 = adaptive_pool(x3)
print("32x32 ->", out1.shape)
print("16x16 ->", out2.shape)
print("8x8 ->", out3.shape)
print("nToutes les sorties sont regroupées en 1x1")
Exemple 2 : Sortie de taille arbitraire
Pooling vers non-carré :
Exemple
import torch
import torch.nn as nn
# pooling vers 4x4
pool = nn.AdaptiveAvgPool2d((4, 4))
x = torch.randn(2, 128, 32, 32)
out = pool(x)
print("Forme d'entrée :", x.shape)
print("Forme de sortie :", out.shape) # (2, 128, 4, 4)
# pooling vers 1x7 (peut être utilisé pour les séquences)
pool_seq = nn.AdaptiveAvgPool2d((1, 7))
x_seq = torch.randn(2, 64, 10, 20)
out_seq = pool_seq(x_seq)
print("nAgrégation de séquence :", x_seq.shape, "->", out_seq.shape)
import torch.nn as nn
# pooling vers 4x4
pool = nn.AdaptiveAvgPool2d((4, 4))
x = torch.randn(2, 128, 32, 32)
out = pool(x)
print("Forme d'entrée :", x.shape)
print("Forme de sortie :", out.shape) # (2, 128, 4, 4)
# pooling vers 1x7 (peut être utilisé pour les séquences)
pool_seq = nn.AdaptiveAvgPool2d((1, 7))
x_seq = torch.randn(2, 64, 10, 20)
out_seq = pool_seq(x_seq)
print("nAgrégation de séquence :", x_seq.shape, "->", out_seq.shape)
Exemple 3 : Utilisation dans un CNN
Agrégation moyenne globale typique :
Exemple
import torch
import torch.nn as nn
class CNNWithGAP(nn.Module):
def __init__(self, num_classes=10):
super(CNNWithGAP, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(128, 256, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
)
# agrégation moyenne globale
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.classifier = nn.Linear(256, num_classes)
def forward(self, x):
x = self.features(x)
x = self.avgpool(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
model = CNNWithGAP()
x = torch.randn(4, 3, 32, 32)
output = model(x)
print("Forme d'entrée :", x.shape)
print("Forme de sortie :", output.shape)
print("nLa carte de caractéristiques est agrégée globalement en un seul vecteur")
import torch.nn as nn
class CNNWithGAP(nn.Module):
def __init__(self, num_classes=10):
super(CNNWithGAP, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(128, 256, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
)
# agrégation moyenne globale
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.classifier = nn.Linear(256, num_classes)
def forward(self, x):
x = self.features(x)
x = self.avgpool(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
model = CNNWithGAP()
x = torch.randn(4, 3, 32, 32)
output = model(x)
print("Forme d'entrée :", x.shape)
print("Forme de sortie :", output.shape)
print("nLa carte de caractéristiques est agrégée globalement en un seul vecteur")
Exemple 4 : comparaison avec le pooling régulier
Exemple
import torch
import torch.nn as nn
# pooling adaptatif vs pooling régulier
adaptive = nn.AdaptiveAvgPool2d(2)
regular = nn.AvgPool2d(kernel_size=16, stride=16)
x = torch.randn(1, 64, 32, 32)
out_adaptive = adaptive(x)
out_regular = regular(x)
print("Entrée :", x.shape)
print("Pooling adaptatif (sortie 2x2) :", out_adaptive.shape)
print("Pooling moyen régulier (16x16) :", out_regular.shape)
import torch.nn as nn
# pooling adaptatif vs pooling régulier
adaptive = nn.AdaptiveAvgPool2d(2)
regular = nn.AvgPool2d(kernel_size=16, stride=16)
x = torch.randn(1, 64, 32, 32)
out_adaptive = adaptive(x)
out_regular = regular(x)
print("Entrée :", x.shape)
print("Pooling adaptatif (sortie 2x2) :", out_adaptive.shape)
print("Pooling moyen régulier (16x16) :", out_regular.shape)
Pooling adaptatif vs pooling régulier
| Type | Avantages | Scénarios applicables |
|---|---|---|
| AdaptiveAvgPool | Taille d'entrée arbitraire | Entrées de différentes échelles |
| AvgPool | Calcul plus rapide | Taille d'entrée fixe |
Questions fréquentes
Q1 : Quand utiliser le pooling adaptatif ?
Lorsque la taille d'entrée n'est pas fixe, ou lorsqu'elle doit être unifiée à une taille fixe.
Q2 : Qu'est-ce que le Global Average Pooling ?
AdaptiveAvgPool2d(1), qui regroupe chaque carte de caractéristiques en une seule valeur.
Cas d'utilisation
- Réseaux de classification: le Global Average Pooling remplace les couches FC
- Entrées multi-échelles: s'adapter à des images de différentes tailles
- Agrégation de caractéristiques: extraire les informations clés
Astuce : le Global Average Pooling peut réduire considérablement le nombre de paramètres.
Autres extensions