def get_model(model_str, placeholders, num_features, num_nodes, features_nonzero): model = None if model_str == 'gcn_ae': model = GCNModelAE(placeholders, num_features, features_nonzero) elif model_str == 'gcn_vae': model = GCNModelVAE(placeholders, num_features, num_nodes, features_nonzero) return model
def gae_for(args): print("Using {} dataset".format(args.dataset_str)) adj, features = load_data(args.dataset_str) # print(features) # exit(0) n_nodes, feat_dim = features.shape print("#nodes={}".format(n_nodes)) # Store original adjacency matrix (without diagonal entries) for later print( "Store original adjacency matrix (without diagonal entries) for later..." ) adj_orig = adj adj_orig = adj_orig - sp.dia_matrix( (adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape) adj_orig.eliminate_zeros() print("Sample the edges for training and testing...") adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges( adj) adj = adj_train # Some preprocessing print("Some preprocessing...") adj_norm = preprocess_graph(adj) adj_label = adj_train + sp.eye(adj_train.shape[0]) # adj_label = sparse_to_tuple(adj_label) adj_label = torch.FloatTensor(adj_label.toarray()) pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum() norm = adj.shape[0] * adj.shape[0] / float( (adj.shape[0] * adj.shape[0] - adj.sum()) * 2) model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout) optimizer = optim.Adam(model.parameters(), lr=args.lr) hidden_emb = None for epoch in range(args.epochs): t = time.time() model.train() optimizer.zero_grad() recovered, mu, logvar = model(features, adj_norm) pos_weight = torch.Tensor([pos_weight]) loss = loss_function(preds=recovered, labels=adj_label, mu=mu, logvar=logvar, n_nodes=n_nodes, norm=norm, pos_weight=pos_weight) loss.backward() cur_loss = loss.item() optimizer.step() hidden_emb = mu.data.numpy() roc_curr, ap_curr = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false) print("Epoch:", '%04d' % (epoch + 1), "train_loss=", "{:.5f}".format(cur_loss), "val_ap=", "{:.5f}".format(ap_curr), "time=", "{:.5f}".format(time.time() - t)) print("Optimization Finished!") roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) print('Test ROC score: ' + str(roc_score)) print('Test AP score: ' + str(ap_score))
'dropout': tf.placeholder_with_default(0., shape=()) } num_nodes = adj.shape[0] features = sparse_to_tuple(features.tocoo()) num_features = features[2][1] features_nonzero = features[1].shape[0] # Create model model = None if model_str == 'gcn_ae': model = GCNModelAE(placeholders, num_features, features_nonzero, FLAGS.hidden1, FLAGS.hidden2, FLAGS.hidden3) elif model_str == 'gcn_vae': model = GCNModelVAE(placeholders, num_features, num_nodes, features_nonzero, FLAGS.hidden1, FLAGS.hidden2) pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum() norm = adj.shape[0] * adj.shape[0] / float( (adj.shape[0] * adj.shape[0] - adj.sum()) * 2) # Optimizer with tf.name_scope('optimizer'): if model_str == 'gcn_ae': opt = OptimizerAE(preds=model.reconstructions, labels=tf.reshape( tf.sparse_tensor_to_dense( placeholders['adj_orig'], validate_indices=False), [-1]), pos_weight=pos_weight, norm=norm,
placeholders = { 'features': tf.sparse_placeholder(tf.float32, shape=(None, 3344)), 'adj': tf.sparse_placeholder(tf.float32, shape=(None, 3344)), 'adj_orig': tf.sparse_placeholder(tf.float32, shape=(None, 3344)), 'dropout': tf.placeholder_with_default(0., shape=()) } # How much to weigh positive examples (true edges) in cost print_function # Want to weigh less-frequent classes higher, so as to prevent model output bias # pos_weight = (num. negative samples / (num. positive samples) pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum() # normalize (scale) average weighted cost norm = adj.shape[0] * adj.shape[0] / float( (adj.shape[0] * adj.shape[0] - adj.sum()) * 2) # Create VAE model model = GCNModelVAE(placeholders, num_features, num_nodes, features_nonzero, HIDDEN1_DIM, HIDDEN2_DIM) opt = OptimizerVAE(preds=model.reconstructions, labels=tf.reshape( tf.sparse_tensor_to_dense(placeholders['adj_orig'], validate_indices=False), [-1]), model=model, num_nodes=num_nodes, pos_weight=pos_weight, norm=norm, learning_rate=LEARNING_RATE) # Calculate ROC AUC def get_roc_score(edges_pos, edges_neg, emb=None):
def gae_for(args): print("Using {} dataset".format(args.dataset_str)) adj, features = load_data(args.dataset_str) features = features.to(args.device) n_nodes, feat_dim = features.shape # Store original adjacency matrix (without diagonal entries) for later adj_orig = adj adj_orig = adj_orig - sp.dia_matrix( (adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape) adj_orig.eliminate_zeros() adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges( adj) adj = adj_train # Some preprocessing adj_norm = preprocess_graph(adj) adj_norm = adj_norm.to(args.device) adj_label = adj_train + sp.eye(adj_train.shape[0]) # adj_label = sparse_to_tuple(adj_label) adj_label = torch.FloatTensor(adj_label.toarray()) adj_orig_tile = adj_label.unsqueeze(2).repeat(1, 1, args.K) adj_orig_tile = adj_orig_tile.to(args.device) pos_weight = torch.tensor( float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum()).float().to(device=args.device) norm = adj.shape[0] * adj.shape[0] / float( (adj.shape[0] * adj.shape[0] - adj.sum()) * 2) psi_input_dim = args.noise_dim + feat_dim logv_input_dim = feat_dim model = GCNModelVAE(psi_input_dim, logv_input_dim, args.hidden1, args.hidden2, args.dropout, args.K, args.J, args.noise_dim, args.device).to(args.device) optimizer = optim.Adam(model.parameters(), lr=args.lr) for epoch in range(args.epochs): warm_up = torch.min(torch.FloatTensor([epoch / 300, 1])).to(args.device) t = time.time() model.train() optimizer.zero_grad() reconstruct_iw, log_prior_iw, log_H_iw, psi_iw_vec = model( features, adj_norm) hidden_emb = psi_iw_vec.data.contiguous().cpu().numpy() loss = loss_function(reconstructed_iw=reconstruct_iw, log_prior_iw=log_prior_iw, log_H_iw=log_H_iw, adj_orig_tile=adj_orig_tile, nodes=n_nodes, K=args.K, pos_weight=pos_weight, norm=norm, warm_up=warm_up, device=args.device) loss.backward() cur_loss = loss.item() optimizer.step() roc_score_val, ap_score_val = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false) roc_score_test, ap_score_test = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) print('Epoch:', '%04d ---> ' % (epoch + 1), 'training_loss = {:.5f} '.format(cur_loss), 'val_AP = {:.5f} '.format(ap_score_val), 'val_ROC = {:.5f} '.format(roc_score_val), 'test_AP = {:.5f} '.format(ap_score_test), 'test_ROC = {:.5f} '.format(roc_score_test), 'time = {:.5f} '.format(time.time() - t)) writer.add_scalar('Loss/train_loss', cur_loss, epoch) writer.add_scalar('Average Precision/test', ap_score_test, epoch) writer.add_scalar('Average Precision/val', ap_score_val, epoch) writer.add_scalar('Area under Roc(AUC)/test', roc_score_test, epoch) writer.add_scalar('Area under Roc(AUC)/val', roc_score_val, epoch) print("Optimization Finished!")
def gae_for(args, iter='0.txt'): # print("Using {} dataset".format(args.ds)) # adj_cd, features = load_data(args.ds) 'Load features!' if args.ds.startswith('tf'): if args.labels == 'y': adj_cd, adj_dd, features, tags_nodes = my_load_data_tfidf_semi( args.wmd) else: adj_cd, adj_dd, features = my_load_data_tfidf(args.wmd) else: # if args.labels == 'y': adj_cd, adj_dd, features, tags_nodes = my_load_data_p2v_semi( args.wmd) else: adj_cd, adj_dd, features = my_load_data_p2v(args.wmd) # adj_cd, adj_dd, features = my_load_data_p2v() 'Load test adjacency matrix' adj_test = load_test() # adj_test = load_test_10_percent(iter) n_nodes, feat_dim = features.shape # Store original adjacency matrix (without diagonal entries) for later adj_orig_cd = adj_cd 'do again for adj_dd' adj_orig_dd = adj_dd adj_train_cd, train_edges, val_edges, val_edges_false = mask_train_edges( adj_cd) 'do again for adj_dd' adj_train_dd, train_edges_dd, _, _ = mask_train_edges(adj_dd) # adj_cd = adj_train_cd adj_dd = adj_train_dd test_edges, test_edges_false = make_test_edges(adj_train_cd, adj_test) # Some preprocessing: calculate norm adj_norm_cd = preprocess_graph(adj_cd) 'For loss function: add diag values' adj_label_cd = adj_train_cd + sp.eye(adj_train_cd.shape[0]) adj_label_cd = torch.FloatTensor(adj_label_cd.toarray()) pos_weight_cd = float(adj_cd.shape[0] * adj_cd.shape[0] - adj_cd.sum()) / adj_cd.sum() norm_cd = adj_cd.shape[0] * adj_cd.shape[0] / float( (adj_cd.shape[0] * adj_cd.shape[0] - adj_cd.sum()) * 2) 'do it again for adj_dd' adj_norm_dd = preprocess_graph(adj_dd) adj_label_dd = adj_train_dd + sp.eye(adj_train_dd.shape[0]) adj_label_dd = torch.FloatTensor(adj_label_dd.toarray()) pos_weight_dd = float(adj_dd.shape[0] * adj_dd.shape[0] - adj_dd.sum()) / adj_dd.sum() norm_dd = adj_dd.shape[0] * adj_dd.shape[0] / float( (adj_dd.shape[0] * adj_dd.shape[0] - adj_dd.sum()) * 2) if args.labels == 'y': model = GCNModelVAE_Semi(feat_dim, args.hidden1, args.hidden2, args.dropout, args.class_dim) else: model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout) optimizer = optim.Adam(model.parameters(), lr=args.lr) print('Now start training...') hidden_emb = None for epoch in range(args.epochs): t = time.time() model.train() optimizer.zero_grad() # import pdb;pdb.set_trace if args.labels == 'y': recovered, mu, logvar, pred_nodes = model( features, [adj_norm_cd, adj_norm_dd]) loss = loss_function_relation_semi(preds=recovered, labels=(adj_label_cd, adj_label_dd), mu=mu, logvar=logvar, n_nodes=n_nodes, norm=(norm_cd, norm_dd), pos_weight=(pos_weight_cd, pos_weight_dd), pred_nodes=pred_nodes, tags_nodes=tags_nodes) else: recovered, mu, logvar = model(features, [adj_norm_cd, adj_norm_dd]) loss = loss_function_relation(preds=recovered, labels=(adj_label_cd, adj_label_dd), mu=mu, logvar=logvar, n_nodes=n_nodes, norm=(norm_cd, norm_dd), pos_weight=(pos_weight_cd, pos_weight_dd)) loss.backward() cur_loss = loss.item() optimizer.step() hidden_emb = mu.data.numpy() acc_curr, p, r, f1, map_curr, roc_curr = my_eval( hidden_emb, (adj_orig_cd, adj_orig_dd), val_edges, val_edges_false) print("Epoch:", '%04d' % (epoch + 1), "train_loss=", "{:.5f}".format(cur_loss), "val_ap=", "{:.5f}".format(map_curr), "val_ac=", "{:.5f}".format(acc_curr), "time=", "{:.5f}".format(time.time() - t)) print("Optimization Finished!") acc_score, p, r, f1, map_score, roc_score = my_eval_test( hidden_emb, (adj_orig_cd, adj_orig_dd), test_edges, test_edges_false) # print('Test ROC score: ' + str(roc_score)) # print('Test AP score: ' + str(ap_score)) # print ("Test accuracy ", "{:.5f}".format(acc_score)) # print ('P {:.5f}, R {:.5f}, F1 {:.5f}'.format(p,r,f1)) print('Acc, P, R, F1, MAP, AUC') print('{:5f},{:5f},{:5f},{:5f},{:5f},{:5f}'.format(acc_score, p, r, f1, map_score, roc_score)) return acc_score, p, r, f1, map_score, roc_score
# Transfer to GPU n_nodes = np.array(features_bs).shape[0] feat_dim = int(adj_bs.shape[1] / dim) adj_norm = preprocess_graph(adj_bs) adj_label = adj_bs + sp.eye(adj_bs.shape[0]) # adj_label = sparse_to_tuple(adj_label) adj_label = torch.FloatTensor(adj_label.toarray()) # adj_label = torch.LongTensor(adj_label.toarray()) pos_weight = float(adj_bs.shape[0] * adj_bs.shape[0] - adj_bs.sum()) / adj_bs.sum() norm = adj_bs.shape[0] * adj_bs.shape[0] / float( (adj_bs.shape[0] * adj_bs.shape[0] - adj_bs.sum()) * 2) model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout) model = torch.nn.DataParallel( model, device_ids=[0] ) ################################################################### model.cuda() # parallel_model = DataParallelModel(model, device_ids=[0]) # parallel_loss = DataParallelCriterion(loss_function, device_ids=[0]) # optimizer = optim.Adam(model.parameters(), lr=args.lr) # parallel_model.train() # optimizer.zero_grad() # recovered, mu, logvar = parallel_model(features_bs, adj_norm) # loss = loss_function(preds=recovered, # labels=adj_label, # mu=mu, # logvar=logvar, # n_nodes=n_nodes,
features_nonzero = features[1].shape[0] sess = tf.Session() # Create model model = None if FLAGS.multihead_attn: model = MultiHeadedGAE(placeholders, num_features, features_nonzero) else: if model_str == 'gcn_ae': model = GCNModelAE(placeholders, num_features, features_nonzero, FLAGS.attention, FLAGS.bilinear) elif model_str == 'gcn_vae': model = GCNModelVAE(placeholders, num_features, num_nodes, features_nonzero, FLAGS.attention) pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum() norm = adj.shape[0] * adj.shape[0] / float( (adj.shape[0] * adj.shape[0] - adj.sum()) * 2) # Optimizer with tf.name_scope('optimizer'): if model_str == 'gcn_ae': opt = OptimizerAE( preds=model.reconstructions, labels=tf.reshape( tf.sparse_tensor_to_dense( placeholders[ 'adj_orig'], # adj_orig in the original implementation validate_indices=False),
def gae_for(args): print("Using {} dataset".format(args.dataset_str)) adj, features, y_test, tx, ty, test_maks, true_labels = load_data( args.dataset_str) n_nodes, feat_dim = features.shape # Store original adjacency matrix (without diagonal entries) for later adj_orig = adj adj_orig = adj_orig - sp.dia_matrix( (adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape) adj_orig.eliminate_zeros() adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges( adj) adj = adj_train # Before proceeding further, make the structure for doing deepWalk if args.dw == 1: print('Using deepWalk regularization...') G = load_edgelist_from_csr_matrix(adj_orig, undirected=True) print("Number of nodes: {}".format(len(G.nodes()))) num_walks = len(G.nodes()) * args.number_walks print("Number of walks: {}".format(num_walks)) data_size = num_walks * args.walk_length print("Data size (walks*length): {}".format(data_size)) # Some preprocessing adj_norm = preprocess_graph(adj) adj_label = adj_train + sp.eye(adj_train.shape[0]) # adj_label = sparse_to_tuple(adj_label) # adj_label = torch.DoubleTensor(adj_label.toarray()) adj_label = torch.FloatTensor(adj_label.toarray()) pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum() norm = adj.shape[0] * adj.shape[0] / float( (adj.shape[0] * adj.shape[0] - adj.sum()) * 2) if args.model == 'gcn_vae': model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout) else: model = GCNModelAE(feat_dim, args.hidden1, args.hidden2, args.dropout) optimizer = optim.Adam(model.parameters(), lr=args.lr) if args.dw == 1: sg = SkipGram(args.hidden2, adj.shape[0]) optimizer_dw = optim.Adam(sg.parameters(), lr=args.lr_dw) # Construct the nodes for doing random walk. Doing it before since the seed is fixed nodes_in_G = list(G.nodes()) chunks = len(nodes_in_G) // args.number_walks random.Random().shuffle(nodes_in_G) hidden_emb = None for epoch in tqdm(range(args.epochs)): t = time.time() model.train() optimizer.zero_grad() z, mu, logvar = model(features, adj_norm) # After back-propagating gae loss, now do the deepWalk regularization if args.dw == 1: sg.train() if args.full_number_walks > 0: walks = build_deepwalk_corpus(G, num_paths=args.full_number_walks, path_length=args.walk_length, alpha=0, rand=random.Random(SEED)) else: walks = build_deepwalk_corpus_iter( G, num_paths=args.number_walks, path_length=args.walk_length, alpha=0, rand=random.Random(SEED), chunk=epoch % chunks, nodes=nodes_in_G) for walk in walks: if args.context == 1: # Construct the pairs for predicting context node # for each node, treated as center word curr_pair = (int(walk[center_node_pos]), []) for center_node_pos in range(len(walk)): # for each window position for w in range(-args.window_size, args.window_size + 1): context_node_pos = center_node_pos + w # make soure not jump out sentence if context_node_pos < 0 or context_node_pos >= len( walk ) or center_node_pos == context_node_pos: continue context_node_idx = walk[context_node_pos] curr_pair[1].append(int(context_node_idx)) else: # first item in the walk is the starting node curr_pair = (int(walk[0]), [ int(context_node_idx) for context_node_idx in walk[1:] ]) if args.ns == 1: neg_nodes = [] pos_nodes = set(walk) while len(neg_nodes) < args.walk_length - 1: rand_node = random.randint(0, n_nodes - 1) if rand_node not in pos_nodes: neg_nodes.append(rand_node) neg_nodes = torch.from_numpy(np.array(neg_nodes)).long() # Do actual prediction src_node = torch.from_numpy(np.array([curr_pair[0]])).long() tgt_nodes = torch.from_numpy(np.array(curr_pair[1])).long() optimizer_dw.zero_grad() log_pos = sg(src_node, tgt_nodes, neg_sample=False) if args.ns == 1: loss_neg = sg(src_node, neg_nodes, neg_sample=True) loss_dw = log_pos + loss_neg else: loss_dw = log_pos loss_dw.backward(retain_graph=True) cur_dw_loss = loss_dw.item() optimizer_dw.step() loss = loss_function(preds=model.dc(z), labels=adj_label, mu=mu, logvar=logvar, n_nodes=n_nodes, norm=norm, pos_weight=pos_weight) loss.backward() cur_loss = loss.item() optimizer.step() hidden_emb = mu.data.numpy() roc_curr, ap_curr = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false) if args.dw == 1: tqdm.write( "Epoch: {}, train_loss_gae={:.5f}, train_loss_dw={:.5f}, val_ap={:.5f}, time={:.5f}" .format(epoch + 1, cur_loss, cur_dw_loss, ap_curr, time.time() - t)) else: tqdm.write( "Epoch: {}, train_loss_gae={:.5f}, val_ap={:.5f}, time={:.5f}". format(epoch + 1, cur_loss, ap_curr, time.time() - t)) if (epoch + 1) % 10 == 0: tqdm.write("Evaluating intermediate results...") kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb) predict_labels = kmeans.predict(hidden_emb) cm = clustering_metrics(true_labels, predict_labels) cm.evaluationClusterModelFromLabel(tqdm) roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) tqdm.write('ROC: {}, AP: {}'.format(roc_score, ap_score)) np.save('logs/emb_epoch_{}.npy'.format(epoch + 1), hidden_emb) tqdm.write("Optimization Finished!") roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) tqdm.write('Test ROC score: ' + str(roc_score)) tqdm.write('Test AP score: ' + str(ap_score)) kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb) predict_labels = kmeans.predict(hidden_emb) cm = clustering_metrics(true_labels, predict_labels) cm.evaluationClusterModelFromLabel(tqdm) if args.plot == 1: cm.plotClusters(tqdm, hidden_emb, true_labels)
def gae_for(args): print("Using {} dataset".format(args.dataset_str)) adj, features, y_test, tx, ty, test_maks, true_labels = load_data(args.dataset_str) n_nodes, feat_dim = features.shape # Store original adjacency matrix (without diagonal entries) for later adj_orig = adj adj_orig = adj_orig - sp.dia_matrix((adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape) adj_orig.eliminate_zeros() adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(adj) adj = adj_train # Some preprocessing adj_norm = preprocess_graph(adj) adj_label = adj_train + sp.eye(adj_train.shape[0]) # adj_label = sparse_to_tuple(adj_label) # adj_label = torch.DoubleTensor(adj_label.toarray()) adj_label = torch.FloatTensor(adj_label.toarray()) pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum() norm = adj.shape[0] * adj.shape[0] / float((adj.shape[0] * adj.shape[0] - adj.sum()) * 2) if args.model == 'gcn_vae': model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout) else: model = GCNModelAE(feat_dim, args.hidden1, args.hidden2, args.dropout) optimizer = optim.Adam(model.parameters(), lr=args.lr) hidden_emb = None for epoch in tqdm(range(args.epochs)): t = time.time() model.train() optimizer.zero_grad() z, mu, logvar = model(features, adj_norm) loss = loss_function(preds=model.dc(z), labels=adj_label, mu=mu, logvar=logvar, n_nodes=n_nodes, norm=norm, pos_weight=pos_weight) loss.backward() cur_loss = loss.item() optimizer.step() hidden_emb = mu.data.numpy() roc_curr, ap_curr = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false) tqdm.write("Epoch: {}, train_loss_gae={:.5f}, val_ap={:.5f}, time={:.5f}".format( epoch + 1, cur_loss, ap_curr, time.time() - t)) if (epoch + 1) % 10 == 0: tqdm.write("Evaluating intermediate results...") kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb) predict_labels = kmeans.predict(hidden_emb) cm = clustering_metrics(true_labels, predict_labels) cm.evaluationClusterModelFromLabel(tqdm) roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) tqdm.write('ROC: {}, AP: {}'.format(roc_score, ap_score)) np.save('logs/emb_epoch_{}.npy'.format(epoch + 1), hidden_emb) tqdm.write("Optimization Finished!") roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) tqdm.write('Test ROC score: ' + str(roc_score)) tqdm.write('Test AP score: ' + str(ap_score)) kmeans = KMeans(n_clusters=args.n_clusters, random_state=0).fit(hidden_emb) predict_labels = kmeans.predict(hidden_emb) cm = clustering_metrics(true_labels, predict_labels) cm.evaluationClusterModelFromLabel(tqdm) if args.plot == 1: cm.plotClusters(tqdm, hidden_emb, true_labels)
# local_batch = local_batch.cuda() n_nodes = np.array(features_bs).shape[0] feat_dim = batch_size adj_norm = preprocess_graph(adj_bs) adj_label = adj_bs + sp.eye(adj_bs.shape[0]) # adj_label = sparse_to_tuple(adj_label) adj_label = torch.FloatTensor(adj_label.toarray()) # adj_label = torch.LongTensor(adj_label.toarray()) pos_weight = float(adj_bs.shape[0] * adj_bs.shape[0] - adj_bs.sum()) / adj_bs.sum() norm = adj_bs.shape[0] * adj_bs.shape[0] / float( (adj_bs.shape[0] * adj_bs.shape[0] - adj_bs.sum()) * 2) model = GCNModelVAE(feat_dim, args.hidden1, args.hidden2, args.dropout) optimizer = optim.Adam(model.parameters(), lr=args.lr) hidden_emb = None t = time.time() model.train() optimizer.zero_grad() recovered, mu, logvar = model(features_bs, adj_norm) loss = loss_function(preds=recovered, labels=adj_label, mu=mu, logvar=logvar, n_nodes=n_nodes, norm=norm, pos_weight=pos_weight) loss.backward()
num_features = adj.shape[1] # Define placeholders placeholders = { 'features': tf.placeholder(tf.float32, [args.batch_size, num_nodes, num_features]), 'adj_norm': tf.placeholder(tf.float32, [args.batch_size, num_nodes, num_nodes]), 'adj_orig': tf.placeholder(tf.float32, [args.batch_size, num_nodes, num_nodes]), 'dropout': tf.placeholder_with_default(tf.cast(0., tf.float32), shape=()) } # Create model model = GCNModelVAE(placeholders, num_features, num_nodes, args) # Initialize session sess = tf.Session() # Score model saver = tf.train.Saver() model_name = './models/brain_vgae_ignore_negative_100_50_5_autoencoder=False.ckpt' with tf.Session() as sess: saver.restore(sess, model_name) features_batch = np.zeros([args.batch_size, num_nodes, num_features], dtype=np.float32) for i in features_batch: np.fill_diagonal(i, 1.)
cnt = 0 adj_feat_list = load_list(args.dataset, args.K) partition = {"train": adj_feat_list} # Parameters train_params = {'dim': dim, 'adj_dim': (dim, dim), 'feature_dim': (dim, 1), 'batch_size': batch_size, 'shuffle': False, 'path': path} training_generator = DataGenerator(partition['train'], **train_params) print("the training data is ready") model = GCNModelVAE(batch_size, args.hidden1, args.hidden2, args.dropout) model.cuda() ################################################################### optimizer = optim.Adam(model.parameters(), lr=args.lr) # scheduler = ReduceLROnPlateau(optimizer, 'min') scheduler = MultiStepLR(optimizer, milestones=[50, 80], gamma=0.1) loss_record = [] start_time = time.time() for epoch in range(epochs): scheduler.step() # Training # numm=0 cur_loss_list = [] for adj_bs, features_bs in training_generator: # Transfer to GPU
'adj': tf.sparse_placeholder(tf.float32), 'adj_orig': tf.sparse_placeholder(tf.float32), 'features': tf.sparse_placeholder(tf.float32,shape=tf.constant(A2[2], dtype=tf.int64)), }] dropout = tf.placeholder(tf.float32) num_nodes = [S1_ori[2][0],S2_ori[2][0]] num_features = [A1[2][1],A2[2][1]] features_nonzero = [A1[1].shape[0],A2[1].shape[0]] # Create model #map_model = Discriminator() # model = None if model_str == 'gcn_ae': model = GCNModelAE(placeholders, num_features = num_features, features_nonzero = features_nonzero,dropout=dropout,flag=True) elif model_str == 'gcn_vae': model = GCNModelVAE(placeholders, num_features = num_features,num_nodes=num_nodes, features_nonzero = features_nonzero,dropout=dropout) pos_weight1 = float(S1.shape[0] * S1.shape[0] - S1.sum()) / S1.sum() norm1 = S1.shape[0] * S1.shape[0] / float((S1.shape[0] * S1.shape[0] - S1.sum()) * 2) pos_weight2 = float(S2.shape[0] * S2.shape[0] - S2.sum()) / S2.sum() norm2 = S2.shape[0] * S2.shape[0] / float((S2.shape[0] * S2.shape[0] - S2.sum()) * 2) pos_weight = [pos_weight1,pos_weight2] norm = [norm1,norm2] # Optimizer with tf.name_scope('optimizer'): if model_str == 'gcn_ae': opt = OptimizerAE(preds=[model.reconstructions1,model.reconstructions2], # labels=tf.reshape(tf.sparse_tensor_to_dense(placeholders['adj_orig'],
def train_gcn(features, adj_train, train_edges, train_edges_false, test_edges, test_edges_false): # Settings flags = tf.app.flags FLAGS = flags.FLAGS flags.DEFINE_float('learning_rate', 0.005, 'Initial learning rate.') flags.DEFINE_integer('epochs', 200, 'Number of epochs to train.') flags.DEFINE_integer('hidden1', 96, 'Number of units in hidden layer 1.') flags.DEFINE_integer('hidden2', 48, 'Number of units in hidden layer 2.') flags.DEFINE_float('weight_decay', 0., 'Weight for L2 loss on embedding matrix.') flags.DEFINE_float('dropout', 0., 'Dropout rate (1 - keep probability).') flags.DEFINE_string('model', 'gcn_vae', 'Model string.') flags.DEFINE_integer('features', 1, 'Whether to use features (1) or not (0).') model_str = FLAGS.model #1-dim index array, used in cost function to only focus on those interactions with high confidence mask_index = construct_optimizer_list(features.shape[0], train_edges, train_edges_false) # Store original adjacency matrix (without diagonal entries) for later adj_orig = adj_train adj_orig = adj_orig - sp.dia_matrix( (adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape) adj_orig.eliminate_zeros() adj = adj_train if FLAGS.features == 0: features = sp.identity(features.shape[0]) # featureless # Some preprocessing adj_norm = preprocess_graph(adj) # Define placeholders placeholders = { 'features': tf.sparse_placeholder(tf.float64), 'adj': tf.sparse_placeholder(tf.float64), 'adj_orig': tf.sparse_placeholder(tf.float64), 'dropout': tf.placeholder_with_default(0., shape=()) } num_nodes = adj.shape[0] features = sparse_to_tuple(features.tocoo()) num_features = features[2][1] features_nonzero = features[1].shape[0] # Create model model = None if model_str == 'gcn_ae': model = GCNModelAE(placeholders, num_features, features_nonzero) elif model_str == 'gcn_vae': model = GCNModelVAE(placeholders, num_features, num_nodes, features_nonzero) pos_weight = 1 norm = 1 #pos_weight = train_edges_false.shape[0] / float(train_edges.shape[0]) #norm = (train_edges.shape[0]+train_edges_false.shape[0]) / float(train_edges_false.shape[0]*train_edges_false.shape[0]) # Optimizer with tf.name_scope('optimizer'): if model_str == 'gcn_ae': opt = OptimizerAE(preds=model.reconstructions, labels=tf.reshape( tf.sparse_tensor_to_dense( placeholders['adj_orig'], validate_indices=False), [-1]), pos_weight=pos_weight, norm=norm, mask=mask_index) elif model_str == 'gcn_vae': opt = OptimizerVAE(preds=model.reconstructions, labels=tf.reshape( tf.sparse_tensor_to_dense( placeholders['adj_orig'], validate_indices=False), [-1]), model=model, num_nodes=num_nodes, pos_weight=pos_weight, norm=norm, mask=mask_index) # Initialize session sess = tf.Session() sess.run(tf.global_variables_initializer()) adj_label = adj_train + sp.eye(adj_train.shape[0]) adj_label = sparse_to_tuple(adj_label) # Train model for epoch in range(FLAGS.epochs): t = time.time() # Construct feed dictionary feed_dict = construct_feed_dict(adj_norm, adj_label, features, placeholders) feed_dict.update({placeholders['dropout']: FLAGS.dropout}) # Run single weight update outs = sess.run([opt.opt_op, opt.cost], feed_dict=feed_dict) print("Epoch:", '%04d' % (epoch + 1), "train_loss=", "{:.5f}".format(outs[1])) print("Optimization Finished!") #return embedding for each protein emb = sess.run(model.z_mean, feed_dict=feed_dict) return emb
def runner(self): model_str = FLAGS.model placeholders = [{ 'features': tf.sparse_placeholder(tf.float32), 'adj': tf.sparse_placeholder(tf.float32), 'adj_orig': tf.sparse_placeholder(tf.float32), 'dropout': tf.placeholder_with_default(0., shape=()), 'num_features': tf.placeholder(tf.float32), 'features_nonzero': tf.placeholder(tf.float32), 'pos_weight': tf.placeholder(tf.float32), 'norm': tf.placeholder(tf.float32), 'reward': tf.placeholder(tf.float32), 'D_W1': tf.placeholder_with_default( tf.zeros([FLAGS.g_hidden2, FLAGS.d_hidden1]), shape=[FLAGS.g_hidden2, FLAGS.d_hidden1]), 'D_W2': tf.placeholder_with_default(tf.zeros([FLAGS.d_hidden1, 1]), shape=[FLAGS.d_hidden1, 1]), 'D_b1': tf.placeholder_with_default(tf.zeros([FLAGS.d_hidden1]), shape=[FLAGS.d_hidden1]), 'D_b2': tf.placeholder_with_default(tf.zeros([1]), shape=[1]), }, { 'features': tf.sparse_placeholder(tf.float32), 'adj': tf.sparse_placeholder(tf.float32), 'adj_orig': tf.sparse_placeholder(tf.float32), 'dropout': tf.placeholder_with_default(0., shape=()), 'num_features': tf.sparse_placeholder(tf.float32), 'features_nonzero': tf.placeholder(tf.float32), 'pos_weight': tf.placeholder(tf.float32), 'norm': tf.placeholder(tf.float32), 'reward': tf.placeholder(tf.float32) }] sess = tf.Session() real_X = tf.placeholder(tf.float32, shape=[None, FLAGS.g_hidden2]) fake_X = tf.placeholder(tf.float32, shape=[None, FLAGS.g_hidden2]) self.D_W1 = tf.Variable(xavier_init([FLAGS.g_hidden2, FLAGS.d_hidden1])) self.D_b1 = tf.Variable(xavier_init([FLAGS.d_hidden1])) self.D_W2 = tf.Variable(xavier_init([FLAGS.d_hidden1, 1])) self.D_b2 = tf.Variable(xavier_init([1])) d_vars = [self.D_W1, self.D_b1, self.D_W2, self.D_b2] print('train for the network embedding...') # Load data dataset_str1 = 'Douban_offline' # 1118 nodes dataset_str2 = 'Douban_online' # 3906 nodes adj1, features1, fea_num1 = load_data(dataset_str1) adj2, features2, fea_num2 = load_data(dataset_str2) num_features = [features1.shape[1], features2.shape[1]] model = None if model_str == 'gcn_ae': model = GCNModelAE(placeholders, num_features, sess) elif model_str == 'gcn_vae': model = GCNModelVAE(placeholders, num_features, num_nodes, features_nonzero) # Optimizer with tf.name_scope('optimizer'): opt = OptimizerAE( preds=[model.reconstructions1, model.reconstructions2], labels=[ tf.reshape( tf.sparse_tensor_to_dense(placeholders[0]['adj_orig'], validate_indices=False), [-1]), tf.reshape( tf.sparse_tensor_to_dense(placeholders[1]['adj_orig'], validate_indices=False), [-1]) ], preds_attribute=[ model.attribute_reconstructions1, model.attribute_reconstructions1 ], labels_attribute=[ tf.sparse_tensor_to_dense(placeholders[0]['features']), tf.sparse_tensor_to_dense(placeholders[1]['features']) ], pos_weight=[ placeholders[0]['pos_weight'], placeholders[1]['pos_weight'] ], norm=[placeholders[0]['norm'], placeholders[1]['norm']], fake_logits=model.fake_logits, alpha=FLAGS.AX_alpha) real_X = tf.placeholder(tf.float32, shape=[None, FLAGS.g_hidden2]) fake_X = tf.placeholder(tf.float32, shape=[None, FLAGS.g_hidden2]) real_logits, fake_logits = self.discriminator(real_X, fake_X) real_prob = tf.reduce_mean(real_logits) fake_prob = tf.reduce_mean(fake_logits) D_loss = -real_prob + fake_prob dis_optimizer = tf.train.AdamOptimizer( learning_rate=FLAGS.learning_rate_dis) # Adam Optimizer opt_dis = dis_optimizer.minimize(D_loss, var_list=d_vars) sess.run(tf.global_variables_initializer()) final_emb1 = [] final_emb2 = [] emb1_id = [] emb2_id = [] local_A_1 = adj1 local_X_1 = features1 local_A_2 = adj2 local_X_2 = features2 adj_norm_1 = preprocess_graph(local_A_1) local_X_1 = sparse_to_tuple(local_X_1.tocoo()) pos_weight_1 = float(local_A_1.shape[0] * local_A_1.shape[0] - local_A_1.sum()) / local_A_1.sum() adj_label_1 = local_A_1 + sp.eye(local_A_1.shape[0]) adj_label_1 = sparse_to_tuple(adj_label_1) norm_1 = local_A_1.shape[0] * local_A_1.shape[0] / float( (local_A_1.shape[0] * local_A_1.shape[0] - local_A_1.sum()) * 2) adj_norm_2 = preprocess_graph(local_A_2) local_X_2 = sparse_to_tuple(local_X_2.tocoo()) pos_weight_2 = float(local_A_2.shape[0] * local_A_2.shape[0] - local_A_2.sum()) / local_A_2.sum() adj_label_2 = local_A_2 + sp.eye(local_A_2.shape[0]) adj_label_2 = sparse_to_tuple(adj_label_2) norm_2 = local_A_2.shape[0] * local_A_2.shape[0] / float( (local_A_2.shape[0] * local_A_2.shape[0] - local_A_2.sum()) * 2) self.tmp_count = {} for epoch in range(FLAGS.epoch): for circle_epoch in range(FLAGS.circle_epoch): for G_epoch in range(FLAGS.g_epoch): # ------------------------------------------------------------------------------------------ feed_dict = construct_feed_dict( [adj_norm_2, adj_norm_1], [adj_label_2, adj_label_1], [local_X_2, local_X_1], [pos_weight_2, pos_weight_1], [norm_2, norm_1], placeholders) feed_dict.update( {placeholders[0]['D_W1']: sess.run(self.D_W1)}) feed_dict.update( {placeholders[0]['D_W2']: sess.run(self.D_W2)}) feed_dict.update( {placeholders[0]['D_b1']: sess.run(self.D_b1)}) feed_dict.update( {placeholders[0]['D_b2']: sess.run(self.D_b2)}) _, embeddings1_, embeddings2_, gcn_cost, fake_prob_, attr_cost = sess.run( [ opt.opt_op, model.embeddings1, model.embeddings2_, opt.cost, model.fake_prob, opt.attribute_cost ], feed_dict=feed_dict) for D_epoch in range(FLAGS.d_epoch): feed_dict.update( {placeholders[0]['dropout']: FLAGS.dropout}) emb1, emb2 = sess.run( [model.embeddings1, model.embeddings2_], feed_dict=feed_dict) _, real_prob_, fake_prob_ = sess.run( [opt_dis, real_prob, fake_prob], feed_dict={ real_X: emb1, fake_X: emb2 }) if epoch % 1 == 0: emb1, emb2 = sess.run([model.embeddings1, model.embeddings2_], feed_dict=feed_dict) final_emb1 = np.array(emb1) final_emb2 = np.array(emb2) similar_matrix = cosine_similarity(final_emb1, final_emb2) self.similar_matrix = similar_matrix pair = {} gnd = np.loadtxt("data/douban_truth.emb") count = {} topk = [1, 5, 10, 20, 30, 50] for i in range(len(topk)): pair[topk[i]] = [] count[topk[i]] = 0 self.tmp_count[topk[i]] = 0 for top in topk: for index in range(similar_matrix.shape[0]): top_index = heapq.nlargest( int(top), range(len(similar_matrix[index])), similar_matrix[index].take) top_index = list(map(lambda x: x + 1, top_index)) pair[top].append([index + 1, top_index]) for ele_1 in gnd: for ele_2 in pair[top]: if ele_1[0] == ele_2[0]: if ele_1[1] in ele_2[1]: count[top] += 1 print( f'-----------------------epoch {epoch}------------------------' ) for top in topk: print("top", '%02d' % (top), "count=", '%d' % (count[top]), "precision=", "{:.5f}".format(count[top] / len(gnd))) print( f'-----------------------epoch {epoch}------------------------' )
'adj_orig': tf.sparse_placeholder(tf.float32), 'dropout': tf.placeholder_with_default(0., shape=()) } num_nodes = adj.shape[0] features = sparse_to_tuple(features.tocoo()) num_features = features[2][1] features_nonzero = features[1].shape[0] logging.info('create model') # Create model model = None if model_str == 'gcn_ae': model = GCNModelAE(placeholders, num_features, features_nonzero) elif model_str == 'gcn_vae': model = GCNModelVAE(placeholders, num_features, num_nodes, features_nonzero) pos_weight = float(adj.shape[0] * adj.shape[0] - adj.sum()) / adj.sum() norm = adj.shape[0] * adj.shape[0] / float( (adj.shape[0] * adj.shape[0] - adj.sum()) * 2) logging.info('optimizer') # Optimizer with tf.name_scope('optimizer'): if model_str == 'gcn_ae': opt = OptimizerAE(preds=model.reconstructions, labels=tf.reshape( tf.sparse_tensor_to_dense( placeholders['adj_orig'], validate_indices=False), [-1]), pos_weight=pos_weight, norm=norm)
adj_train = np.zeros( (len(drugs) + len(proteins), len(drugs) + len(proteins)), dtype=np.float32) train_rows, train_cols = train_data[0], train_data[1] valid_rows, valid_cols = valid_data[0], valid_data[1] test_rows, test_cols = test_data[0], test_data[1] R = np.zeros(affinity.shape) # drug protein interaction matrix R[train_rows, train_cols] = 1 adj_train[:len(drugs), len(drugs):] = R adj_train[len(drugs):, :len(drugs)] = R.T adj_train = torch.FloatTensor(adj_train) epoch = 10000 lr = 0.001 model = GCNModelVAE(128, 32, 64).cuda() optim = Adam(model.parameters(), lr=lr) for i in range(epoch): # train model.train() optim.zero_grad() prediction, mu, logvar = model( torch.Tensor(drugs).cuda(), torch.LongTensor(proteins).cuda(), adj_train.cuda()) # print("affinity",affinity[train_rows, train_cols].shape) # print(torch.FloatTensor(affinity[train_rows, train_cols]).size()) # print("prediction",prediction[train_rows, train_cols].size()) # print(prediction[train_rows, train_cols]) loss = loss_function( torch.FloatTensor(affinity[train_rows, train_cols]).cuda(),