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