def train_SdA(train_names, valid_names, output_folder, base_folder, window_size, corruption_levels, pretraining_epochs, start_base, rank, pretrain_lr): """ Demonstrates how to train and test a stochastic denoising autoencoder. This is demonstrated on ICHI. :type pretraining_epochs: int :param pretraining_epochs: number of epoch to do pretraining :type n_iter: int :param n_iter: maximal number of iterations ot run the optimizer :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 """ # compute number of examples given in training set n_in = window_size*3 # number of input units n_out = 7 # number of output units # numpy random generator # start-snippet-3 numpy_rng = numpy.random.RandomState(89677) print '... building the model' # construct the stacked denoising autoencoder class sda = SdA( numpy_rng=numpy_rng, n_ins=n_in, hidden_layers_sizes=[window_size*2, window_size], n_outs=n_out ) # end-snippet-3 start-snippet-4 ######################### # PRETRAINING THE MODEL # ######################### start_time = timeit.default_timer() ''' pretrained_sda = pretrain_sda_sgd(sda=sda, train_names=train_names, window_size=window_size, pretraining_epochs=pretraining_epochs, pretrain_lr=pretrain_lr, corruption_levels=corruption_levels) ''' pretrained_sda = pretrain_sda_cg(sda=sda, train_names=train_names, window_size=window_size, pretraining_epochs=pretraining_epochs, corruption_levels=corruption_levels) end_time = timeit.default_timer() for i in xrange(sda.n_layers): print(i, 'i pretrained') visualize_pretraining(train_cost=pretrained_sda.dA_layers[i].train_cost_array, window_size=window_size, learning_rate=0, corruption_level=corruption_levels[i], n_hidden=sda.dA_layers[i].n_hidden, da_layer=i, datasets_folder=output_folder, base_folder=base_folder) print >> sys.stderr, ('The pretraining code for file ' + os.path.split(__file__)[1] + ' ran for %.2fm' % ((end_time - start_time) / 60.)) # end-snippet-4 ######################## # FINETUNING THE MODEL # ######################## #create matrices for params of HMM layer n_hiddens=[5]*n_out #create hmm container hmmLayer = GeneralHMM( n_hiddens = n_hiddens, n_hmms = n_out ) #train_hmm train_reader = ICHISeqDataReader(train_names) n_train_patients = len(train_names) #train hmms on data of each pattient for train_patient in xrange(n_train_patients): #get data divided on sequences with respect to labels train_set = train_reader.read_one_with_window( window_size=window_size, divide=True ) for i in xrange(hmmLayer.n_hmms): cur_train_set = train_set[i].eval() if cur_train_set.shape[0] <= 0: continue print('train_set[i].eval(): ', train_set[i].eval().shape) #get (avg, disp) labels for x-values train_visible_after_sda = numpy.array([sda.get_da_output( numpy.array(cur_train_set[time]).reshape(1, -1)) for time in xrange(cur_train_set.shape[0])]) x_labels = create_labels_after_das( da_output_matrix = train_visible_after_sda, rank=rank, start_base=start_base ) hmmLayer.hmm_models[i].fit([numpy.array(x_labels).reshape(-1, 1)]) error_cur_epoch = hmmLayer.validate_model( valid_names = valid_names, window_size = window_size, rank = rank, start_base = start_base ) hmmLayer.valid_error_array.append([]) hmmLayer.valid_error_array[-1].append(train_patient) hmmLayer.valid_error_array[-1].append(error_cur_epoch) gc.collect() gc.collect() print('MultinomialHMM created') sda.set_hmm_layer( hmm_model=hmmLayer ) return sda
def pretrain_SdA(train_names, valid_names, read_window, read_algo, read_rank, window_size, corruption_levels, pretraining_epochs, pretraining_pat_epochs, pretrain_lr, pretrain_algo, hidden_layers_sizes, output_folder, base_folder): """ Demonstrates how to train and test a stochastic denoising autoencoder. This is demonstrated on ICHI. :type pretraining_epochs: int :param pretraining_epochs: number of epoch to do pretraining :type n_iter: int :param n_iter: maximal number of iterations ot run the optimizer :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 """ n_out = 7 # number of output units # numpy random generator numpy_rng = numpy.random.RandomState(89677) # construct the stacked denoising autoencoder class sda = SdA( numpy_rng=numpy_rng, n_ins=window_size, hidden_layers_sizes=hidden_layers_sizes, n_outs=n_out ) ######################### # PRETRAINING THE MODEL # ######################### if (pretrain_algo == "sgd"): pretrained_sda = pretrain_sda_sgd( sda = sda, train_names = train_names, valid_names = valid_names, read_window = read_window, read_algo = read_algo, read_rank = read_rank, window_size = window_size, global_epochs = pretraining_epochs, pat_epochs = pretraining_pat_epochs, pretrain_lr = pretrain_lr, corruption_levels = corruption_levels ) else: pretrained_sda = pretrain_sda_cg( sda=sda, train_names=train_names, window_size=window_size, pretraining_epochs=pretraining_epochs, corruption_levels=corruption_levels, preprocess_algo = pretrain_algo, read_window = read_window ) for i in xrange(sda.n_layers): visualize_pretraining( train_cost = pretrained_sda.dA_layers[i].train_cost_array, valid_error = pretrained_sda.dA_layers[i].valid_error_array, window_size = window_size, learning_rate = pretrain_lr, corruption_level = corruption_levels[i], n_hidden = sda.dA_layers[i].n_hidden, da_layer = i, datasets_folder = output_folder, base_folder = base_folder ) gc.collect() return sda