def train_dA(training_epochs, window_size, corruption_level, n_hidden,
dataset, output_folder, base_folder):
"""
This dA is tested on ICHI_Data
:type training_epochs: int
:param training_epochs: number of epochs used for training
:type window_size: int
:param window_size: size of window used for training
:type corruption_level: float
:param corruption_level: corruption_level used for training the DeNosing
AutoEncoder
:type n_hidden: int
:param n_hidden: count of nodes in hidden layer
:type datasets: array
:param datasets: [train_set, valid_set, test_set]
:type output_folder: string
:param output_folder: folder for costand error graphics with results
"""
# allocate symbolic variables for the data
index = T.lscalar() # index
x = T.matrix('x') # the data is presented as 3D vector
rng = numpy.random.RandomState(123)
theano_rng = RandomStreams(rng.randint(2 ** 30))
n_visible = window_size*3 # number of input units
da = dA(
numpy_rng=rng,
theano_rng=theano_rng,
input=x,
n_visible=n_visible,
n_hidden=n_hidden
)
n_train_samples = dataset.get_value(borrow=True).shape[0] - window_size + 1
cost = da.get_cost(
corruption_level=corruption_level
)
# compile a theano function that returns the cost
conj_cost = theano.function(
inputs=[index],
outputs=cost,
givens={
x: dataset[index: index + window_size]
},
name="conj_cost"
)
# compile a theano function that returns the gradient with respect to theta
conj_grad = theano.function(
[index],
T.grad(cost, da.theta),
givens={
x: dataset[index: index + window_size]
},
name="conj_grad"
)
da.train_cost_array = []
da.epoch = 0
# creates a function that computes the average cost on the training set
def train_fn(theta_value):
da.theta.set_value(theta_value, borrow=True)
train_losses = [conj_cost(i)
for i in xrange(n_train_samples)]
this_train_loss = float(numpy.mean(train_losses))
da.train_cost_array.append([])
da.train_cost_array[-1].append(da.epoch)
da.train_cost_array[-1].append(this_train_loss)
da.epoch += 1
return this_train_loss
# creates a function that computes the average gradient of cost with
# respect to theta
def train_fn_grad(theta_value):
da.theta.set_value(theta_value, borrow=True)
grad = conj_grad(0)
for i in xrange(1, n_train_samples):
grad += conj_grad(i)
return grad / n_train_samples
############
# TRAINING #
############
# using scipy conjugate gradient optimizer
import scipy.optimize
print ("Optimizing using scipy.optimize.fmin_cg...")
start_time = timeit.default_timer()
best_w_b = scipy.optimize.fmin_cg(
f=train_fn,
x0=numpy.zeros((n_visible + 1) * n_hidden, dtype=x.dtype),
fprime=train_fn_grad,
disp=0,
maxiter=training_epochs
)
end_time = timeit.default_timer()
print(
'Optimization complete'
)
print >> sys.stderr, ('The code for file ' +
os.path.split(__file__)[1] +
' ran for %.1fs' % ((end_time - start_time)))
visualize_da(train_cost=da.train_cost_array,
window_size=window_size,
learning_rate=0,
corruption_level=corruption_level,
n_hidden=n_hidden,
output_folder=output_folder,
base_folder=base_folder)
def train_dA(learning_rate, training_epochs, window_size, corruption_level, n_hidden,
train_set, output_folder, base_folder):
"""
This dA is tested on ICHI_Data
:type learning_rate: float
:param learning_rate: learning rate used for training the DeNosing
AutoEncoder
:type training_epochs: int
:param training_epochs: number of epochs used for training
:type window_size: int
:param window_size: size of window used for training
:type corruption_level: float
:param corruption_level: corruption_level used for training the DeNosing
AutoEncoder
:type n_hidden: int
:param n_hidden: count of nodes in hidden layer
:type output_folder: string
:param output_folder: folder for costand error graphics with results
"""
# split the datasets
start_time = time.clock()
rng = numpy.random.RandomState(123)
theano_rng = RandomStreams(rng.randint(2 ** 30))
x = T.matrix('x') # the data is presented as 3D vector
da = dA(
numpy_rng=rng,
theano_rng=theano_rng,
input=x,
n_visible=window_size*3,
n_hidden=n_hidden
)
'''
updated_da = train_da_sgd(learning_rate=learning_rate,
window_size=window_size,
training_epochs=training_epochs,
corruption_level=corruption_level,
train_set=train_set,
da=da)
'''
updated_da = train_da_cg(da=da,
train_set=train_set,
window_size=window_size,
corruption_level=corruption_level,
training_epochs=training_epochs)
visualize_da(train_cost=updated_da.train_cost_array,
window_size=window_size,
learning_rate=learning_rate,
corruption_level=corruption_level,
n_hidden=n_hidden,
output_folder=output_folder,
base_folder=base_folder)
end_time = time.clock()
training_time = (end_time - start_time)
print >> sys.stderr, ('The no corruption code for file ' +
os.path.split(__file__)[1] +
' ran for %.2fm' % ((training_time) / 60.))
