def fit(self, X, Y):
# Create a report to be saved at the end of execution
# (when running on the remote server)
if self.do_report:
report = {"learning_rate":self.learning_rate,
"training_epochs":self.training_epochs,
"batch_size":self.batch_size,
"n_chains":self.n_chains,
"n_samples":self.n_samples,
"n_hidden":self.n_hidden,
"k":self.k,
"costs":np.zeros(self.training_epochs),
# "accuracy":np.zeros(self.training_epochs),
"pretraining_time":0}
train_data = np.hstack([Y,X])
n_visible = train_data.shape[1]
# Building of theano format datasets
train_set = shared_dataset(train_data)
# compute number of minibatches for training, validation and testing
n_train_batches = train_set.get_value(borrow=True).shape[0] / \
self.batch_size
# allocate symbolic variables for the data
index = T.lscalar() # index to a [mini]batch
x = T.matrix('x') # the data
rng = np.random.RandomState(123)
theano_rng = RandomStreams(rng.randint(2 ** 30))
# initialize storage for the persistent chain (state = hidden
# layer of chain)
persistent_chain = theano.shared(np.zeros((self.batch_size,
self.n_hidden),
dtype=theano.config.floatX),
borrow=True)
# construct the RBM class
self.rbm = RBM(input=x,
n_visible=n_visible,
n_labels=self.n_labels,
n_hidden=self.n_hidden,
np_rng=rng,
theano_rng=theano_rng)
# get the cost and the gradient corresponding to one step of CD-k
cost, updates = self.rbm.get_cost_updates(lr=self.learning_rate,
persistent=persistent_chain,
k=self.k)
# accuracy = self.rbm.get_cv_error()
#%%====================================================================
# Training the RBM
#======================================================================
# it is ok for a theano function to have no output
# the purpose of train_rbm is solely to update the RBM parameters
train_rbm = theano.function(
[index],
cost,
updates=updates,
givens={
x: train_set[index * self.batch_size: \
(index + 1) * self.batch_size]
},
name='train_rbm'
)
start_time = timeit.default_timer()
max_score = -np.inf
argmax_score = RBM(input=x,
n_visible=n_visible,
n_labels=self.n_labels,
n_hidden=self.n_hidden,
np_rng=rng,
theano_rng=theano_rng)
# count = 0
## go through training epochs
for epoch in xrange(self.training_epochs):
# go through the training set
mean_cost = []
for batch_index in xrange(n_train_batches):
mean_cost += [train_rbm(batch_index)]
print 'Training epoch %d, cost is ' % epoch, np.mean(mean_cost)
score = np.mean(mean_cost)
if score>max_score:
max_score = score
argmax_score.clone(self.rbm)
# acc = accuracy.eval()
#
# if self.scoring=='cost':
# score = np.mean(mean_cost)
# elif self.scoring=='accuracy':
# score = acc
# else:
# raise Warning('''scoring must be cost or accuracy,
# set to accuracy''')
# score = acc
#
# if score>max_score:
# max_score = score
# argmax_score.clone(self.rbm)
# count = 0
# else:
# count += 1
#
# if count>2:
# break
if self.do_report:
report["costs"][epoch] = np.mean(mean_cost)
# report["accuracy"][epoch] = acc
end_time = timeit.default_timer()
pretraining_time = (end_time - start_time)
report['pretraining_time'] = pretraining_time
self.rbm = argmax_score
if self.do_report:
try:
np.save(self.report_folder+'/'+self.report_name, report)
except OSError:
os.mkdir(self.report_folder)
np.save(self.report_folder+'/'+self.report_name, report)
% (epoch,
((cv_time-epoch_time) / 60.),
((timeit.default_timer()-cv_time) / 60.),
acc))
if scoring=='cost':
score = np.mean(mean_cost)
elif scoring=='accuracy':
score = acc
else:
raise Warning('''scoring must be cost or accuracy,
set to accuracy''')
score = acc
if score>max_score:
max_score = score
argmax_score.clone(rbm)
count = 0
else:
count += 1
if count>=increasing_constraint:
break
if do_report:
report["costs"][epoch] = np.mean(mean_cost)
report["accuracy"][epoch] = acc
end_time = timeit.default_timer()
training_time = (end_time - start_time)
report['training_time'] = training_time
print ('Training took %f minutes' % (training_time / 60.))
if do_report:
np.save('reports/'+report_name+'_'+str(i), report)
