Minor fixes + changed the default number of epochs to 100.

[pysvrt.git] / cnn-svrt.py

diff --git a/cnn-svrt.py b/cnn-svrt.py
index 755d1c7..96fb498 100755 (executable)
--- a/cnn-svrt.py
+++ b/cnn-svrt.py
@@ -24,6 +24,8 @@
 import time
 import argparse
 
+from colorama import Fore, Back, Style
+
 import torch
 
 from torch import optim
@@ -51,17 +53,23 @@ parser.add_argument('--nb_test_samples',
                     help = 'How many samples for test')
 
 parser.add_argument('--nb_epochs',
-                    type = int, default = 25,
+                    type = int, default = 100,
                     help = 'How many training epochs')
 
+parser.add_argument('--log_file',
+                    type = str, default = 'cnn-svrt.log',
+                    help = 'Log file name')
+
 args = parser.parse_args()
 
 ######################################################################
 
-log_file = open('cnn-svrt.log', 'w')
+log_file = open(args.log_file, 'w')
+
+print(Fore.RED + 'Logging into ' + args.log_file + Style.RESET_ALL)
 
 def log_string(s):
-    s = time.ctime() + ' ' + str(problem_number) + ' | ' + s
+    s = Fore.GREEN + time.ctime() + Style.RESET_ALL + ' ' + s
     log_file.write(s + '\n')
     log_file.flush()
     print(s)
@@ -70,26 +78,43 @@ def log_string(s):
 
 def generate_set(p, n):
     target = torch.LongTensor(n).bernoulli_(0.5)
+    t = time.time()
     input = svrt.generate_vignettes(p, target)
+    t = time.time() - t
+    log_string('DATA_SET_GENERATION {:.02f} sample/s'.format(n / t))
     input = input.view(input.size(0), 1, input.size(1), input.size(2)).float()
     return Variable(input), Variable(target)
 
 ######################################################################
 
-# 128x128 --conv(9)-> 120x120 --max(4)-> 30x30 --conv(6)-> 25x25 --max(5)-> 5x5
+# Afroze's ShallowNet
+
+#                       map size   nb. maps
+#                     ----------------------
+#    input                128x128    1
+# -- conv(21x21 x 6)   -> 108x108    6
+# -- max(2x2)          -> 54x54      6
+# -- conv(19x19 x 16)  -> 36x36      16
+# -- max(2x2)          -> 18x18      16
+# -- conv(18x18 x 120) -> 1x1        120
+# -- reshape           -> 120        1
+# -- full(120x84)      -> 84         1
+# -- full(84x2)        -> 2          1
 
 class Net(nn.Module):
     def __init__(self):
         super(Net, self).__init__()
-        self.conv1 = nn.Conv2d(1, 10, kernel_size=9)
-        self.conv2 = nn.Conv2d(10, 20, kernel_size=6)
-        self.fc1 = nn.Linear(500, 100)
-        self.fc2 = nn.Linear(100, 2)
+        self.conv1 = nn.Conv2d(1, 6, kernel_size=21)
+        self.conv2 = nn.Conv2d(6, 16, kernel_size=19)
+        self.conv3 = nn.Conv2d(16, 120, kernel_size=18)
+        self.fc1 = nn.Linear(120, 84)
+        self.fc2 = nn.Linear(84, 2)
 
     def forward(self, x):
-        x = fn.relu(fn.max_pool2d(self.conv1(x), kernel_size=4, stride=4))
-        x = fn.relu(fn.max_pool2d(self.conv2(x), kernel_size=5, stride=5))
-        x = x.view(-1, 500)
+        x = fn.relu(fn.max_pool2d(self.conv1(x), kernel_size=2))
+        x = fn.relu(fn.max_pool2d(self.conv2(x), kernel_size=2))
+        x = fn.relu(self.conv3(x))
+        x = x.view(-1, 120)
         x = fn.relu(self.fc1(x))
         x = self.fc2(x)
         return x
@@ -97,11 +122,16 @@ class Net(nn.Module):
 def train_model(train_input, train_target):
     model, criterion = Net(), nn.CrossEntropyLoss()
 
+    nb_parameters = 0
+    for p in model.parameters():
+        nb_parameters += p.numel()
+    log_string('NB_PARAMETERS {:d}'.format(nb_parameters))
+
     if torch.cuda.is_available():
         model.cuda()
         criterion.cuda()
 
-    optimizer, bs = optim.SGD(model.parameters(), lr = 1e-1), 100
+    optimizer, bs = optim.SGD(model.parameters(), lr = 1e-2), 100
 
     for k in range(0, args.nb_epochs):
         acc_loss = 0.0
@@ -133,6 +163,9 @@ def nb_errors(model, data_input, data_target, bs = 100):
 
 ######################################################################
 
+for arg in vars(args):
+    log_string('ARGUMENT ' + str(arg) + ' ' + str(getattr(args, arg)))
+
 for problem_number in range(1, 24):
     train_input, train_target = generate_set(problem_number, args.nb_train_samples)
     test_input, test_target = generate_set(problem_number, args.nb_test_samples)
@@ -147,9 +180,19 @@ for problem_number in range(1, 24):
 
     model = train_model(train_input, train_target)
 
+    nb_train_errors = nb_errors(model, train_input, train_target)
+
+    log_string('TRAIN_ERROR {:d} {:.02f}% {:d} {:d}'.format(
+        problem_number,
+        100 * nb_train_errors / train_input.size(0),
+        nb_train_errors,
+        train_input.size(0))
+    )
+
     nb_test_errors = nb_errors(model, test_input, test_target)
 
-    log_string('TEST_ERROR {:.02f}% ({:d}/{:d})'.format(
+    log_string('TEST_ERROR {:d} {:.02f}% {:d} {:d}'.format(
+        problem_number,
         100 * nb_test_errors / test_input.size(0),
         nb_test_errors,
         test_input.size(0))