X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?p=pysvrt.git;a=blobdiff_plain;f=cnn-svrt.py;h=5dc91c82e66e99322ee77ec95e6e8c4b337dcdff;hp=c7e0585abd009c5efb26913ee214ac74ec22eb41;hb=15f2d2cf0a655234cfa435789e26238b95f5a371;hpb=b7c9b813a879742e1a2ac359c46c0fb6335455cf

diff --git a/cnn-svrt.py b/cnn-svrt.py
index c7e0585..5dc91c8 100755
--- a/cnn-svrt.py
+++ b/cnn-svrt.py
@@ -45,36 +45,31 @@ from vignette_set import VignetteSet, CompressedVignetteSet
 ######################################################################
 
 parser = argparse.ArgumentParser(
-    description = 'Simple convnet test on the SVRT.',
+    description = "Convolutional networks for the SVRT. Written by Francois Fleuret, (C) Idiap research institute.",
     formatter_class = argparse.ArgumentDefaultsHelpFormatter
 )
 
-parser.add_argument('--nb_train_batches',
-                    type = int, default = 1000,
-                    help = 'How many samples for train')
+parser.add_argument('--nb_train_samples',
+                    type = int, default = 100000)
 
-parser.add_argument('--nb_test_batches',
-                    type = int, default = 100,
-                    help = 'How many samples for test')
+parser.add_argument('--nb_test_samples',
+                    type = int, default = 10000)
 
 parser.add_argument('--nb_epochs',
-                    type = int, default = 50,
-                    help = 'How many training epochs')
+                    type = int, default = 50)
 
 parser.add_argument('--batch_size',
-                    type = int, default = 100,
-                    help = 'Mini-batch size')
+                    type = int, default = 100)
 
 parser.add_argument('--log_file',
-                    type = str, default = 'default.log',
-                    help = 'Log file name')
+                    type = str, default = 'default.log')
 
 parser.add_argument('--compress_vignettes',
-                    action='store_true', default = False,
+                    action='store_true', default = True,
                     help = 'Use lossless compression to reduce the memory footprint')
 
 parser.add_argument('--deep_model',
-                    action='store_true', default = False,
+                    action='store_true', default = True,
                     help = 'Use Afroze\'s Alexnet-like deep model')
 
 parser.add_argument('--test_loaded_models',
@@ -104,10 +99,10 @@ def log_string(s, remark = ''):
 
     pred_log_t = t
 
-    s = Fore.BLUE + '[' + time.ctime() + '] ' + Fore.GREEN + elapsed + Style.RESET_ALL + ' ' + s
-    log_file.write(s + '\n')
+    log_file.write('[' + time.ctime() + '] ' + elapsed + ' ' + s + '\n')
     log_file.flush()
-    print(s + Fore.CYAN + remark + Style.RESET_ALL)
+
+    print(Fore.BLUE + '[' + time.ctime() + '] ' + Fore.GREEN + elapsed + Style.RESET_ALL + ' ' + s + Fore.CYAN + remark + Style.RESET_ALL)
 
 ######################################################################
 
@@ -259,6 +254,20 @@ for arg in vars(args):
 
 ######################################################################
 
+def int_to_suffix(n):
+    if n > 1000000 and n%1000000 == 0:
+        return str(n//1000000) + 'M'
+    elif n > 1000 and n%1000 == 0:
+        return str(n//1000) + 'K'
+    else:
+        return str(n)
+
+######################################################################
+
+if args.nb_train_samples%args.batch_size > 0 or args.nb_test_samples%args.batch_size > 0:
+    print('The number of samples must be a multiple of the batch size.')
+    raise
+
 for problem_number in range(1, 24):
 
     log_string('**** problem ' + str(problem_number) + ' ****')
@@ -273,7 +282,7 @@ for problem_number in range(1, 24):
 
     model_filename = model.name + '_' + \
                      str(problem_number) + '_' + \
-                     str(args.nb_train_batches) + '.param'
+                     int_to_suffix(args.nb_train_samples) + '.param'
 
     nb_parameters = 0
     for p in model.parameters(): nb_parameters += p.numel()
@@ -294,14 +303,16 @@ for problem_number in range(1, 24):
 
         if args.compress_vignettes:
             train_set = CompressedVignetteSet(problem_number,
-                                              args.nb_train_batches, args.batch_size,
-                                              cuda=torch.cuda.is_available())
+                                              args.nb_train_samples, args.batch_size,
+                                              cuda = torch.cuda.is_available())
         else:
             train_set = VignetteSet(problem_number,
-                                    args.nb_train_batches, args.batch_size,
-                                    cuda=torch.cuda.is_available())
+                                    args.nb_train_samples, args.batch_size,
+                                    cuda = torch.cuda.is_available())
 
-        log_string('data_generation {:0.2f} samples / s'.format(train_set.nb_samples / (time.time() - t)))
+        log_string('data_generation {:0.2f} samples / s'.format(
+            train_set.nb_samples / (time.time() - t))
+        )
 
         train_model(model, train_set)
         torch.save(model.state_dict(), model_filename)
@@ -322,14 +333,16 @@ for problem_number in range(1, 24):
 
         if args.compress_vignettes:
             test_set = CompressedVignetteSet(problem_number,
-                                             args.nb_test_batches, args.batch_size,
-                                             cuda=torch.cuda.is_available())
+                                             args.nb_test_samples, args.batch_size,
+                                             cuda = torch.cuda.is_available())
         else:
             test_set = VignetteSet(problem_number,
-                                   args.nb_test_batches, args.batch_size,
-                                   cuda=torch.cuda.is_available())
+                                   args.nb_test_samples, args.batch_size,
+                                   cuda = torch.cuda.is_available())
 
-        log_string('data_generation {:0.2f} samples / s'.format(test_set.nb_samples / (time.time() - t)))
+        log_string('data_generation {:0.2f} samples / s'.format(
+            test_set.nb_samples / (time.time() - t))
+        )
 
         nb_test_errors = nb_errors(model, test_set)