def test_sql():
log = Log("Smoketest",
"no data",
{'zen':"perspective",'nothing':"everything"}
)
log.result(100,{})
return "OK"
def test_SdA(args):
"""
Demonstrates how to train and test a stochastic denoising autoencoder.
This is demonstrated on MNIST.
:type learning_rate: float
:param learning_rate: learning rate used in the finetune stage
(factor for the stochastic gradient)
: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 n_iter: int
:param n_iter: maximal number of iterations ot run the optimizer
:type dataset: string
:param dataset: path the the pickled dataset
"""
finetune_lr = args.get('finetune_lr',0.1, type=float)
pretraining_epochs = args.get('pretraining_epochs', 15, type=int)
pretrain_lr = args.get('pretrain_lr', 0.001, type=float)
training_epochs = args.get('training_epochs', 1000, type=int)
n_ins = math.pow(args.get('n_ins', 28, type=int),2)
hidden_layer_size = args.get('hidden_layer_size', 1000, type=int)
n_outs = args.get('n_outs', 10, type=int)
dataset='mnist.pkl.gz'
batch_size=1
log = Log("SdA",
dataset,
args
)
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]
n_train_batches /= batch_size
# numpy random generator
# start-snippet-3
numpy_rng = numpy.random.RandomState(89677)
log.trace('... building the model')
# construct the stacked denoising autoencoder class
sda = SdA(
numpy_rng = numpy_rng,
n_ins = n_ins,
hidden_layers_sizes = [hidden_layer_size, hidden_layer_size, hidden_layer_size],
n_outs = n_outs
)
# end-snippet-3 start-snippet-4
#########################
# PRETRAINING THE MODEL #
#########################
log.trace('... getting the pretraining functions')
pretraining_fns = sda.pretraining_functions(train_set_x=train_set_x,
batch_size=batch_size)
log.trace('... pre-training the model')
start_time = timeit.default_timer()
## Pre-train layer-wise
corruption_levels = [.1, .2, .3]
for i in xrange(sda.n_layers):
# go through pretraining epochs
for epoch in xrange(pretraining_epochs):
# go through the training set
c = []
for batch_index in xrange(n_train_batches):
c.append(pretraining_fns[i](index=batch_index,
corruption=corruption_levels[i],
lr=pretrain_lr))
log.trace('Pre-training layer %i, epoch %d, cost ' % (i, epoch))
log.trace(numpy.mean(c))
end_time = timeit.default_timer()
log.trace('The pretraining code for file ' +
os.path.split(__file__)[1] +
' ran for %.2fm' % ((end_time - start_time) / 60.))
# end-snippet-4
########################
# FINETUNING THE MODEL #
########################
# get the training, validation and testing function for the model
log.trace('... getting the finetuning functions')
train_fn, validate_model, test_model = sda.build_finetune_functions(
datasets=datasets,
batch_size=batch_size,
learning_rate=finetune_lr
)
log.trace('... finetunning the model')
# early-stopping parameters
patience = 10 * 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
# minibatche 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 xrange(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)
log.trace('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)
log(test_score, {epoch:epoch, minibatch_index:minibatch_index})
log.trace(('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()
# log.trace(
# (
# 'Optimization complete with best validation score of %f %%, '
# 'on iteration %i, '
# 'with test performance %f %%'
# )
# % (best_validation_loss * 100., best_iter + 1, test_score * 100.)
# )
log.trace('The training code for file ' +
os.path.split(__file__)[1] +
' ran for %.2fm' % ((end_time - start_time) / 60.))
