#traindata, tradj = load_SIFT1M() trgcn = GCN(sample, output_n, adj=tradj) trgcn.build(lr=0.5, PCA=True) for i in range(3): for j in range(100): loss = trgcn.train_fn(sample) print 'epoch {0}/300 loss: {1}'.format(i*300+j+1, loss) nz = trgcn.infer_fn(sample) trgcn.loss_fn.update(nz) B = trgcn.infer_fn(sample) trgcn.save() #trgcn.load('/mnt/disk1/ImageNett_model_%d' % output_n) #np.save('%d' % output_n, np.sign(nz)) #after = trgcn.infer_fn(sample) #tB = np.dot(gfunc1, B) #sio.savemat('emb', {'B':B}) #B = sio.loadmat('emb')['B'] #trgcn.load('/mnt/disk1/ImageNett_model_%d' % output_n) B = np.sign(B) #sio.savemat('/mnt/disk1/ImageNet1M/ImageNettiny/%d.mat' % output_n, {'Z': Z}) #B = np.sign(np.dot(gfunc1, Z)) tB = np.sign(np.dot(gfunc, B)) #ttgcn.build_infer_fn() #B = np.sign(trgcn.infer_fn(traindata)) #tB = np.sign(ttgcn.infer_fn(testdata))
def train_step(model_file): # Set random seed seed = 123 np.random.seed(seed) tf.set_random_seed(seed) dirname = FLAGS.dataset + model_file + '/' print(dirname) # Load data namelist_path = FLAGS.dataset + 'sub_list_new.txt' adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask = load_data( FLAGS.hemisphere, namelist=namelist_path, MPM=True) # neighbor_mask = 50*np.load( FLAGS.modeldir+'neighbor_mask_{}.npy'.format(FLAGS.hemisphere)) namelist = [ str(name).replace("\n", "") for name in open(namelist_path, 'r').readlines() ] # mpm = np.max(np.load( FLAGS.modeldir+'MPM_{}.npy'.format(FLAGS.hemisphere))[:,:210], axis=1) # train_mask = np.array([False]*len(mpm)) # train_mask[mpm>0.5] = True # Some preprocessing adj = sparse_to_tuple(adj) for i in range(len(features)): features[i] = preprocess_features(features[i]) support = chebyshev_polynomials(adj, FLAGS.max_degree) num_supports = 1 + FLAGS.max_degree # Define placeholders/ placeholders = { 'support': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)], 'features': tf.sparse_placeholder(tf.float32, shape=tf.constant(features[0].shape, dtype=tf.float64)), 'labels': tf.placeholder(tf.float32, shape=(None, y_train.shape[1])), 'labels_mask': tf.placeholder(tf.int32), 'dropout': tf.placeholder_with_default(FLAGS.dropout, shape=()), 'num_features_nonzero': tf.placeholder(tf.int32), # helper variable for sparse dropout 'gradient_adj': [tf.sparse_placeholder(tf.float32)], 'gradient': tf.placeholder(tf.bool) } # Create model model_name = 'model_{}'.format(FLAGS.hemisphere) print('model name:', model_name) model = GCN(placeholders, input_dim=features[0].shape[1], layer_num=FLAGS.layer_num, logging=True, name=model_name) # Initialize session sess = tf.Session() # Init variables sess.run(tf.global_variables_initializer()) # Define model evaluation function def evaluate(features, support, labels, mask, adj, gradient, placeholders): t_test = time.time() feed_dict_val = construct_feed_dict(features, support, labels, mask, adj, gradient, placeholders) outs_val = sess.run([model.loss, model.dice, model.outputs], feed_dict=feed_dict_val) return outs_val[0], outs_val[1], outs_val[2], (time.time() - t_test) def dynamic_learning_rate(epoch): # learning_rate = FLAGS.basic_learning_rate * 10**(-3 * epoch/FLAGS.epochs) learning_rate = FLAGS.basic_learning_rate * (1 - epoch / FLAGS.epochs) return learning_rate # def dynamic_training_mask(mpm, epoch): # if (epoch/FLAGS.epochs)>0.5: # train_mask = [True]*len(mpm) # else: # thr = 65-130*epoch/FLAGS.epochs # train_mask = np.array([False]*len(mpm)) # train_mask[mpm>thr] = True # return train_mask cost_train, acc_train, dc_train = [], [], [] cost_val, acc_val, dc_val = [], [], [] # Train model print('length', len(features)) for epoch in range(FLAGS.epochs): numlist = np.arange(0, FLAGS.train_num, 1) np.random.shuffle(numlist) FLAGS.learning_rate = dynamic_learning_rate(epoch) # train_mask = dynamic_training_mask(mpm, epoch) print('_____leaning rate', FLAGS.learning_rate, 'epoch:', epoch) for i in numlist: t = time.time() print('training sample: ', i) # Construct feed dictionary feed_dict = construct_feed_dict(features[i], support, y_train, train_mask, adj, False, placeholders) # Training step outs = sess.run([model.opt_op, model.loss, model.dice], feed_dict=feed_dict) cost_train.append(outs[1]) dice_train.append(outs[2]) # Validation validnum = np.random.randint(FLAGS.validate_num) + FLAGS.train_num cost_val, dice_val, _, tt = evaluate(features[validnum], support, y_val, val_mask, adj, False, placeholders) cost_val.append(cost_val) dc_val.append(dice_val) # Print results print("Epoch:", '%04d' % (epoch + 1), "train_loss=", "{:.5f}".format(outs[1]), "train_dice=", "{:.3f}".format(outs[2]), "val_loss=", "{:.5f}".format(cost_val), "val_dice=", "{:.3f}".format(dice_val), "time=", "{:.5f}".format(tt)) # if epoch > FLAGS.early_stopping and cost_val[-1] > np.mean(cost_val[-(FLAGS.early_stopping+1):-1]): # print("Early stopping...") # break model.save(sess=sess, path=dirname) np.savetxt(dirname + 'cost_val.txt', cost_val, fmt='%9.5f', delimiter=',') np.savetxt(dirname + 'cost_train.txt', cost_train, fmt='%9.5f', delimiter=',') np.savetxt(dirname + 'dc_val.txt', dc_val, fmt='%9.5f', delimiter=',') np.savetxt(dirname + 'dc_train.txt', dc_train, fmt='%9.5f', delimiter=',') print("Optimization Finished!") # model.load(sess) # testave = [] # # Testing # for i in range(len(features)): # test_cost, test_acc, test_dice, prediction, test_duration = evaluate(features[i], support, y_test, test_mask, neighbor_mask, placeholders) # print("Test set results:", "cost=", "{:.5f}".format(test_cost), # "accuracy=", "{:.3f}_{:.3f}".format(test_acc, test_dice), "time=", "{:.5f}".format(test_duration)) # if i>=FLAGS.train_num: # testave.append(test_dice) # # print(prediction.shape) # path = dirname+'{}.npy'.format(namelist[i]) # np.save(path, prediction) # np.savetxt(dirname+'dc_test.txt', testave, fmt='%7.4f', delimiter=',') # print('average_test_dice:', np.array(testave).mean()) # Testing and resting # #load data # f = open('/DATA/232/lma/data/HCP_test/sub_list.txt','r') # namelist = [str(int(name)) for name in f.readlines()] # feature_path_list = [] # for name in namelist: # feature_path_list.append('/DATA/232/lma/data/HCP_test/{}/{}_{}_probtrackx_omatrix2/finger_print_fiber.npz'.format(name, name, FLAGS.hemisphere)) # adj, features2, y_train, y_val, y_test, train_mask, val_mask, test_mask = load_data(FLAGS.hemisphere,pathlist= feature_path_list) # # Some preprocessing # for i in range(len(features2)): # features2[i] = preprocess_features(features2[i]) # # prediction # testave = [] # for i in range(len(features2)): # test_cost, test_acc, test_dice, prediction, test_duration = evaluate(features2[i], support, y_test, test_mask, neighbor_mask,placeholders) # print("Test set results:", "cost=", "{:.5f}".format(test_cost), # "accuracy=", "{:.5f}".format(test_dice), "time=", "{:.5f}".format(test_duration)) # testave.append(test_dice) # # print(prediction.shape) # path = dirname+'test_{}.npy'.format(namelist[i]) # np.save(path, prediction) # print('average_test/retest_acc:', np.array(testave).mean()) # #Resesting # f = open('/DATA/232/lma/data/HCP_retest/sub_list.txt','r') # namelist = [str(int(name)) for name in f.readlines()] # feature_path_list = [] # for name in namelist: # feature_path_list.append('/DATA/232/lma/data/HCP_retest/{}/{}_{}_probtrackx_omatrix2/finger_print_fiber.npz'.format(name, name, FLAGS.hemisphere)) # adj, features3, y_train, y_val, y_test, train_mask, val_mask, test_mask = load_data(FLAGS.hemisphere, pathlist= feature_path_list) # # Some preprocessing # for i in range(len(features3)): # features3[i] = preprocess_features(features3[i]) # #prediction # testave = [] # for i in range(len(features3)): # test_cost, test_acc, test_dice, prediction, test_duration = evaluate(features3[i], support, y_test, test_mask, neighbor_mask, placeholders) # print("Test set results:", "cost=", "{:.5f}".format(test_cost), # "accuracy=", "{:.5f}".format(test_dice), "time=", "{:.5f}".format(test_duration)) # testave.append(test_dice) # # print(prediction.shape) # path = dirname+'retest_{}.npy'.format(namelist[i]) # np.save(path, prediction) # print('average_test/retest_acc:', np.array(testave).mean()) return None
train_loss = open('tmp/train_loss_record.txt', 'a') train_loss.write('Start training, lr = %f\n' % (FLAGS.learning_rate)) pkl = pickle.load(open('data/utils/eccv_final_version.dat', 'rb')) train_number = data.number for epoch in range(FLAGS.epochs): all_loss = np.zeros(train_number, dtype='float32') for iters in range(train_number): # Fetch training data img_inp, y_train, data_id = data.fetch() feed_dict = construct_feed_dict(img_inp, pkl, y_train, placeholders) # Training step _, dists = sess.run([model.opt_op, model.loss], feed_dict=feed_dict) all_loss[iters] = dists mean_loss = np.mean(all_loss[np.where(all_loss)]) print 'Epoch %d, Iteration %d' % (epoch + 1, iters + 1) print 'Mean loss = %f, iter loss = %f, %d' % (mean_loss, dists, data.queue.qsize()) # Save model model.save(sess) train_loss.write('Epoch %d, loss %f\n' % (epoch + 1, mean_loss)) train_loss.flush() # evaluate one model out1, out2, out3 = sess.run([model.output1, model.output2, model.output3], feed_dict=feed_dict) evaluate(y_train, out1, out2, out3) data.shutdown() print 'CNN-GCN Optimization Finished!'