def main(_): dropout_on = tf.placeholder(tf.float32) if dropout_on is not None: conv_keep_prob = 1.0 else: conv_keep_prob = 1.0 x = tf.placeholder(tf.float32, shape=[None, 14 * 4]) y_ = tf.placeholder(tf.float32, shape=[None, 2]) x_image = tf.reshape([-1, 14, 4, 1]) n_conv1 = 384 # TBD L_conv1 = 9 # TBD maxpool_len1 = 2 conv1 = convolution2d(x_image, n_conv1, [L_conv1, 4], padding="VALID", normalizer_fn=None) conv1_pool_len = int((14 - L_conv1 + 1) / maxpool_len1) n_conv2 = n_conv1 L_conv2 = 5 maxpool_len2 = int( conv1_pool_len - L_conv2 + 1) # global maxpooling (max-pool across temporal domain) conv2 = convolution2d(conv1_pool, n_conv2, [L_conv2, 1], padding='VALID', normalizer_fn=None) conv2_pool = max_pool2d(conv2, [maxpool_len2, 1], [maxpool_len2, 1]) # conv2_drop = tf.nn.dropout(conv2_pool, conv_keep_prob) # LINEAR FC LAYER y_conv = fully_connected(flatten(conv2_pool), 2, activation_fn=None) y_conv_softmax = tf.nn.softmax(y_conv) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(y_conv, y_)) train_step = tf.train.AdamOptimizer().minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) sess.run(tf.initialize_all_variables())
def __init__(self, sequence_length, num_classes): #placeholders for input, output and dropout self.input_x = tf.placeholder(tf.float32, [None, sequence_length], name="input_x") self.input_y = tf.placeholder(tf.float32, [None, num_classes], name="input_y") self.dropout_keep_prob = tf.placeholder(tf.float32, name="dropout_keep_prob") x_image = tf.reshape(self.input_x, shape=[-1, 14, 4, 1]) n_conv1 = 44 L_conv1 = 5 maxpool_len1 = 2 conv1 = convolution2d(x_image, n_conv1, [L_conv1, 4], padding='VALID', normalizer_fn=None) conv1_pool = max_pool2d(conv1, [maxpool_len1, 1], [maxpool_len1, 1]) conv1_pool_len = int((101 - L_conv1 + 1) / maxpool_len1) # n_conv2 = n_conv1 # L_conv2 = 3 # maxpool_len2 = int(conv1_pool_len - L_conv2 + 1) # global maxpooling (max-pool across temporal domain) # conv2 = convolution2d(conv1_pool, n_conv2, [L_conv2, 1], padding='VALID', normalizer_fn=None) # conv2_pool = max_pool2d(conv2, [maxpool_len2, 1], [maxpool_len2, 1]) # LINEAR FC LAYER y_conv = fully_connected(flatten(conv1_pool), 2, activation_fn=None) prediction = tf.nn.softmax(y_conv) self.cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=self.input_y)) # train_step = tf.train.AdamOptimizer().minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(prediction, 1), tf.argmax(self.input_y, 1)) self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
def main(_): global _train_epochs_completed global _validation_epochs_completed global _test_epochs_completed global _datasets global _validation_size global _test_labels dropout_on = tf.placeholder(tf.float32) if dropout_on is not None: conv_keep_prob = 1.0 else: conv_keep_prob = 1.0 file_name = 'out_' + str(int(time.time())) + '.csv' f = open(file_name, 'w') # clear file f.write('dataset_num,dataset_name,roc_auc\n') f.close() for dataset_num in range(0, len(_datasets)): load_ENCODE_k562_dataset(dataset_num) x = tf.placeholder(tf.float32, shape=[None, 101 * 4]) y_ = tf.placeholder(tf.float32, shape=[None, 2]) # Create the model x_image = tf.reshape(x, [-1, 101, 4, 1]) # CONVOLUTIONAL LAYER(S) n_conv3 = 64 L_conv3 = 9 maxpool_len3 = int(101 - L_conv3 + 1) # global maxpooling ("across temporal domain") conv3 = convolution2d(x_image, n_conv3, [L_conv3, 4], padding='VALID', normalizer_fn=None) conv3_pool = max_pool2d(conv3, [maxpool_len3, 1], [maxpool_len3, 1]) # LINEAR FC LAYER y_conv = fully_connected(flatten(conv3_pool), 2, activation_fn=None) y_conv_softmax = tf.nn.softmax(y_conv) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(y_conv, y_)) train_step = tf.train.AdamOptimizer().minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) sess.run(tf.initialize_all_variables()) i = 0 prev_auc = 0.0001 # small value to prevent DIV0 stop_condition = None t0 = time.time() while stop_condition is None: if i % 1000 == 0: #t0 = time.time() pred_validation_labels = None true_validation_labels = None prev_validation_epochs_completed = _validation_epochs_completed while _validation_epochs_completed - prev_validation_epochs_completed == 0: # do in mini batches because single GTX970 has insufficient memory to test all at once if _validation_size > 1024 * 5: validation_batch = get_next_batch(1, 1024) else: validation_batch = get_next_batch(1, 64) if pred_validation_labels is None: pred_validation_labels = y_conv_softmax.eval( feed_dict={ x: validation_batch[0], y_: validation_batch[1] }) true_validation_labels = validation_batch[1] else: pred_validation_labels = numpy.vstack([ pred_validation_labels, y_conv_softmax.eval(feed_dict={ x: validation_batch[0], y_: validation_batch[1] }) ]) true_validation_labels = numpy.vstack( [true_validation_labels, validation_batch[1]]) fpr, tpr, _ = roc_curve(true_validation_labels[:, 0], pred_validation_labels[:, 0]) roc_auc = auc(fpr, tpr) #check stop condition: perc_chg_auc = (roc_auc - prev_auc) / prev_auc #if perc_chg_auc < 0.005: # stop when auc moving average on validation set changes by <0.5% # stop_condition = 1 prev_auc = roc_auc print( "%s, dataset %g, epoch %d, step %d, time elapsed %g, validation roc auc %g, perc chg in auc %g" % (_datasets[dataset_num], dataset_num, _train_epochs_completed, i, time.time() - t0, roc_auc, perc_chg_auc)) t0 = time.time() batch = get_next_batch(0) train_step.run(feed_dict={ x: batch[0], y_: batch[1], dropout_on: 1 }) if i == 7000: stop_condition = 1 i += 1 pred_test_labels = None true_test_labels = None while _test_epochs_completed == 0: # do testing in mini batches because single GTX970 has insufficient memory to test all at once test_batch = get_next_batch(2, 64) if pred_test_labels is None: pred_test_labels = y_conv_softmax.eval(feed_dict={ x: test_batch[0], y_: test_batch[1] }) true_test_labels = test_batch[1] else: pred_test_labels = numpy.vstack([ pred_test_labels, y_conv_softmax.eval(feed_dict={ x: test_batch[0], y_: test_batch[1] }) ]) true_test_labels = numpy.vstack( [true_test_labels, test_batch[1]]) fpr, tpr, _ = roc_curve(true_test_labels[:, 0], pred_test_labels[:, 0]) roc_auc = auc(fpr, tpr) print("%s, dataset %g, final test roc auc %g" % (_datasets[dataset_num], dataset_num, roc_auc)) f = open(file_name, 'a') f.write( str(dataset_num) + ',' + _datasets[dataset_num] + ',' + str(roc_auc) + '\n') f.close()
def main(_): global _train_epochs_completed global _validation_epochs_completed global _test_epochs_completed global _datasets global _validation_size global _test_labels dropout_on = tf.placeholder(tf.float32) if dropout_on is not None: conv_keep_prob = 1.0 else: conv_keep_prob = 1.0 file_name = 'out_' + str(int(time.time())) + '.csv' f = open(file_name, 'w') # clear file f.write( 'dataset_num,motif_discovery=0|motif_occupancy=1,dataset_name,roc_auc,prc_auc,time(sec)\n' ) f.close() for dataset_num in range(0, len(_datasets)): for motif_occ in range(0, 2): success = False try: load_ENCODE_k562_dataset(dataset_num, motif_occ) success = True except: print('Hmm.. Something happened. Skipping dataset ' + _datasets[dataset_num]) if success: with tf.variable_scope('scopename_' + str(dataset_num) + '_' + str(motif_occ)): # LSTM Parameters ============================ lstm_n_hidden = 32 # hidden layer num features # ============================================ x = tf.placeholder(tf.float32, shape=[None, 101 * 4]) y_ = tf.placeholder(tf.float32, shape=[None, 2]) # Create the model x_image = tf.reshape(x, [-1, 101, 4, 1]) # CONVOLUTIONAL LAYER(S) n_conv1 = 384 L_conv1 = 9 maxpool_len1 = 2 conv1 = convolution2d(x_image, n_conv1, [L_conv1, 4], padding='VALID', normalizer_fn=None) conv1_pool = max_pool2d(conv1, [maxpool_len1, 1], [maxpool_len1, 1]) #conv1_drop = tf.nn.dropout(conv1_pool, conv_keep_prob) conv1_pool_len = int((101 - L_conv1 + 1) / maxpool_len1) n_conv2 = n_conv1 L_conv2 = 5 maxpool_len2 = int( conv1_pool_len - L_conv2 + 1 ) # global maxpooling (max-pool across temporal domain) conv2 = convolution2d(conv1_pool, n_conv2, [L_conv2, 1], padding='VALID', normalizer_fn=None) conv2_pool = max_pool2d(conv2, [maxpool_len2, 1], [maxpool_len2, 1]) #conv2_drop = tf.nn.dropout(conv2_pool, conv_keep_prob) # LINEAR FC LAYER y_conv = fully_connected(flatten(conv2_pool), 2, activation_fn=None) y_conv_softmax = tf.nn.softmax(y_conv) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(y_conv, y_)) train_step = tf.train.AdamOptimizer().minimize( cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean( tf.cast(correct_prediction, tf.float32)) sess.run(tf.initialize_all_variables()) i = 0 prev_auc = 0.0001 # small value to prevent DIV0 stop_condition = None t0 = time.time() while stop_condition is None: #if i%100 == 0: if 1 == 0: # turned off #t0 = time.time() pred_validation_labels = None true_validation_labels = None prev_validation_epochs_completed = _validation_epochs_completed while _validation_epochs_completed - prev_validation_epochs_completed == 0: # do in mini batches because single GTX970 has insufficient memory to test all at once if _validation_size > 1024 * 5: validation_batch = get_next_batch(1, 1024) else: validation_batch = get_next_batch(1, 64) if pred_validation_labels is None: pred_validation_labels = y_conv_softmax.eval( feed_dict={ x: validation_batch[0], y_: validation_batch[1] }) true_validation_labels = validation_batch[ 1] else: pred_validation_labels = numpy.vstack([ pred_validation_labels, y_conv_softmax.eval( feed_dict={ x: validation_batch[0], y_: validation_batch[1] }) ]) true_validation_labels = numpy.vstack([ true_validation_labels, validation_batch[1] ]) fpr, tpr, _ = roc_curve( true_validation_labels[:, 0], pred_validation_labels[:, 0]) roc_auc = auc(fpr, tpr) #check stop condition: perc_chg_auc = (roc_auc - prev_auc) / prev_auc #if perc_chg_auc < 0.005: # stop when auc moving average on validation set changes by <0.5% # stop_condition = 1 prev_auc = roc_auc print( "%s, dataset %g, epoch %d, step %d, time elapsed %g, validation roc auc %g, perc chg in auc %g" % (_datasets[dataset_num], dataset_num, _train_epochs_completed, i, time.time() - t0, roc_auc, perc_chg_auc)) t0 = time.time() batch = get_next_batch(0) train_step.run(feed_dict={ x: batch[0], y_: batch[1], dropout_on: 1 }) if i == 7000: stop_condition = 1 i += 1 pred_test_labels = None true_test_labels = None while _test_epochs_completed == 0: # do testing in mini batches because single GTX970 has insufficient memory to test all at once test_batch = get_next_batch(2, 64) if pred_test_labels is None: pred_test_labels = y_conv_softmax.eval( feed_dict={ x: test_batch[0], y_: test_batch[1] }) true_test_labels = test_batch[1] else: pred_test_labels = numpy.vstack([ pred_test_labels, y_conv_softmax.eval(feed_dict={ x: test_batch[0], y_: test_batch[1] }) ]) true_test_labels = numpy.vstack( [true_test_labels, test_batch[1]]) fpr, tpr, _ = roc_curve( true_test_labels[:, 0], pred_test_labels[:, 0] ) # get receiver operating characteristics precision, recall, _ = precision_recall_curve( true_test_labels[:, 0], pred_test_labels[:, 0]) # get precision recall curve roc_auc = auc(fpr, tpr) prc_auc = auc(recall, precision) print( "%s, dataset %g, final test roc auc %g, final test prc auc %g, time elapsed %g seconds" % (_datasets[dataset_num], dataset_num, roc_auc, prc_auc, time.time() - t0)) f = open(file_name, 'a') f.write( str(dataset_num) + ',' + str(motif_occ) + ',' + _datasets[dataset_num] + ',' + str(roc_auc) + ',' + str(prc_auc) + ',' + str(time.time() - t0) + '\n') f.close() t0 = time.time()
def main(_): global _train_epochs_completed global _validation_epochs_completed global _test_epochs_completed global _datasets global _validation_size global _test_labels dropout_on = tf.placeholder(tf.float32) if dropout_on is not None: rnn_keep_prob = 1.0 else: rnn_keep_prob = 1.0 file_name = 'out_' + str(int(time.time())) + '.csv' f=open(file_name,'w') # clear file f.write('dataset_num,motif_discovery=0|motif_occupancy=1,dataset_name,roc_auc,prc_auc,time(sec)\n') f.close() for dataset_num in range(106, len(_datasets)): for motif_occ in range(0,2): success = False try: load_ENCODE_k562_dataset(dataset_num,motif_occ) success = True except: print('Hmm.. Something happened. Skipping dataset ' + _datasets[dataset_num]) if success: with tf.variable_scope('scopename_' + str(dataset_num) + '_' + str(motif_occ)): # LSTM Parameters ============================ lstm_n_hidden = 32 # hidden layer num features # ============================================ x = tf.placeholder(tf.float32, shape=[None, 101*4]) y_ = tf.placeholder(tf.float32, shape=[None, 2]) # Create the model x_image = tf.reshape(x, [-1,101,4,1]) # CONVOLUTIONAL LAYER(S) n_conv1 = 128 L_conv1 = 9 n_steps1 = (101-L_conv1+1) conv1 = convolution2d(x_image, n_conv1, [L_conv1,4], padding='VALID', normalizer_fn=None) conv1_resh = tf.reshape(conv1, [-1,n_steps1,n_conv1]) # LSTM LAYER(S) conv1_unpacked = tf.unpack(conv1_resh, axis=1) # this func does it all for us :) lstm_fw_cell = rnn_cell.BasicLSTMCell(lstm_n_hidden) lstm_bw_cell = rnn_cell.BasicLSTMCell(lstm_n_hidden) birnn_out,_,_ = tf.nn.bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, conv1_unpacked, dtype=tf.float32) # Linear activation # rnn_out = birnn_out[-1] # to use LAST of the rnn inner loops (as in the MNIST example) rnn_out = tf.div(tf.add_n(birnn_out), 101) # to use the AVERAGE of the rnn inner loops rnn_out_drop = tf.nn.dropout(rnn_out, rnn_keep_prob) # apply dropout to regularize the LSTM pred = fully_connected(flatten(rnn_out_drop), 2, activation_fn=None) pred_softmax = tf.nn.softmax(pred) cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y_)) train_step = tf.train.AdamOptimizer().minimize(cross_entropy) sess.run(tf.initialize_all_variables()) i = 0 prev_auc = 0.0001 # small value to prevent DIV0 stop_condition = None t0 = time.time() while stop_condition is None: #if i%100 == 0: if 1 == 0: # turned off #t0 = time.time() pred_validation_labels = None true_validation_labels = None prev_validation_epochs_completed = _validation_epochs_completed while _validation_epochs_completed - prev_validation_epochs_completed == 0: # do in mini batches because single GTX970 has insufficient memory to test all at once if _validation_size > 1024*5: validation_batch = get_next_batch(1,1024) else: validation_batch = get_next_batch(1,64) if pred_validation_labels is None: pred_validation_labels = pred_softmax.eval(feed_dict={x: validation_batch[0], y_: validation_batch[1]}) true_validation_labels = validation_batch[1] else: pred_validation_labels = numpy.vstack([pred_validation_labels, pred_softmax.eval(feed_dict={x: validation_batch[0], y_: validation_batch[1]})]) true_validation_labels = numpy.vstack([true_validation_labels, validation_batch[1]]) fpr, tpr, _ = roc_curve(true_validation_labels[:,0], pred_validation_labels[:,0]) roc_auc = auc(fpr, tpr) #check stop condition: perc_chg_auc = (roc_auc - prev_auc) / prev_auc #if perc_chg_auc < 0.005: # stop when auc moving average on validation set changes by <0.5% # stop_condition = 1 prev_auc = roc_auc print("%s, dataset %g, epoch %d, step %d, time elapsed %g, validation roc auc %g, perc chg in auc %g"%(_datasets[dataset_num], dataset_num, _train_epochs_completed, i, time.time()-t0, roc_auc, perc_chg_auc)) t0 = time.time() batch = get_next_batch(0) train_step.run(feed_dict={x: batch[0], y_: batch[1], dropout_on: 1}) if i == 4800: stop_condition = 1 i += 1 pred_test_labels = None true_test_labels = None while _test_epochs_completed == 0: # do testing in mini batches because single GTX970 has insufficient memory to test all at once test_batch = get_next_batch(2, 64) if pred_test_labels is None: pred_test_labels = pred_softmax.eval(feed_dict={x: test_batch[0], y_: test_batch[1]}) true_test_labels = test_batch[1] else: pred_test_labels = numpy.vstack([pred_test_labels, pred_softmax.eval(feed_dict={x: test_batch[0], y_: test_batch[1]})]) true_test_labels = numpy.vstack([true_test_labels, test_batch[1]]) fpr, tpr, _ = roc_curve(true_test_labels[:,0], pred_test_labels[:,0]) # get receiver operating characteristics precision, recall, _ = precision_recall_curve(true_test_labels[:,0], pred_test_labels[:,0]) # get precision recall curve roc_auc = auc(fpr, tpr) prc_auc = auc(recall, precision) print("%s, dataset %g, final test roc auc %g, final test prc auc %g, time elapsed %g seconds"%(_datasets[dataset_num], dataset_num, roc_auc, prc_auc, time.time()-t0)) f=open(file_name,'a') f.write(str(dataset_num) + ',' + str(motif_occ) + ',' + _datasets[dataset_num] + ',' + str(roc_auc) + ',' + str(prc_auc) + ',' + str(time.time()-t0) + '\n') f.close() t0 = time.time()
def main(_): global _train_epochs_completed global _validation_epochs_completed global _test_epochs_completed global _datasets global _validation_size global _test_labels file_name = 'out_' + str(int(time.time())) + '.csv' f = open(file_name, 'w') # clear file f.write('dataset_num,dataset_name,roc_auc\n') f.close() _datasets = utils.remove_non_existing_datafiles(_datasets) for dataset_num in range(0, len(_datasets)): load_ENCODE_k562_dataset(dataset_num) x = tf.placeholder(tf.float32, shape=[None, 101 * 4]) y_ = tf.placeholder(tf.float32, shape=[None, 2]) conv_keep_prob = tf.placeholder(tf.float32) # Create the model x_image = tf.reshape(x, [-1, 101, 4, 1]) # CONVOLUTIONAL LAYER(S) n_conv1 = 64 L_conv1 = 9 maxpool_len1 = 2 conv1 = convolution2d(x_image, n_conv1, [L_conv1, 4], padding='VALID', normalizer_fn=None) conv1_pool = max_pool2d(conv1, [maxpool_len1, 1], [maxpool_len1, 1]) conv1_drop = tf.nn.dropout(conv1_pool, conv_keep_prob) conv1_pool_len = int((101 - L_conv1 + 1) / maxpool_len1) n_conv2 = n_conv1 L_conv2 = 5 maxpool_len2 = int( conv1_pool_len - L_conv2 + 1) # global maxpooling (max-pool across temporal domain) conv2 = convolution2d(conv1_drop, n_conv2, [L_conv2, 1], padding='VALID', normalizer_fn=None) conv2_pool = max_pool2d(conv2, [maxpool_len2, 1], [maxpool_len2, 1]) conv2_drop = tf.nn.dropout(conv2_pool, conv_keep_prob) # LINEAR FC LAYER y_conv = fully_connected(flatten(conv2_drop), 2, activation_fn=None) y_conv_softmax = tf.nn.softmax(y_conv) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) train_step = tf.train.AdamOptimizer().minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) sess.run(tf.initialize_all_variables()) i = 0 prev_auc = 0.0001 # small value to prevent DIV0 prev_train_epochs_compl = 0 stop_condition = None t0 = time.time() this_conv_keep_prob = 0.5 final_keep_prob = 0.75 while stop_condition is None: if i % 1000 == 0: #t0 = time.time() pred_validation_labels = None true_validation_labels = None prev_validation_epochs_completed = _validation_epochs_completed while _validation_epochs_completed - prev_validation_epochs_completed == 0: # do in mini batches because single GTX970 has insufficient memory to test all at once if _validation_size > 1024 * 5: validation_batch = get_next_batch(1, 1024) else: validation_batch = get_next_batch(1, 64) if pred_validation_labels is None: pred_validation_labels = y_conv_softmax.eval( feed_dict={ x: validation_batch[0], y_: validation_batch[1], conv_keep_prob: 1.0 }) true_validation_labels = validation_batch[1] else: pred_validation_labels = numpy.vstack([ pred_validation_labels, y_conv_softmax.eval( feed_dict={ x: validation_batch[0], y_: validation_batch[1], conv_keep_prob: 1.0 }) ]) true_validation_labels = numpy.vstack( [true_validation_labels, validation_batch[1]]) fpr, tpr, _ = roc_curve(true_validation_labels[:, 0], pred_validation_labels[:, 0]) roc_auc = auc(fpr, tpr) perc_chg_auc = (roc_auc - prev_auc) / prev_auc print( "%s, dataset %g, epoch %d, step %d, time elapsed %g, validation roc auc %g, perc chg in auc %g, conv_keep_prob %g" % (_datasets[dataset_num], dataset_num, _train_epochs_completed, i, time.time() - t0, roc_auc, perc_chg_auc, this_conv_keep_prob)) #check stop condition: if i == 3000 or i == 10000 or i == 20000: # increase keep_prob at these iteration numbers (not epochs) if this_conv_keep_prob < final_keep_prob: this_conv_keep_prob += 0.2 if this_conv_keep_prob > final_keep_prob: this_conv_keep_prob = final_keep_prob else: stop_condition = 1 prev_train_epochs_compl = _train_epochs_completed prev_auc = roc_auc t0 = time.time() batch = get_next_batch(0) train_step.run(feed_dict={ x: batch[0], y_: batch[1], conv_keep_prob: this_conv_keep_prob }) i += 1 pred_test_labels = None true_test_labels = None while _test_epochs_completed == 0: # do testing in mini batches because single GTX970 has insufficient memory to test all at once test_batch = get_next_batch(2, 64) if pred_test_labels is None: pred_test_labels = y_conv_softmax.eval(feed_dict={ x: test_batch[0], y_: test_batch[1], conv_keep_prob: 1.0 }) true_test_labels = test_batch[1] else: pred_test_labels = numpy.vstack([ pred_test_labels, y_conv_softmax.eval(feed_dict={ x: test_batch[0], y_: test_batch[1], conv_keep_prob: 1.0 }) ]) true_test_labels = numpy.vstack( [true_test_labels, test_batch[1]]) fpr, tpr, _ = roc_curve(true_test_labels[:, 0], pred_test_labels[:, 0]) roc_auc = auc(fpr, tpr) print("%s, dataset %g, final test roc auc %g" % (_datasets[dataset_num], dataset_num, roc_auc)) f = open(file_name, 'a') f.write( str(dataset_num) + ',' + _datasets[dataset_num] + ',' + str(roc_auc) + '\n') f.close()