Wir beginnen unsere Implementierung mit der Faltungsblockstruktur, die auf alle 5 Blöcke verallgemeinert werden kann. Dies kann Modularität ermöglichen und eine Wiederverwendung bei der Implementierung der gesamten Alex Internet-Architektur ermöglichen. Dies reduziert die Codeduplizierung.
class AlexNetBlock(nn.Module):
def __init__(
self,
in_channels,
out_channels,
kernel_size,
stride,
padding,
pool_and_norm: bool = True
) -> None:tremendous(AlexNetBlock, self).__init__()
self.conv_layer = nn.Conv2d(
in_channels, out_channels, kernel_size, stride, padding)
self.relu = nn.ReLU()
self.pool_and_norm = pool_and_norm
if pool_and_norm:
self.norm_layer = nn.LocalResponseNorm(
measurement=5, alpha=0.0001, beta=0.75, ok=2)
self.pool_layer = nn.MaxPool2d(stride=2, kernel_size=3)
def ahead(self, x):
x = self.conv_layer(x)
x = self.relu(x)
if self.pool_and_norm:
x = self.norm_layer(x)
x = self.pool_layer(x)
return x
Der Code ist selbsterklärend, wobei wir Parameter für die Faltungsschicht erhalten. Darüber hinaus verwenden wir einen booleschen Wert pool_and_norm, der für Block 3 und Block 4 auf False gesetzt wird. Der obige Block kann in der gesamten Alex Internet-Architektur verwendet werden.
Der folgende Code zeigt das vollständige Alex Internet-Modell, das den obigen Block verwendet.
class AlexNet(nn.Module):
def __init__(self, num_classes, in_channels) -> None:
tremendous(AlexNet, self).__init__()self.block1 = AlexNetBlock(
in_channels, 96, 11, 4, 0, pool_and_norm=True)
self.block2 = AlexNetBlock(96, 256, 5, 1, 2, pool_and_norm=True)
self.block3 = AlexNetBlock(256, 384, 3, 1, 1, pool_and_norm=False)
self.block4 = AlexNetBlock(384, 384, 3, 1, 1, pool_and_norm=False)
self.block5 = AlexNetBlock(384, 256, 3, 1, 1, pool_and_norm=True)
self.flatten = nn.Flatten()
self.fc1 = nn.Linear(256 * 6 * 6, 4096)
self.dropout1 = nn.Dropout(0.5)
self.fc2 = nn.Linear(4096, 4096)
self.dropout2 = nn.Dropout(0.5)
self.classification_layer = nn.Linear(4096, num_classes)
def ahead(self, x):
x = self.block1(x)
x = self.block2(x)
x = self.block3(x)
x = self.block4(x)
x = self.block5(x)
x = self.flatten(x)
x = self.fc1(x)
x = self.dropout1(x)
x = self.fc2(x)
x = self.dropout2(x)
x = self.classification_layer(x)
return x
Gemäß dem Flussdiagramm erstellen wir 5 Alex Internet-Blöcke mit der beschriebenen Konfiguration. Anschließend durchlaufen wir die Eingabe nacheinander durch alle Schichten, bis wir ein eindimensionales Array erhalten, das die Wahrscheinlichkeit jeder möglichen Klasse darstellt.
Für diesen speziellen Fall benötigen wir zwei Initialisierungsparameter für AlexNet. Einer davon sind Eingangskanäle, die für RGB-Bilder standardmäßig drei sind. Die zweite ist die Gesamtzahl der Klassen, die unsere Ausgabegröße definiert. In der Arbeit wurde für die Picture Internet-Aufgabe der Wert 1000 verwendet. Für meine Implementierung verwende ich den CIFAR-10-Datensatz, additionally setze ich ihn auf zehn.
Das folgende Bild fasst die Alex Internet-Architektur zusammen.
