Debugging

lib/models/homotopy_classification/cnn_based.py

@@ -1,3 +1,6 @@
+from functools import reduce
+from operator import mul
+
 import torch
 from torch import nn
 import torch.nn.functional as F
@@ -13,7 +16,7 @@ class ConvHomDetector(LightningBaseModule):
     name = 'CNNHomotopyClassifier'
 
     def configure_optimizers(self):
-        return Adam(self.parameters(), lr=self.lr)
+        return Adam(self.parameters(), lr=self.hparams.lr)
 
     def validation_step(self, *args, **kwargs):
         pass
@@ -32,29 +35,36 @@ class ConvHomDetector(LightningBaseModule):
 
     def __init__(self, *params):
         super(ConvHomDetector, self).__init__(*params)
+
         # Dataset
-        self.dataset = TrajData(self.hparams.data_param.data_root)
+        self.dataset = TrajData(self.hparams.data_param.root)
 
         # Additional Attributes
         self.map_shape = self.dataset.map_shapes_max
 
+        # Model Paramters
+        self.in_shape = self.dataset.map_shapes_max
+        assert len(self.in_shape) == 3, f'Image or map shape has to have 3 dims, but had: {len(self.in_shape)}'
+
         # NN Nodes
         # ============================
         # Convolutional Map Processing
         #
-        self.map_res_1 = ResidualModule(self.in_shape, ConvModule, 3,
+        self.map_conv_0 = ConvModule(self.in_shape, conv_kernel=3, conv_stride=1,
+                                     conv_padding=0, conv_filters=self.hparams.model_param.filters[0])
+        self.map_res_1 = ResidualModule(self.map_conv_0.shape, ConvModule, 3,
                                         **dict(conv_kernel=3, conv_stride=1,
-                                               conv_padding=0, conv_filters=self.hparams.model_param.filters[0]))
+                                               conv_padding=1, conv_filters=self.hparams.model_param.filters[0]))
         self.map_conv_1 = ConvModule(self.map_res_1.shape, conv_kernel=5, conv_stride=1,
                                      conv_padding=0, conv_filters=self.hparams.model_param.filters[0])
         self.map_res_2 = ResidualModule(self.map_conv_1.shape, ConvModule, 3,
                                         **dict(conv_kernel=3, conv_stride=1,
-                                               conv_padding=0, conv_filters=self.hparams.model_param.filters[0]))
+                                               conv_padding=1, conv_filters=self.hparams.model_param.filters[0]))
         self.map_conv_2 = ConvModule(self.map_res_2.shape, conv_kernel=5, conv_stride=1,
                                      conv_padding=0, conv_filters=self.hparams.model_param.filters[0])
         self.map_res_3 = ResidualModule(self.map_conv_2.shape, ConvModule, 3,
                                         **dict(conv_kernel=3, conv_stride=1,
-                                               conv_padding=0, conv_filters=self.hparams.model_param.filters[0]))
+                                               conv_padding=1, conv_filters=self.hparams.model_param.filters[0]))
         self.map_conv_3 = ConvModule(self.map_res_3.shape, conv_kernel=5, conv_stride=1,
                                      conv_padding=0, conv_filters=self.hparams.model_param.filters[0])
 
@@ -64,12 +74,13 @@ class ConvHomDetector(LightningBaseModule):
         # Classifier
         #
 
-        self.linear = nn.Linear(self.flatten.shape.item(), self.hparams.model_param.classes * 10)
-        self.classifier = nn.Linear(self.linear.shape, self.hparams.model_param.classes)
+        self.linear = nn.Linear(reduce(mul, self.flatten.shape), self.hparams.model_param.classes * 10)
+        self.classifier = nn.Linear(self.hparams.model_param.classes * 10, self.hparams.model_param.classes)
         self.softmax = nn.Softmax()
 
     def forward(self, x):
-        tensor = self.map_res_1(x)
+        tensor = self.map_conv_0(x)
+        tensor = self.map_res_1(tensor)
         tensor = self.map_conv_1(tensor)
         tensor = self.map_res_2(tensor)
         tensor = self.map_conv_2(tensor)