def __init__(self, **kwargs):
"""Initialization.
Args:
debug (kwargs): boolean indicating debug mode
"""
self.debug = Debug("debug" in kwargs and kwargs["debug"])
self.graph = []
def __init__(self, **kwargs):
self.debug = Debug("debug" in kwargs and kwargs["debug"])
self.graph = []
def MLP():
np.random.seed(13141)
debug_mode = False
dbg = Debug(debug_mode)
parser = argparse.ArgumentParser(
description='Train and test neural network on cifar dataset.')
parser.add_argument('experiment_name',
help='used for outputting log files')
parser.add_argument('--num_hidden_units',
type=int,
help='number of hidden units')
parser.add_argument('--learning_rate',
type=float,
help='learning rate for solver')
parser.add_argument('--momentum_mu',
type=float,
help='mu for momentum solver')
parser.add_argument('--mini_batch_size', type=int, help='mini batch size')
parser.add_argument('--num_epoch', type=int, help='number of epochs')
args = parser.parse_args()
experiment_name = args.experiment_name
iter_log_file = "logs/{0}_iter_log.txt".format(experiment_name)
epoch_log_file = "logs/{0}_epoch_log.txt".format(experiment_name)
print
timer.begin("dataset")
DATASET_PATH = 'cifar-2class-py2/cifar_2class_py2.p'
data = CifarDataset()
data.load(DATASET_PATH)
num_training = data.get_num_train()
num_test = data.get_num_test()
input_dim = data.get_data_dim()
num_hidden_units = 50 if args.num_hidden_units is None else args.num_hidden_units
learning_rate = 0.01 if args.learning_rate is None else args.learning_rate
momentum_mu = 0.6 if args.momentum_mu is None else args.momentum_mu
mini_batch_size = 64 if args.mini_batch_size is None else args.mini_batch_size
num_epoch = (500 if not debug_mode else
1) if args.num_epoch is None else args.num_epoch
print("num_hidden_units: {0}".format(num_hidden_units))
print("learning_rate: {0}".format(learning_rate))
print("momentum_mu: {0}".format(momentum_mu))
print("mini_batch_size: {0}".format(mini_batch_size))
print("num_epoch: {0}".format(num_epoch))
net = Sequential(debug=debug_mode)
net.add(LinearLayer(input_dim, num_hidden_units))
net.add(ReluLayer())
net.add(LinearLayer(num_hidden_units, 2))
net.add(SoftMaxLayer())
print("{0}\n".format(net))
loss = CrossEntropyLoss()
training_objective = Objective(loss)
test_objective = Objective(loss)
errorRate = ErrorRate()
print("Loss function: {0}\n".format(loss))
solver = MomentumSolver(lr=learning_rate, mu=momentum_mu)
monitor = Monitor()
monitor.createSession(iter_log_file, epoch_log_file)
cum_iter = 0
for epoch in range(num_epoch):
print("Training epoch {0}...".format(epoch))
timer.begin("epoch")
for iter, batch in enumerate(data.get_train_batches(
mini_batch_size)): #BATCHES ARE FORMED HERE
if iter > 1 and debug_mode:
break
timer.begin("iter")
(x, target) = batch
batch_size = x.shape[2]
z = net.forward(x)
dbg.disp("\toutput: {0}".format(z))
dbg.disp("\toutput shape: {0}".format(z.shape))
if debug_mode:
l = loss.forward(z, target)
dbg.disp("\tloss: {0}".format(l))
dbg.disp("\tloss shape: {0}".format(l.shape))
gradients = loss.backward(z, target)
dbg.disp("\tgradients: {0}".format(gradients))
dbg.disp("\tgradients shape: {0}".format(gradients.shape))
grad_x = net.backward(x, gradients)
dbg.disp("\tgrad_x: {0}".format(grad_x))
dbg.disp("\tgrad_x: {0}".format(grad_x.shape))
net.updateParams(solver)
loss_avg = training_objective.compute(z, target)
elapsed = timer.getElapsed("iter")
print("\t[iter {0}]\tloss: {1}\telapsed: {2}".format(
iter, loss_avg, elapsed))
monitor.recordIteration(cum_iter, loss_avg, elapsed)
cum_iter += 1
target = data.get_test_labels()
x = data.get_test_data()
output = net.forward(x) #forward_layer
loss_avg_test = test_objective.compute(output, target)
error_rate_test = errorRate.compute(output, target) #100 % - ACCURACY
target = data.get_train_labels()
x = data.get_train_data()
output = net.forward(x) #forward_layer
loss_avg_train = training_objective.compute(output, target)
error_rate_train = errorRate.compute(output, target) #100 % - ACCURACY
elapsed = timer.getElapsed("epoch")
print(
"End of epoch:\ttest objective: {0}\ttrain objective: {1}".format(
loss_avg_test, loss_avg_train))
print("\t\ttest error rate: {0}\ttrain error rate: {1}".format(
error_rate_test, error_rate_train))
print("Finished epoch {1} in {0:2f}s.\n".format(elapsed, epoch))
monitor.recordEpoch(epoch, loss_avg_train, loss_avg_test,
error_rate_train, error_rate_test, elapsed)
monitor.finishSession()
