def __init__(self, rbm_layers, do_pretrain=True, rbm_num_epochs=list([10]), rbm_batch_size=list([10]), model_name='dbn', rbm_learning_rate=list([0.01]), rbm_names=list(['']), rbm_gibbs_k=list([1]), rbm_gauss_visible=False, rbm_stddev=0.1, finetune_learning_rate=0.01, momentum=0.9, finetune_num_epochs=10, finetune_batch_size=10, finetune_dropout=1, finetune_opt='gradient_descent', verbose=1, finetune_act_func='relu', finetune_loss_func='mean_squared', main_dir='dbn/', dataset='mnist'): """ :param rbm_layers: list containing the hidden units for each layer :param do_pretrain: whether to do unsupervised pretraining of the network :param rbm_num_epochs: number of epochs to train each rbm :param rbm_batch_size: batch size each rbm :param rbm_learning_rate: learning rate each rbm :param rbm_names: model name for each rbm :param rbm_gibbs_k: number of gibbs sampling steps for each rbm :param rbm_gauss_visible: whether the input layer should have gaussian units :param rbm_stddev: standard deviation for the gaussian layer :param finetune_dropout: dropout parameter :param verbose: Level of verbosity. 0 - silent, 1 - print accuracy. int, default 0 """ model.Model.__init__(self, model_name, main_dir) self._initialize_training_parameters(loss_func=finetune_loss_func, learning_rate=finetune_learning_rate, num_epochs=finetune_num_epochs, batch_size=finetune_batch_size, dropout=finetune_dropout, dataset=dataset, opt=finetune_opt, momentum=momentum) self.do_pretrain = do_pretrain self.layers = rbm_layers self.finetune_act_func = finetune_act_func self.verbose = verbose self.W_pretrain = None self.bh_pretrain = None self.bv_pretrain = None self.W_vars = None self.b_vars = None self.rbms = [] for l, layer in enumerate(rbm_layers): if l == 0 and rbm_gauss_visible: # Gaussian visible units self.rbms.append(rbm.RBM( visible_unit_type='gauss', stddev=rbm_stddev, model_name=rbm_names[l] + str(l), num_hidden=rbm_layers[l], main_dir=self.main_dir, learning_rate=rbm_learning_rate[l], gibbs_sampling_steps=rbm_gibbs_k[l], verbose=self.verbose, num_epochs=rbm_num_epochs[l], batch_size=rbm_batch_size[l])) else: # Binary RBMs self.rbms.append(rbm.RBM( model_name=rbm_names[l] + str(l), num_hidden=rbm_layers[l], main_dir=self.main_dir, learning_rate=rbm_learning_rate[l], gibbs_sampling_steps=rbm_gibbs_k[l], verbose=self.verbose, num_epochs=rbm_num_epochs[l], batch_size=rbm_batch_size[l]))
def __init__(self, layers, do_pretrain=True, rbm_num_epochs=list([10]), rbm_batch_size=list([10]), rbm_learning_rate=list([0.01]), rbm_names=list(['']), rbm_gibbs_k=list([1]), gauss_visible=False, stddev=0.1, learning_rate=0.01, momentum=0.7, num_epochs=10, batch_size=10, dropout=1, opt='gradient_descent', loss_func='mean_squared', model_name='deepae', main_dir='deepae/', dataset='mnist', verbose=1): """ :param layers: list containing the hidden units for each layer :param do_pretrain: whether to do unsupervised pretraining of the network :param rbm_num_epochs: number of epochs to train each rbm :param rbm_batch_size: batch size each rbm :param rbm_learning_rate: learning rate each rbm :param rbm_names: model name for each rbm :param rbm_gibbs_k: number of gibbs sampling steps for each rbm :param gauss_visible: whether the input layer should have gaussian units :param stddev: standard deviation for the gaussian layer :param dropout: dropout parameter :param verbose: Level of verbosity. 0 - silent, 1 - print accuracy. int, default 0 """ model.Model.__init__(self, model_name, main_dir) self._initialize_training_parameters(loss_func, learning_rate, num_epochs, batch_size, dataset, opt, momentum) self.layers = layers self.n_layers = len(layers) # RBM parameters self.do_pretrain = do_pretrain self.rbm_num_epochs = rbm_num_epochs self.rbm_batch_size = rbm_batch_size self.rbm_learning_rate = rbm_learning_rate self.rbm_names = rbm_names self.rbm_gibbs_k = rbm_gibbs_k # Stacked RBM parameters self.gauss_visible = gauss_visible self.stddev = stddev self.dropout = dropout self.verbose = verbose self.W_pretrain = None self.bh_pretrain = None self.bv_pretrain = None self.W_vars = None self.W_vars_t = None self.bh_vars = None self.bv_vars = None self.encode = None if self.do_pretrain: self.rbms = [] for l in range(self.n_layers): if l == 0 and self.gauss_visible: # Gaussian visible units self.rbms.append( rbm.RBM(visible_unit_type='gauss', stddev=self.stddev, model_name=self.rbm_names[l] + str(l), num_hidden=self.layers[l], main_dir=self.main_dir, learning_rate=self.rbm_learning_rate[l], verbose=self.verbose, num_epochs=self.rbm_num_epochs[l], batch_size=self.rbm_batch_size[l])) else: # Binary RBMs self.rbms.append( rbm.RBM(model_name=self.rbm_names[l] + str(l), num_hidden=self.layers[l], main_dir=self.main_dir, learning_rate=self.rbm_learning_rate[l], verbose=self.verbose, num_epochs=self.rbm_num_epochs[l], batch_size=self.rbm_batch_size[l]))
else: return None trX = load_from_np(FLAGS.train_dataset) vlX = load_from_np(FLAGS.valid_dataset) teX = load_from_np(FLAGS.test_dataset) else: trX, vlX, teX, width, height = None, None, None, None, None # Create the object r = rbm.RBM(num_hidden=FLAGS.num_hidden, main_dir=FLAGS.main_dir, visible_unit_type=FLAGS.visible_unit_type, learning_rate=FLAGS.learning_rate, num_epochs=FLAGS.num_epochs, batch_size=FLAGS.batch_size, stddev=FLAGS.stddev, verbose=FLAGS.verbose, gibbs_sampling_steps=FLAGS.gibbs_sampling_steps, model_name=FLAGS.model_name) # Fit the model print('Start training...') r.build_model(trX.shape[1]) r.fit(trX, teX, restore_previous_model=FLAGS.restore_previous_model) # Encode the training data and store it if FLAGS.encode_train: print('Transforming training data...') r.transform(trX, name='train', save=FLAGS.encode_train)