test_sup_learn_data = SupLearningData()
try:
exit_code = 1
if args.cmd == 'train':
# call the do_this class method
if (args.input_data_file_format == 'fann'):
"""
Test with FANN's building data set, 14 inputs and 3 outputs
"""
# fann_training_data = 'datasets/fann/building.train'
# fann_test_data = 'datasets/fann/building.test'
fann_training_data = 'datasets/fann/mushroom.train'
fann_test_data = 'datasets/fann/mushroom.test'
sup_learn_data = SupLearningData()
num_entries, num_input_fields, num_output_fields, input_matrix, output_matrix = sup_learn_data.read_fann_data(fann_training_data)
log.info('input_matrix has %d rows and %d cols', len(input_matrix), len(input_matrix[0]))
log.info('output_matrix has %d rows and %d cols', len(output_matrix), len(output_matrix[0]))
X_train = np.array(input_matrix)
y_train = np.array(output_matrix)
num_entries, num_input_fields, num_output_fields, input_matrix, output_matrix = sup_learn_data.read_fann_data(fann_test_data)
X_val = np.array(input_matrix)
y_val = np.array(output_matrix)
data = [(X_train, y_train), (X_val, y_val)]
do_mlp(dataset=data, n_hidden=[12, 12, 6], mean_loss_threshold=0.001, batch_size=1)
elif (args.input_data_file_format == 'jsonz'):
"""
Test with image data
"""
jsonz_training_data = '/home/hemkenhg/workspace/theano/examples/image_data/enlarge_center_2x-8-1k-train-a.jsonz'
break
end_time = timeit.default_timer()
print(
(
'Optimization complete with best validation score of %f %%, '
'obtained at iteration %i, '
'with test performance %f %%'
) % (best_validation_loss * 100., best_iter + 1, test_score * 100.)
)
print >> sys.stderr, ('The fine tuning code for file ' +
os.path.split(__file__)[1] +
' ran for %.2fm' % ((end_time - start_time)
/ 60.))
if __name__ == '__main__':
sup_learn_data = SupLearningData()
num_entries, num_input_fields, num_output_fields, input_matrix, output_matrix = sup_learn_data.read_fann_data('datasets/fann/mushroom.train')
X_train = numpy.array(input_matrix)
y_train = numpy.array(output_matrix)
num_entries, num_input_fields, num_output_fields, input_matrix, output_matrix = sup_learn_data.read_fann_data('datasets/fann/mushroom.test')
X_val = numpy.array(input_matrix)
y_val = numpy.array(output_matrix)
datasets = [(X_train, y_train), (X_val, y_val)]
test_DBN(datasets=datasets,
n_ins=num_input_fields,
n_outs=num_output_fields,
hidden_layers_sizes=[32, 32, 32])
def test_DBN(finetune_lr=0.1, pretraining_epochs=100,
pretrain_lr=0.01, k=1, training_epochs=1000,
dataset='mnist.pkl.gz', batch_size=10):
"""
Demonstrates how to train and test a Deep Belief Network.
This is demonstrated on MNIST.
:type finetune_lr: float
:param finetune_lr: learning rate used in the finetune stage
:type pretraining_epochs: int
:param pretraining_epochs: number of epoch to do pretraining
:type pretrain_lr: float
:param pretrain_lr: learning rate to be used during pre-training
:type k: int
:param k: number of Gibbs steps in CD/PCD
:type training_epochs: int
:param training_epochs: maximal number of iterations ot run the optimizer
:type dataset: string
:param dataset: path the the pickled dataset
:type batch_size: int
:param batch_size: the size of a minibatch
"""
examples = SupLearningData()
num_train_examples, num_train_inputs, num_train_outputs, train_input_data, train_output_data = examples.read_file_data('datasets/mnist/mnist_train.jsonz')
train_set_x, train_set_y = examples.convert_data_to_theano_shared(train_input_data, train_output_data)
datasets = load_data(dataset)
# train_set_x, train_set_y = datasets[0]
valid_set_x, valid_set_y = datasets[1]
test_set_x, test_set_y = datasets[2]
# compute number of minibatches for training, validation and testing
n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size
# numpy random generator
numpy_rng = numpy.random.RandomState(123)
print '... building the model'
# construct the Deep Belief Network
dbn = DBN(numpy_rng=numpy_rng, n_ins=28 * 28,
hidden_layers_sizes=[1000, 1000, 1000],
n_outs=10)
# start-snippet-2
#########################
# PRETRAINING THE MODEL #
#########################
print '... getting the pretraining functions'
pretraining_fns = dbn.pretraining_functions(train_set_x=train_set_x,
batch_size=batch_size,
k=k)
print '... pre-training the model'
start_time = timeit.default_timer()
## Pre-train layer-wise
for i in range(dbn.n_layers):
# go through pretraining epochs
for epoch in range(pretraining_epochs):
# go through the training set
c = []
for batch_index in range(n_train_batches):
c.append(pretraining_fns[i](index=batch_index,
lr=pretrain_lr))
print 'Pre-training layer %i, epoch %d, cost ' % (i, epoch),
print numpy.mean(c)
end_time = timeit.default_timer()
# end-snippet-2
print >> sys.stderr, ('The pretraining code for file ' +
os.path.split(__file__)[1] +
' ran for %.2fm' % ((end_time - start_time) / 60.))
########################
# FINETUNING THE MODEL #
########################
# get the training, validation and testing function for the model
print '... getting the finetuning functions'
train_fn, validate_model, test_model = dbn.build_finetune_functions(
datasets=datasets,
batch_size=batch_size,
learning_rate=finetune_lr
)
print '... finetuning the model'
# early-stopping parameters
patience = 4 * n_train_batches # look as this many examples regardless
patience_increase = 2. # wait this much longer when a new best is
# found
improvement_threshold = 0.995 # a relative improvement of this much is
# considered significant
validation_frequency = min(n_train_batches, patience / 2)
# go through this many
# minibatches before checking the network
# on the validation set; in this case we
# check every epoch
best_validation_loss = numpy.inf
test_score = 0.
start_time = timeit.default_timer()
done_looping = False
epoch = 0
while (epoch < training_epochs) and (not done_looping):
epoch = epoch + 1
for minibatch_index in range(n_train_batches):
minibatch_avg_cost = train_fn(minibatch_index)
iter = (epoch - 1) * n_train_batches + minibatch_index
if (iter + 1) % validation_frequency == 0:
validation_losses = validate_model()
this_validation_loss = numpy.mean(validation_losses)
print(
'epoch %i, minibatch %i/%i, validation error %f %%'
% (
epoch,
minibatch_index + 1,
n_train_batches,
this_validation_loss * 100.
)
)
# if we got the best validation score until now
if this_validation_loss < best_validation_loss:
#improve patience if loss improvement is good enough
if (
this_validation_loss < best_validation_loss *
improvement_threshold
):
patience = max(patience, iter * patience_increase)
# save best validation score and iteration number
best_validation_loss = this_validation_loss
best_iter = iter
# test it on the test set
test_losses = test_model()
test_score = numpy.mean(test_losses)
print((' epoch %i, minibatch %i/%i, test error of '
'best model %f %%') %
(epoch, minibatch_index + 1, n_train_batches,
test_score * 100.))
if patience <= iter:
done_looping = True
break
end_time = timeit.default_timer()
print(
(
'Optimization complete with best validation score of %f %%, '
'obtained at iteration %i, '
'with test performance %f %%'
) % (best_validation_loss * 100., best_iter + 1, test_score * 100.)
)
print >> sys.stderr, ('The fine tuning code for file ' +
os.path.split(__file__)[1] +
' ran for %.2fm' % ((end_time - start_time)
/ 60.))
