Deep paper resnet

Author: lpdon

config.yml

@@ -1,7 +1,7 @@
 data : "ORAND-CAR-2014/CAR-A/"
 train_val_split: 0.8
 epochs: 1500
-batch_size: 8
+batch_size: 32
 lr : 1.0e-4
 verbose: True
 log: train_log.txt

model.py

@@ -5,6 +5,26 @@
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
 
+class ResBlock(nn.Module):
+    def __init__(self, input_channels, output_channels):
+        super(ResBlock, self).__init__()
+
+        self.conv1 = nn.Conv2d(in_channels=input_channels, out_channels=output_channels, kernel_size=3, padding=1, stride=2)
+        self.bn1 = nn.BatchNorm2d(output_channels)
+        self.conv2 = nn.Conv2d(in_channels=output_channels, out_channels=output_channels, kernel_size=3, padding=1, stride=1)
+        self.bn2 = nn.BatchNorm2d(output_channels)
+        self.res_conv = nn.Conv2d(in_channels=input_channels, out_channels=output_channels, kernel_size=1, padding=0, stride=2)
+        self.bn_res = nn.BatchNorm2d(output_channels)
+
+    def forward(self, x):
+        res = x
+        x = F.relu(self.bn1(self.conv1(x)))
+        x = self.bn2(self.conv2(x))
+        x = F.relu(x.add(self.bn_res(self.res_conv(res))))
+
+        return x
+
+
 class StringNet(nn.Module):
     def __init__(self, n_classes, seq_length, batch_size):
         """
@@ -18,7 +38,7 @@ def __init__(self, n_classes, seq_length, batch_size):
         self.batch_size = batch_size
         self.hidden_dim = 100
         self.bidirectional = True
-        self.lstm_layers = 1
+        self.lstm_layers = 2
 
         self.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=5, padding=1, stride=1)
         self.bn1 = nn.BatchNorm2d(64)
@@ -29,29 +49,17 @@ def __init__(self, n_classes, seq_length, batch_size):
         self.conv3 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1, stride=1)
         self.bn3 = nn.BatchNorm2d(64)
 
-        self.conv4 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1, stride=2)
-        self.bn4 = nn.BatchNorm2d(128)
-        self.conv5 = nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, padding=1, stride=1)
-        self.bn5 = nn.BatchNorm2d(128)
-        self.res_conv1 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=1, padding=0, stride=2)
-        self.bn_res1 = nn.BatchNorm2d(128)
-
-        self.conv6 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, padding=1, stride=2)
-        self.bn6 = nn.BatchNorm2d(256)
-        self.conv7 = nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, padding=1, stride=1)
-        self.bn7 = nn.BatchNorm2d(256)
-        self.res_conv2 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=1, padding=0, stride=2)
-        self.bn_res2 = nn.BatchNorm2d(256)
-
-        self.conv8 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=1, stride=2)
-        self.bn8 = nn.BatchNorm2d(512)
-        self.conv9 = nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, padding=1, stride=1)
-        self.bn9 = nn.BatchNorm2d(512)
-        self.res_conv3 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=1, padding=0, stride=2)
-        self.bn_res3 = nn.BatchNorm2d(512)
-
-        self.lstm = nn.LSTM(227328, self.hidden_dim, num_layers=self.lstm_layers, bias=True,
-                            bidirectional=self.bidirectional)
+        self.res_block1 = ResBlock(64, 128)
+        self.res_block2 = ResBlock(128, 128)
+
+        self.res_block3 = ResBlock(128, 256)
+        self.res_block4 = ResBlock(256, 256)
+
+        self.res_block5 = ResBlock(256, 512)
+        self.res_block6 = ResBlock(512, 512)
+
+        self.lstm = nn.LSTM(5120, self.hidden_dim, num_layers=self.lstm_layers, bias=True,
+                            bidirectional=self.bidirectional, dropout=0.5)
 
         self.fc2 = nn.Linear(self.hidden_dim * self.directions, n_classes)
         # self.fc2 = nn.Linear(self.hidden_dim, n_classes)
@@ -76,17 +84,14 @@ def forward(self, x):
         x = self.bn3(self.conv3(x))
         x = sum1 = F.relu(x.add(res1))        
 
-        x = F.relu(self.bn4(self.conv4(x)))
-        x = self.bn5(self.conv5(x))
-        x = sum2 = F.relu(x.add(self.bn_res1(self.res_conv1(sum1))))
+        x = self.res_block1(x)
+        x = self.res_block2(x)
 
-        x = F.relu(self.bn6(self.conv6(x)))
-        x = self.bn7(self.conv7(x))
-        x = sum3 = F.relu(x.add(self.bn_res2(self.res_conv2(sum2))))
+        x = self.res_block3(x)
+        x = self.res_block4(x)
 
-        x = F.relu(self.bn8(self.conv8(x)))
-        x = self.bn9(self.conv9(x))
-        x = F.relu(x.add(self.bn_res3(self.res_conv3(sum3))))
+        x = self.res_block5(x)
+        x = self.res_block6(x)
 
         x = x.view(x.size(0), -1)  # flatten