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.))