def run_mnist_training(batch_size, epochs, lr, log_interval, device, file):
test_batch_size = 1000
accuracy = []
acc = 0
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3981, ))])
train_set = datasets.MNIST('../data',
train=True,
download=True,
transform=transform)
test_set = datasets.MNIST('../data', train=False, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=batch_size)
test_loader = torch.utils.data.DataLoader(test_set,
batch_size=test_batch_size)
PATH = './models/MNISTandSVHN/MNIST.pth'
model = M_Network().to(device)
optimizer = optim.SGD(model.parameters(), lr=lr)
#Training the model
for epoch in range(1, epochs + 1):
accuracy.append(
train(log_interval, model, device, train_loader, optimizer, epoch))
torch.save(model.state_dict(), PATH)
#Generating Confusion Matrix for test
_, true, pred = test(model, device, test_loader)
cm = confusion_matrix(true, pred)
names = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')
plt.figure(figsize=(10, 10))
plot_confusion_matrix(cm, names, t='MNIST Confusion Matrix')
f1 = f1_score(true, pred, average='micro')
acc = accuracy_score(true, pred)
#Write test acc to file
file1 = open(file, "a")
write_string = "MNIST Accuracy: " + str(acc) + "\t F1: " + str(f1) + "\n"
file1.write(write_string)
file1.close()
#Plotting ROC
plot_roc(model,
device,
test_loader,
num_classes=10,
t='MNIST ROC',
mode='single')
return accuracy
num_ftrs = model_conv.fc.in_features
model_conv.fc = nn.Linear(num_ftrs, nb_classes)
if torch.cuda.is_available():
model_conv = model_conv.cuda()
loss_fn = nn.CrossEntropyLoss().type(dtype)
# Observe that only parameters of final layer are being optimized as
# opoosed to before.
optimizer_conv = optim.Adam(model_conv.fc.parameters(), lr=1e-3)
train_acc = []
val_acc = []
results = train(model_conv, loss_fn, optimizer_conv, loader_train, loader_val, num_epochs = 5)
resultfile1 = write_results(results)
resultfile1.to_csv(os.path.join(os.path.curdir, resultfilename1))
test_accuracy = check_accuracy(model_conv, loader_test)
print('Test accuracy after training last layer: {}'.format(test_accuracy))
# now we allow all of the network to change, but by less
for param in model_conv.parameters():
param.requires_grad = True
optimizer_conv = optim.Adam(model_conv.parameters(), lr=1e-10)
results = train(model_conv, loss_fn, optimizer_conv, loader_train, loader_val, num_epochs = 1)
tensor_trainY = torch.Tensor(trainY)
train_dataset = TensorDataset(tensor_trainX, tensor_trainY) # create your datset
train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE)
model = get_current_model()
model = model.to(device)
print('model', model)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
optimizer_name = "Adam"
print("Beginning to train")
#(train_dataloader, model, loss_fn, optimzer, epochs, device)
loss_history, accuracy_history = help.train(train_dataloader, model, loss_fn, optimizer, EPOCHS, device)
model_filepath = 'saved_models/cnn_1.pt'
torch.save(model.state_dict(), model_filepath)
best_loss = round(min(loss_history), 3)
best_acc = round(max(accuracy_history), 3)
#print(f"Best training accuracy: {best_acc}")
acc_filename = f"plots/training_accuracy_cnn_1.png"
help.plot_history(accuracy_history, 'accuracy', acc_filename)
loss_filename = f"plots/training_loss_cnn_1.png"
help.plot_history(loss_history, 'loss', loss_filename)
print('Beginning to test')
tensor_testX = torch.Tensor(testX)
def run_svhn_training(batch_size, epochs, lr, log_interval, device, file):
accuracy = []
acc = 0
transform = transforms.Compose(
[transforms.CenterCrop((28, 28)),
transforms.ToTensor()])
train_set = datasets.SVHN('../data',
split='train',
transform=transform,
target_transform=None,
download=False)
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=batch_size,
shuffle=True)
test_set = datasets.SVHN('../data',
split='test',
transform=transform,
target_transform=None,
download=False)
test_loader = torch.utils.data.DataLoader(test_set,
batch_size=batch_size,
shuffle=True)
model = S_Network().to(device)
optimizer = optim.SGD(model.parameters(), lr=lr)
for epoch in range(1, epochs + 1):
accuracy.append(
train(log_interval, model, device, train_loader, optimizer, epoch))
PATH = './models/MNISTandSVHN/SVHN.pth'
torch.save(model.state_dict(), PATH)
#Generating Confusion Matrix for test
_, true, pred = test(model, device, test_loader)
cm = confusion_matrix(true, pred)
names = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')
plt.figure(figsize=(10, 10))
plot_confusion_matrix(cm, names, t='SVHN Confusion Matrix')
f1 = f1_score(true, pred, average='micro')
acc = accuracy_score(true, pred)
#Write test acc to file
file1 = open(file, "a")
write_string = "SVHN Accuracy: " + str(acc) + "\t F1: " + str(f1) + "\n"
file1.write(write_string)
file1.close()
#Plotting ROC
plot_roc(model,
device,
test_loader,
num_classes=10,
t='SVHN ROC',
mode='single')
return accuracy
help='image for transformation or viewing',
metavar='IMAGE_PATH')
parser.add_argument('-o',
type=str,
dest='image_output_path',
help='image output path',
metavar='IMAGE_OUTPUT_PATH')
parser.add_argument('--iters',
type=int,
dest='iters',
help='iter times, only for temp_view mode',
metavar='ITER_TIMES',
default=500)
return parser
if __name__ == '__main__':
parser = build_parser()
args = parser.parse_args()
with open(args.config_path) as f_config:
options = json.load(f_config)
if args.mode == 'train':
train(options)
elif args.mode == 'predict':
predict(options, args.image_path, args.image_output_path)
elif args.mode == 'temp_view':
temp_view(options, args.image_path, args.image_output_path, args.iters)