def _net_experiment_tlstm_helper(json_file, model_file,
data_triplet, wbm, num_reps,
num_hidden_layers, num_hidden_units, use_hinge, proj_type):
nn = _make_tlstm_net(data_triplet.training_data, wbm,
data_triplet.output_dimensions()[0], num_hidden_layers,
num_hidden_units, use_hinge, proj_type)
start_time = timeit.default_timer()
theano.function(inputs=nn.input+nn.output, outputs=nn.crossentropy)
end_time = timeit.default_timer()
num_data = len(data_triplet.training_data_label[0])
print 'crossentropy function for %s instances take %s seconds' % (num_data, end_time - start_time )
learning_rate = 0.001
lr_smoother = 0.01
indexed_data_triplet = DataTriplet(
data_list=[
[np.arange(len(data_triplet.training_data_label[0]))],
[np.arange(len(data_triplet.dev_data_label[0]))],
[np.arange(len(data_triplet.test_data_label[0]))]
],
label_vectors=[data_triplet.training_data_label,
data_triplet.dev_data_label,
data_triplet.test_data_label],
label_alphabet_list=data_triplet.label_alphabet_list)
#print nn.input
#f = theano.function(inputs=nn.input[0:1] + nn.output, outputs=nn.crossentropy)
#print f(np.array([2]), np.array([2]))
start_time = timeit.default_timer()
trainer = AdagradTrainer(nn,
nn.hinge_loss if use_hinge else nn.crossentropy,
learning_rate, lr_smoother, indexed_data_triplet,
BinaryForestLSTM.make_givens)
end_time = timeit.default_timer()
num_data = len(indexed_data_triplet.training_data_label[0])
print '%s instances take %s seconds' % (num_data, end_time - start_time )
return
dev_model = _copy_tlstm_net(data_triplet.dev_data, nn, proj_type)
test_model = _copy_tlstm_net(data_triplet.test_data, nn, proj_type)
dev_accuracy = T.mean(T.eq(dev_model.output[-1], dev_model.predict[-1]))
trainer.dev_eval_function = \
theano.function(inputs=dev_model.input + dev_model.output,
outputs=[dev_accuracy, dev_model.crossentropy],
on_unused_input='warn')
test_accuracy = T.mean(T.eq(test_model.output[-1], test_model.predict[-1]))
trainer.test_eval_function = \
theano.function(inputs=test_model.input + test_model.output,
outputs=[test_accuracy, test_model.crossentropy],
on_unused_input='warn')
#with open(model_file, 'w') as f:
#sys.setrecursionlimit(5000000)
#cPickle.dump(trainer, f)
for rep in xrange(num_reps):
random_seed = rep
rng = np.random.RandomState(random_seed)
for layer in nn.layers:
layer.reset(rng)
trainer.reset()
minibatch_size = np.random.randint(20, 60)
minibatch_size = 1
n_epochs = 50
start_time = timeit.default_timer()
best_iter, best_dev_acc, best_test_acc = \
trainer.train_minibatch_triplet(minibatch_size, n_epochs)
end_time = timeit.default_timer()
print end_time - start_time
print best_iter, best_dev_acc, best_test_acc
result_dict = {
'test accuracy': best_test_acc,
'best dev accuracy': best_dev_acc,
'best iter': best_iter,
'random seed': random_seed,
'minibatch size': minibatch_size,
'learning rate': learning_rate,
'lr smoother': lr_smoother,
'experiment name': experiment_name,
'num hidden units': num_hidden_units,
'num hidden layers': num_hidden_layers,
'cost function': 'hinge loss' if use_hinge else 'crossentropy',
'projection' : proj_type,
}
json_file.write('%s\n' % json.dumps(result_dict, sort_keys=True))
