PyTorch torch.nn.AdaptiveAvgPool2d Funktion
PyTorch torch.nn Referenzhandbuch
torch.nn.AdaptiveAvgPool2dEs ist das adaptive Average-Pooling-Modul in PyTorch.
Es kann Eingabe-Feature-Maps beliebiger Größe auf eine angegebene Zielgröße poolen, ohne kernel_size und stride manuell berechnen zu müssen.
Funktionsdefinition
torch.nn.AdaptiveAvgPool2d(output_size)
Parameterbeschreibung:
output_size(int oder tuple): Ausgabegröße. Kann (H, W) oder ein einzelner int (quadratisch) sein.
Anwendungsbeispiele
Beispiel 1: Grundlegende Verwendung
Die Feature-Map auf eine feste Größe poolen:
Beispiel
import torch
import torch.nn as nn
# auf 1x1 poolen
adaptive_pool = nn.AdaptiveAvgPool2d(1)
# Eingabe unterschiedlicher Größen
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("nAlle Ausgaben werden auf 1x1 gepoolt")
import torch.nn as nn
# auf 1x1 poolen
adaptive_pool = nn.AdaptiveAvgPool2d(1)
# Eingabe unterschiedlicher Größen
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("nAlle Ausgaben werden auf 1x1 gepoolt")
Beispiel 2: Beliebige Ausgabengröße
Auf nicht-quadratische Größe poolen:
Beispiel
import torch
import torch.nn as nn
# auf 4x4 poolen
pool = nn.AdaptiveAvgPool2d((4, 4))
x = torch.randn(2, 128, 32, 32)
out = pool(x)
print("Eingabeform:", x.shape)
print("Ausgabeform:", out.shape) # (2, 128, 4, 4)
# auf 1x7 poolen (kann für Sequenzen verwendet werden)
pool_seq = nn.AdaptiveAvgPool2d((1, 7))
x_seq = torch.randn(2, 64, 10, 20)
out_seq = pool_seq(x_seq)
print("nSequenz-Pooling:", x_seq.shape, "->", out_seq.shape)
import torch.nn as nn
# auf 4x4 poolen
pool = nn.AdaptiveAvgPool2d((4, 4))
x = torch.randn(2, 128, 32, 32)
out = pool(x)
print("Eingabeform:", x.shape)
print("Ausgabeform:", out.shape) # (2, 128, 4, 4)
# auf 1x7 poolen (kann für Sequenzen verwendet werden)
pool_seq = nn.AdaptiveAvgPool2d((1, 7))
x_seq = torch.randn(2, 64, 10, 20)
out_seq = pool_seq(x_seq)
print("nSequenz-Pooling:", x_seq.shape, "->", out_seq.shape)
Beispiel 3: Verwendung in CNN
Typisches globales Average-Pooling:
Beispiel
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),
)
# globales Average-Pooling
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("Eingabeform:", x.shape)
print("Ausgabeform:", output.shape)
print("nDie Feature-Map wird global zu einem einzelnen Vektor gepoolt")
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),
)
# globales Average-Pooling
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("Eingabeform:", x.shape)
print("Ausgabeform:", output.shape)
print("nDie Feature-Map wird global zu einem einzelnen Vektor gepoolt")
Beispiel 4: Vergleich mit regulärem Pooling
Beispiel
import torch
import torch.nn as nn
# adaptives Pooling vs. reguläres Pooling
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("Eingabe:", x.shape)
print("Adaptives Pooling (Ausgabe 2x2):", out_adaptive.shape)
print("Reguläres Average-Pooling (16x16):", out_regular.shape)
import torch.nn as nn
# adaptives Pooling vs. reguläres Pooling
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("Eingabe:", x.shape)
print("Adaptives Pooling (Ausgabe 2x2):", out_adaptive.shape)
print("Reguläres Average-Pooling (16x16):", out_regular.shape)
Adaptives Pooling vs. reguläres Pooling
| Type | Vorteile | Geeignete Szenarien |
|---|---|---|
| AdaptiveAvgPool | Beliebige Eingabegröße | Eingaben unterschiedlicher Skalierung |
| AvgPool | Schnellere Berechnung | Feste Eingabegröße |
Häufig gestellte Fragen
F1: Wann sollte adaptives Pooling verwendet werden?
Wenn die Eingabegröße nicht fest ist oder wenn sie auf eine feste Größe vereinheitlicht werden muss.
F2: Was ist Global Average Pooling?
AdaptiveAvgPool2d(1), das jede Feature-Map zu einem einzelnen Wert poolt.
Anwendungsfälle
- Klassifikationsnetze: Global Average Pooling ersetzt FC-Schichten
- Multi-Scale-Eingaben: An Bilder unterschiedlicher Größe anpassen
- Feature-Aggregation: Wichtige Informationen extrahieren
Tipp: Global Average Pooling kann die Anzahl der Parameter erheblich reduzieren.
Andere Erweiterungen