import time
import argparse
+
from colorama import Fore, Back, Style
import torch
help = 'How many samples for test')
parser.add_argument('--nb_epochs',
- type = int, default = 25,
+ type = int, default = 50,
help = 'How many training epochs')
parser.add_argument('--log_file',
log_file = open(args.log_file, 'w')
-print('Logging into ' + args.log_file)
+print(Fore.RED + 'Logging into ' + args.log_file + Style.RESET_ALL)
def log_string(s):
- s = Fore.GREEN + time.ctime() + Style.RESET_ALL + ' ' + \
- str(problem_number) + ' ' + s
+ s = Fore.GREEN + time.ctime() + Style.RESET_ALL + ' ' + s
log_file.write(s + '\n')
log_file.flush()
print(s)
######################################################################
-# 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
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()
######################################################################
+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)
nb_train_errors = nb_errors(model, train_input, train_target)
- log_string('TRAIN_ERROR {:.02f}% {:d} {:d}'.format(
+ 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))