update

Author: L1aoXingyu

chapter4_CNN/alexnet.py

@@ -0,0 +1,34 @@
+from torch import nn
+
+
+class AlexNet(nn.Module):
+    def __init__(self, num_classes):
+        super(AlexNet, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            nn.Conv2d(64, 192, kernel_size=5, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            nn.Conv2d(192, 384, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(384, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2), )
+        self.classifier = nn.Sequential(
+            nn.Dropout(),
+            nn.Linear(256 * 6 * 6, 4096),
+            nn.ReLU(inplace=True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(inplace=True),
+            nn.Linear(4096, num_classes), )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), 256 * 6 * 6)
+        x = self.classifier(x)
+        return x

chapter4_CNN/lenet.py

@@ -24,5 +24,6 @@ def __init__(self):
     def forward(self, x):
         x = self.layer1(x)
         x = self.layer2(x)
+        x = x.view(x.size(0), -1)
         x = self.layer3(x)
         return x

chapter4_CNN/net_structure.py

@@ -49,11 +49,14 @@ def forward(self, x):
 
 conv_model = nn.Sequential()
 for layer in model.named_modules():
-    if 'conv' in layer[0]:
+    if isinstance(layer[1], nn.Conv2d):
         conv_model.add_module(layer[0], layer[1])
 
-for param in model.named_parameters():
-    if 'conv' in param[0] and 'weight' in param[0]:
-        init.normal(param[1].data)
-        init.xavier_normal(param[1].data)
-        init.kaiming_normal(param[1].data)
+for m in model.modules():
+    if isinstance(m, nn.Conv2d):
+        init.normal(m.weight.data)
+        init.xavier_normal(m.weight.data)
+        init.kaiming_normal(m.weight.data)
+        m.bias.data.fill_(0)
+    elif isinstance(m, nn.Linear):
+        m.weight.data.normal_()

chapter4_CNN/vgg.py

@@ -0,0 +1,52 @@
+from torch import nn
+
+
+class VGG(nn.Module):
+    def __init__(self, num_classes):
+        super(VGG, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(128, 256, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(256, 512, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.Conv2d(512, 512, kernel_size=3, padding=1),
+            nn.ReLU(True),
+            nn.MaxPool2d(kernel_size=2, stride=2), )
+        self.classifier = nn.Sequential(
+            nn.Linear(512 * 7 * 7, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(True),
+            nn.Dropout(),
+            nn.Linear(4096, num_classes), )
+        self._initialize_weights()
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)