def run_cora_incremental(feat_data, labels, adj_lists, args): features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = IncrementSupervisedGraphSage(7, enc2, labels, args) val_data = Continuum(name="cora", data_type='val', download=True) val = val_data.nodes() for i in range(7): incremental_data = Continuum(name="cora", data_type='train', download=True, task_type=i) train = incremental_data.nodes() random.shuffle(train) print("the size of task: %i"%len(train)) for i in range(0, len(train), args.batch_size): if i+args.batch_size <= len(train): batch_nodes = train[i:i+args.batch_size] else: batch_nodes = train[i:len(train)] graphsage.observe(batch_nodes) val_output = graphsage.forward(val) print("Validation F1:", f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro"))
def __init__(self, adj_lists, cuda=False): super(Policy, self).__init__() self.cuda = cuda agg1 = MeanAggregator(cuda=cuda) enc1 = Encoder(3, 128, adj_lists, agg1, gcn=True, cuda=cuda) agg2 = MeanAggregator(cuda=cuda) enc2 = Encoder(enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 50 enc2.num_samples = 10 self.enc1 = enc1 self.GCN = enc2 # Fully connected network that outputs node probabilities. input_dim = 128 + 1 self.network = nn.Sequential(nn.Linear(input_dim, 128), nn.ReLU(), nn.Linear(128, 64), nn.ReLU(), nn.Linear(64, 1)) self.smax = nn.Softmax(dim=0)
def run_cora(): np.random.seed(1) random.seed(1) num_nodes = 2708 path = "/data/ducva/graphsage-simple/data/" if torch.cuda.is_available(): cuda_available = True feat_data, labels, adj_lists = load_cora() features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) if cuda_available: features.cuda() # two inner loop for aggregating a node in graph agg1 = MeanAggregator(features, cuda=cuda_available) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=cuda_available) agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=cuda_available) enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=cuda_available) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(7, enc2) if cuda_available: graphsage.cuda() rand_indices = np.random.permutation(num_nodes) test = rand_indices[:1000] val = rand_indices[1000:1500] train = list(rand_indices[1500:]) optimizer = torch.optim.SGD(filter(lambda p : p.requires_grad, graphsage.parameters()), lr=0.7) times = [] best_loss = 100 for batch in range(100): batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() if cuda_available: loss = graphsage.loss(batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]).cuda())) # (nodes, labels) else: loss = graphsage.loss(batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]).cuda())) loss.backward() optimizer.step() end_time = time.time() times.append(end_time-start_time) if loss.item() < best_loss: best_loss = loss.item() torch.save(graphsage.state_dict(), path + "SupervisedGraphSage.model") torch.save(enc1.state_dict(), path + "Encoder1.model") torch.save(enc2.state_dict(), path + "Encoder2.model") torch.save(agg1.state_dict(), path + "MeanAggregator1.model") torch.save(agg2.state_dict(), path + "MeanAggregator2.model") print(batch, loss.item()) val_output = graphsage.forward(val) print("Validation F1:", f1_score(labels[val], val_output.data.cpu().numpy().argmax(axis=1), average="micro")) print("Average batch time:", np.mean(times))
def run_cora(): hook = syft.TorchHook(torch) bob = syft.VirtualWorker(hook, id='bob') alice = syft.VirtualWorker(hook, id='alice') np.random.seed(1) random.seed(1) num_nodes = 2708 feat_data, labels, adj_lists = load_cora() features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=True) # features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(7, enc2).send(bob) # graphsage.cuda() rand_indices = np.random.permutation(num_nodes) test = rand_indices[:1000] val = rand_indices[1000:1500] train = list(rand_indices[1500:]) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) times = [] for batch in range(100): batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss( batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(batch, loss.data) val_output = graphsage.forward(val) print( "Validation F1:", f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro")) print("Average batch time:", np.mean(times))
def run_cora(): np.random.seed(1) random.seed(1) num_nodes = 2708 feat_data, labels, adj_lists = load_cora() features = nn.Embedding(2708, 1433) features.weight = nn.Parameter( torch.FloatTensor(feat_data), requires_grad=False) # The feature is already well embedded. # So we just use the embedding layer for rows selection. features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=True) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=True) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=True) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(7, enc2) graphsage.cuda() rand_indices = np.random.permutation(num_nodes) test = rand_indices[:1000] val = rand_indices[1000:1500] train = list(rand_indices[1500:]) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) times = [] for batch in range(100): batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss( batch_nodes, torch.tensor(labels[np.array(batch_nodes)], dtype=torch.long)) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(batch, loss.item()) val_output = graphsage.forward(val).cpu() print( "Validation F1:", f1_score(labels[val], val_output.argmax(axis=1).numpy(), average="micro")) print("Average batch time:", np.mean(times))
def run_bc_test_based_on_group(adj_lists_test, feat_data, test, model_name, output, edge_count): num_nodes = 10312 feature_dim = 128 embed_dim = 128 feat_data_cp = np.ones((10312, 128)) features = nn.Embedding(num_nodes, feature_dim) features.weight = nn.Parameter(torch.FloatTensor(feat_data_cp), requires_grad=False) # Set up the model using the testing graph structure agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, feature_dim, embed_dim, adj_lists_test, agg1, gcn=False, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, embed_dim, adj_lists_test, agg2, base_model=enc1, gcn=False, cuda=False) # Possible additional layers # agg3 = MeanAggregator(lambda nodes: enc2(nodes).t(), cuda=False) # enc3 = Encoder(lambda nodes: enc2(nodes).t(), enc2.embed_dim, embed_dim, adj_lists_test, agg3, # base_model=enc2, gcn=False, cuda=False) # agg4 = MeanAggregator(lambda nodes: enc3(nodes).t(), cuda=False) # enc4 = Encoder(lambda nodes: enc3(nodes).t(), enc3.embed_dim, embed_dim, adj_lists_test, agg4, # base_model=enc3, gcn=False, cuda=False) enc1.num_sample = edge_count enc2.num_sample = 10 # enc3.num_sample = 15 # enc4.num_sample = 20 # Initial the model and load the stored parameters from the file graphsage = RegressionGraphSage(enc2) graphsage.load_state_dict(torch.load(model_name)) graphsage.eval() # Compute the cosine similarity embed_output = graphsage.forward(test) cos = nn.CosineSimilarity(dim=1, eps=1e-6) print("Average Validation Cosine Similarity:", cos(embed_output, torch.FloatTensor(feat_data[test])).mean(0).item()) # Save Embedding to file np.savetxt(output, embed_output.data.numpy())
def run_cora(): np.random.seed(1) random.seed(1) num_nodes = 2708 feat_data, labels, adj_lists = load_cora() features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) # features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) # agg1 = MeanAggregator(features, cuda=False) # enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=False, cuda=False) # agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False) # enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, # base_model=enc1, gcn=False, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(7, enc2) # graphsage.cuda() train = range(200) + range(1500, num_nodes) val = range(200, 500) test = range(500, 1500) # rand_indices = np.random.permutation(num_nodes) # test = rand_indices[:1000] # val = rand_indices[1000:1500] # train = list(rand_indices[1500:]) optimizer = torch.optim.SGD(filter(lambda p : p.requires_grad, graphsage.parameters()), lr=0.7) times = [] for batch in range(100): batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss(batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time-start_time) # print batch, loss.item()[0] val = test[:] val_output = graphsage.forward(val) print "Validation F1:", f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro") # print labels[val] # print val_output.data.numpy().argmax(axis=1) print "Validation Acc:", accuracy_score(labels[val], val_output.data.numpy().argmax(axis=1)) print "Average batch time:", np.mean(times) return labels[val], val_output.data.numpy().argmax(axis=1)
def run_bc_test(adj_lists_test, feat_data, test, model_name, output, edge_count): num_nodes = 10312 feature_dim = 128 embed_dim = 128 features = nn.Embedding(num_nodes, feature_dim) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, feature_dim, embed_dim, adj_lists_test, agg1, gcn=False, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, embed_dim, adj_lists_test, agg2, base_model=enc1, gcn=False, cuda=False) enc1.num_sample = edge_count enc2.num_sample = edge_count graphsage = RegressionGraphSage(enc2) graphsage.load_state_dict(torch.load(model_name)) graphsage.eval() # test data based on degree (group) test_data = [] with open("../BlogCatalog-data/data_id0.txt", "r") as f: vecs = f.readline().split(" ") for x in vecs: test.append(x) embed_output = graphsage.forward(test_data) cos = nn.CosineSimilarity(dim=1, eps=1e-6) print("Average Validation Cosine Similarity:", cos(embed_output, torch.FloatTensor(feat_data[test])).mean(0).item()) #Save Embedding to file np.savetxt(output, embed_output.data.numpy()) with open("test_id" + str(edge_count) + ".txt", "w") as f: for item in test: f.write(str(item) + " ")
def run_pubmed(): np.random.seed(1) random.seed(1) num_nodes = 19717 feat_data, labels, adj_lists = load_pubmed() features = Embedding(19717, 500) features.weight = Parameter(torch.tensor(feat_data, dtype=torch.float), requires_grad=False) agg1 = MeanAggregator(features) enc1 = Encoder(features, 500, 128, adj_lists, agg1, gcn=True) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t()) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True) enc1.num_samples = 10 enc2.num_samples = 25 graphsage = SupervisedGraphSage(3, enc2) rand_indices = np.random.permutation(num_nodes) test = rand_indices[:1000] val = rand_indices[1000:1500] train = list(rand_indices[1500:]) all_grad_params = filter(lambda p: p.requires_grad, graphsage.parameters()) optimizer = torch.optim.SGD(all_grad_params, lr=0.7) times = [] for batch in range(200): batch_nodes = train[:1024] random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss(batch_nodes, torch.tensor(labels[np.array(batch_nodes)])) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(batch, loss.item()) val_output = graphsage.forward(val) print( "Validation F1:", f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro")) print("Average batch time:", np.mean(times))
def run_pubmed_incremental(feat_data, labels, adj_lists, args): evaluation_metrics = [] features = nn.Embedding(19717, 500) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) # features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 500, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 10 enc2.num_samples = 25 graphsage = IncrementSupervisedGraphSage(3, enc2, labels, args) val_data = Continuum(name="pubmed", data_type='val', download=True) val = val_data.nodes() for t in range(val_data.num_class): incremental_data = Continuum(name="pubmed", data_type='train', download=True, task_type=t) train = incremental_data.nodes() random.shuffle(train) print("the size of task: %i" % len(train)) for i in range(0, len(train), args.batch_size): if i + args.batch_size <= len(train): batch_nodes = train[i:i + args.batch_size] else: batch_nodes = train[i:len(train)] graphsage.observe(batch_nodes) val_output = graphsage.forward(val) evaluation_metrics.append([ i, len(train), f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro") ]) return evaluation_metrics
def graph_forward(node_feat_dim, features, adj_lists0, adj_lists1, agg_sel=False): agg1_0 = MeanAggregator(features, cuda=False) agg1_1 = MeanAggregator(features, cuda=False) enc1 = Encoder(features, node_feat_dim, 15, adj_lists0, adj_lists1, agg1_0, agg1_1, gcn=agg_sel, cuda=False) agg2_0 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False) agg2_1 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, 12, adj_lists0, adj_lists1, agg2_0, agg2_1, base_model=enc1, gcn=agg_sel, cuda=False) agg3_0 = MeanAggregator(lambda nodes : enc2(nodes).t(), cuda=False) agg3_1 = MeanAggregator(lambda nodes : enc2(nodes).t(), cuda=False) enc3 = Encoder(lambda nodes : enc2(nodes).t(), enc2.embed_dim, 12, adj_lists0, adj_lists1, agg3_0, agg3_1, base_model=enc2, gcn=agg_sel, cuda=False) return enc2
def run_cora(): np.random.seed(1) #可复现随机种子 random.seed(1) num_nodes = 2708 feat_data, labels, adj_lists = load_cora()#载入数据集 features = nn.Embedding(2708, 1433) #初试特征维度 features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) #features.cuda() agg1 = MeanAggregator(features, cuda=True)#mean聚合 enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False)#gcn聚合嵌入到128维 agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False) #用gcn嵌入后的节点特征做mean聚合 enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) #agg2后再gcn聚合嵌入 enc1.num_samples = 5 #一阶和二阶的邻居采样数 enc2.num_samples = 5 graphsage = SupervisedGraphSage(7, enc2)#cora数据集7分类 #graphsage.cuda() rand_indices = np.random.permutation(num_nodes)#打乱数据集(新的数组) test = rand_indices[:1000] #划分数据集为3个部分 val = rand_indices[1000:1500] train = list(rand_indices[1500:]) optimizer = torch.optim.SGD(filter(lambda p : p.requires_grad, graphsage.parameters()), lr=0.7) times = [] for batch in range(100): batch_nodes = train[:256] #每次取前256个 random.shuffle(train) #会在train数组本身打乱,所以每次256个会不同 start_time = time.time() optimizer.zero_grad() #梯度清零 loss = graphsage.loss(batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)])))#loss loss.backward() #反向传播 optimizer.step() #梯度更新 end_time = time.time() times.append(end_time-start_time) print batch, loss.data[0] val_output = graphsage.forward(val) #验证集 print "Validation F1:", f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro") print "Average batch time:", np.mean(times)
def main(): np.random.seed(1) random.seed(1) feat_data, labels, adj_lists, train, test = load_cora() num_nodes = feat_data.shape[0] feat_dim = feat_data.shape[1] hidden_dim = 15 features = nn.Embedding(num_nodes, feat_dim) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) #features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, feat_dim, hidden_dim, adj_lists, agg1, gcn=False, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, hidden_dim, adj_lists, agg2, base_model=enc1, gcn=False, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(2, enc2) #graphsage.cuda() rand_indices = np.random.permutation(num_nodes) #train = rand_indices[:400] #val = rand_indices[1000:1500] #test = rand_indices[400:] optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.001) times = [] epoch = 10 batch_size = 512 num_batch = len(train) // batch_size best_loss = 1e9 cnt_wait = 0 patience = 50 flag = 0 for e in range(epoch): for i in range(num_batch): if i < num_batch - 1: batch_nodes = train[i * batch_size:i * batch_size + batch_size] else: batch_nodes = train[i * batch_size:len(train)] start_time = time.time() optimizer.zero_grad() loss = graphsage.loss(batch_nodes,\ Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print("The {}-th epoch ".format(e), "{}-th batch".format(i), "Loss: ", loss.item()) ''' if loss.item() < best_loss: best_loss = loss.item() cnt_wait = 0 else: cnt_wait += 1 if cnt_wait == patience: print("early stopping!") flag = 1 break ''' ''' if flag == 1: break ''' if len(test) < 100000: test_output = graphsage.forward(test) print( "Test F1:", f1_score(labels[test], test_output.data.numpy().argmax(axis=1), average="micro", labels=[1])) print( "Test Recall:", recall_score(labels[test], test_output.data.numpy().argmax(axis=1), average="micro", labels=[1])) print( "Test Precision:", precision_score(labels[test], test_output.data.numpy().argmax(axis=1), average="micro", labels=[1])) plot_confusion_matrix(labels[test], test_output.data.numpy().argmax(axis=1), np.array([0, 1]), title='Confusion matrix, without normalization') ### Inference on large graph, avoid out of memory else: chunk_size = 512 pred = [] for j in range(len(test) // chunk_size): if j < (len(test) // chunk_size - 1): test_output = graphsage.forward(test[j * chunk_size:(j + 1) * chunk_size]) else: test_output = graphsage.forward(test[j * chunk_size:len(test)]) pred += (test_output.data.numpy().argmax(axis=1)).tolist() print("Inference on the {}-th chunk".format(j)) print( "Test F1:", f1_score(labels[test], np.asarray(pred), average="micro", labels=[1])) print( "Test Recall:", recall_score(labels[test], np.asarray(pred), average="micro", labels=[1])) print( "Test Precision:", precision_score(labels[test], np.asarray(pred), average="micro", labels=[1])) plot_confusion_matrix(labels[test], np.asarray(pred), np.array([0, 1]), title='Confusion matrix, without normalization') print("Average batch time:", np.mean(times))
def run_ppi(): np.random.seed(1) random.seed(1) num_nodes = 56944 feat_data, labels, adj_lists, dataset_split = load_ppi() features = nn.Embedding(56944, 50) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 50, 512, adj_lists, agg1, gcn=True, cuda=True) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=True) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 512, adj_lists, agg2, base_model=enc1, gcn=True, cuda=True) enc1.num_samples = 10 enc2.num_samples = 25 # enc1.num_samples = None # enc2.num_samples = None graphsage = SupervisedGraphSage(121, enc2) graphsage.cuda() test = dataset_split['test'] train = dataset_split['train'] optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.0001) times = [] epoch_num = 400 for epoch in range(epoch_num): for batch in range(int(len(train) / 1024)): batch_nodes = train[:1024] random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss( batch_nodes, Variable(torch.FloatTensor( labels[np.array(batch_nodes)])).cuda()) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(epoch + 1, loss.data) print('') os.system("nvidia-smi") agg1.cuda = False enc1.cuda = False agg2.cuda = False enc2.cuda = False val_output = graphsage.cpu().forward(test) val_output[val_output > 0] = 1 val_output[val_output <= 0] = 1 print( "Validation F1:", f1_score(labels[test], val_output.cpu().data.numpy(), average="micro")) print("Total time:", np.sum(times)) print("Average batch time:", np.sum(times) / epoch_num) print('')
def main(): np.random.seed(1) random.seed(1) feat_data, labels, adj_lists, train, test, edge_map = load_cora() num_nodes = feat_data.shape[0] feat_dim = feat_data.shape[1] hidden_dim = 15 features = nn.Embedding(num_nodes, feat_dim) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) #features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, feat_dim, hidden_dim, adj_lists, agg1, gcn=False, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, hidden_dim, adj_lists, agg2, base_model=enc1, gcn=False, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(1, enc2, edge_map) #graphsage.cuda() optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.001, weight_decay=1e-5) times = [] epoch = 10 batch_size = 512 num_batch = len(train) // batch_size best = 1e9 cnt_wait = 0 patience = 20 best_t = 0 for e in range(epoch): for i in range(num_batch): if i < num_batch - 1: batch_nodes = train[i * batch_size:i * batch_size + batch_size] else: batch_nodes = train[i * batch_size:len(train)] start_time = time.time() optimizer.zero_grad() loss = graphsage.loss(batch_nodes,\ Variable(torch.FloatTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print("The {}-th epoch ".format(e), "{}-th batch".format(i), "Loss: ", loss.item()) if loss.item() < best: best_loss = loss.item() cnt_wait = 0 best_t = e torch.save(graphsage.state_dict(), 'best_model.pkl') else: cnt_wait += 1 if cnt_wait == patience: print("early stopping!") break print('Loading {}th epoch'.format(best_t)) graphsage.load_state_dict(torch.load('best_model.pkl')) if len(test) < 100000: test_output = torch.sigmoid(graphsage.forward(test)) pred = (np.where(test_output.data.numpy() < 0.5, 0, 1)) print("Test F1:", f1_score(labels[test], pred, labels=[1], average="micro")) print("Test Recall:", recall_score(labels[test], pred, labels=[1], average="micro")) print("Test Precision:", precision_score(labels[test], pred, labels=[1], average="micro")) cm = plot_confusion_matrix( labels[test], pred, np.array([0, 1]), title='Confusion matrix, without normalization') #recall = cm[1][1]/(cm[1][0]+cm[1][1]) #precision = cm[1][1]/(cm[1][1]+cm[0][1]) #f1 = 2*recall*precision/(recall+precision) #print("Test F1 micro:", f1) #print("Test Recall micro:", recall) #print("Test Precision micro:", precision) ### Inference on large graph, avoid out of memory else: chunk_size = 5120 pred = [] for j in range(len(test) // chunk_size): if j < (len(test) // chunk_size - 1): test_output = torch.sigmoid( graphsage.forward(test[j * chunk_size:(j + 1) * chunk_size])) else: test_output = torch.sigmoid( graphsage.forward(test[j * chunk_size:len(test)])) pred += (np.where(test_output.data.numpy() < 0.5, 0, 1)).tolist() print("Inference on the {}-th chunk".format(j)) cm = plot_confusion_matrix( labels[test], np.asarray(pred), np.array([0, 1]), title='Confusion matrix, without normalization') print( "Test F1:", f1_score(labels[test], np.asarray(pred), labels=[1], average="micro")) print( "Test Recall:", recall_score(labels[test], np.asarray(pred), labels=[1], average="micro")) print( "Test Precision:", precision_score(labels[test], np.asarray(pred), labels=[1], average="micro")) print("Average batch time:", np.mean(times))
def run_cora(): np.random.seed(1) random.seed(1) num_nodes = 2708 # feat_data: ndarray 2708*1433 # labels: ndarray 2708*1 # adj_list: defaultdict feat_data, labels, adj_lists = load_cora() # 生成2708个嵌入,每一个嵌入1433维度 features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) # features.cuda() # forward流 下面的过程始终不会调用forward函数 # K = 2 # 调用MeanAggregator构造函数__init__ agg1 = MeanAggregator(features, cuda=False) # 调用Encoder构造函数__init__ enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) # t()转置,利用lambda表达式,输入是nodes,输出为enc1(nodes).t(),但是此处不会调用执行enc1的forward函数,只是把lambda匿名函数句柄传给构造函数 agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) # Encoder接受采样参数,在forward中传递给聚合层forward函数 enc1.num_samples = 5 enc2.num_samples = 5 # 封装为一个整体的model graphsage = SupervisedGraphSage(7, enc2) # graphsage.cuda() # 生成2708的一个全排列,切分训练集,测试集和验证集 rand_indices = np.random.permutation(num_nodes) test = rand_indices[:1000] val = rand_indices[1000:1500] # 将ndarray转换为list train = list(rand_indices[1500:]) # 初始化优化器,并且给优化器应该优化的参数 optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) times = [] for batch in range(1): # 取256大小的batch_size batch_nodes = train[:256] # 随机打乱 random.shuffle(train) # 记录训练时间 start_time = time.time() # 初始化梯度为0 optimizer.zero_grad() # forward + loss 得到正向计算结果 loss = graphsage.loss( batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) # backward 计算出梯度 loss.backward() # 优化器 optimizer.step() end_time = time.time() times.append(end_time - start_time) # loss是一个torch.Tensor print(batch, loss.item()) # print(type(loss), loss.size()) '''
def run_cora(printout = True): begin = timeit.default_timer() np.random.seed(1) random.seed(1) num_nodes = 2708 feat_data, labels, adj_lists = load_cora() ################################################################################################################ # TESTAR AS DUAS FORMAS: INCLUIR NA MATRIZ DE FEATURES AS INFORMACOES # (talvez isso nao seja necessario ja que o graphsage faz os embeddings por agregacao) # OU # APENAS USAR O RESULTADO DO K-MEANS PARA SEPARAR OS LOTES ################################################################################################################ # Metodo Elbow para encontrar o numero de classes if True: wcss = [] # Within Cluster Sum of Squares for i in range(2, 11): kmeans = KMeans(n_clusters = i, init = 'random') kmeans.fit(feat_data) if printout: print 'kmeans wcss: ', i, kmeans.inertia_ wcss.append(kmeans.inertia_) #plt.plot(range(2, 11), wcss) #plt.title('O Metodo Elbow') #plt.xlabel('Numero de Clusters') #plt.ylabel('WCSS') #plt.show() #return None, None # Metodo Elbow encontrou 7 classes kmeans = KMeans(n_clusters = 7, init = 'random') kmeans.fit(feat_data) kmeans.fit_transform(feat_data) klabels = kmeans.labels_ if False: return labels, klabels ###################################################################################################################### ###################################################################################################################### ################################################################################################################### # AQUI EU ATRIBUO INDICES AOS CONJUNTOS USANDO AS QUANTIDADES PROPORCIONAIS DE CADA K-MEANS CLUSTER ################################################################################################################### #test = rand_indices[:1000] # 1000 exemplos #val = rand_indices[1000:1500] # 500 exemplos #train = list(rand_indices[1500:]) # 1208 exemplos train, val, test, ratio = _processes_set(klabels, num_clusters = 7, num_examples = num_nodes) # normalization ind_train = list() for key in train: ind_train.extend(train[key]) scaler = preprocessing.StandardScaler().fit(feat_data[ind_train]) # only fit in the train examples feat_data = scaler.transform(feat_data) ################################################################################################################### ################################################################################################################### features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) # features.cuda() # MeanAggregator params # features, cuda=False, gcn=False # Encoder params # features, feature_dim, embed_dim, adj_lists, aggregator, num_sample=10, base_model=None, # gcn=False, cuda=False, feature_transform=False agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(7, enc2) # graphsage.cuda() rand_indices = np.random.permutation(num_nodes) # len(rand_indices) = 2708 optimizer = torch.optim.SGD(filter(lambda p : p.requires_grad, graphsage.parameters()), lr=0.7) times = [] ################################################################################################################### # quantidade proporcional do batch, inicializacao do vetor de erro ################################################################################################################### quantity = np.empty((7,1), dtype=int) quantity[:,0] = ratio * 256 quantity = list(quantity.flatten()) train_loss = list() ################################################################################################################### ################################################################################################################### for batch in range(100): ################################################################################################## # O QUE EU POSSO FAZER AQUI EH EMBARALHAR OS VERTICES SEPARADAMENTE DENTRO DOS CLUSTERS # PARA MONTAR BATCH_NODES, PEGAR AS QUANTIDADES PROPORCIONAIS ################################################################################################## batch_nodes = list() for key in train: batch_nodes.extend(train[key][:quantity[key]]) random.shuffle(train[key]) random.shuffle(batch_nodes) ################################################################################################## ################################################################################################## # pega os primeiros 255 exemplos #batch_nodes = train[:256] # embaralha os exemplos para que o proximo batch_nodes tenha outros vertices # a amostragem, nesse caso, eh com reposicao #random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss(batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time-start_time) ################################################################################################## train_loss.append(loss.data[0]) # armazena o erro if printout: print batch, loss.data[0] end = timeit.default_timer() elapsed = end - begin val_output = graphsage.forward(val) score = f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro") if printout: print "Validation F1:", score print "Average batch time:", np.mean(times) return train_loss, score, elapsed
def run_cora(): np.random.seed(1) random.seed(1) num_nodes = 2708 feat_data, labels, adj_lists, adj = load_cora() features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) adj = Variable(torch.FloatTensor(adj), requires_grad=False) if torch.cuda.is_available(): features, adj = features.cuda(), adj.cuda() # features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(7, enc2) if torch.cuda.is_available(): graphsage = graphsage.cuda() # rand_indices = np.random.permutation(num_nodes) # test = rand_indices[:1000] # val = rand_indices[1000:1500] # train = list(rand_indices[1500:]) train = list(range(140)) val = np.array(range(200, 500)) test = np.array(range(500, 1500)) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) temp = TEMP for batch in range(000): batch_nodes = list(range(num_nodes)) optimizer.zero_grad() loss = graphsage.nmincut_loss(batch_nodes, adj, temp=temp, beta=BETA) loss.backward() optimizer.step() if batch % 100 == 0: accs = classify(graphsage.embeds.detach().cpu().numpy(), labels, 0.5) print(batch, loss.item(), accs) # if batch % 1000: # temp = max(0.1, TEMP*np.exp(-0.0003*batch)) times = [] for batch in range(100): batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() batch_labels = Variable(torch.LongTensor( labels[np.array(batch_nodes)])) if torch.cuda.is_available(): batch_labels = batch_labels.cuda() loss = graphsage.loss(batch_nodes, batch_labels) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(batch, loss.item()) _, test_output = graphsage.forward(test) print( "Testing F1:", f1_score(labels[test], test_output.detach().cpu().numpy().argmax(axis=1), average="micro")) print("Average batch time:", np.mean(times))
def run_hate(gcn, features, weights, edges, flag_index="hate", num_features=320, lr=0.01, batch_size=128): # torch.manual_seed(1) # np.random.seed(1) # random.seed(1) num_nodes = 100386 feat_data, labels, adj_lists = load_hate(features, edges, num_features) features = nn.Embedding(num_nodes, num_features) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) agg1 = MeanAggregator(features, cuda=False) enc1 = Encoder(features, num_features, 256, adj_lists, agg1, gcn=gcn, cuda=False) # agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) # enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 256, adj_lists, agg2, # base_model=enc1, gcn=gcn, cuda=False) enc1.num_samples = 25 # enc2.num_samples = 10 # graphsage = SupervisedGraphSage(len(weights), enc2, torch.FloatTensor(weights)) graphsage = SupervisedGraphSage(len(weights), enc1, torch.FloatTensor(weights)) if flag_index == "hate": df = pd.read_csv("hate/users_neighborhood_anon.csv") df = df[df.hate != "other"] y = np.array([1 if v == "hateful" else 0 for v in df["hate"].values]) x = np.array(df["user_id"].values) del df else: df = pd.read_csv("suspended/users_anon.csv") np.random.seed(321) df2 = df[df["is_63_2"] == True].sample(668, axis=0) df3 = df[df["is_63_2"] == False].sample(5405, axis=0) df = pd.concat([df2, df3]) y = np.array([1 if v else 0 for v in df["is_63_2"].values]) x = np.array(df["user_id"].values) del df, df2, df3 skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=123) f1_test = [] accuracy_test = [] auc_test = [] recall_test = [] precision_test = [] for train_index, test_index in skf.split(x, y): train, test = x[train_index], x[test_index] print("=================begin train test======================") # optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, graphsage.parameters())) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=lr) graphsage = SupervisedGraphSage(len(weights), enc1, torch.FloatTensor(weights)) times = [] cum_loss = 0 for batch in range(1000): batch_nodes = train[:batch_size] train = np.roll(train, batch_size) # random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss( batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) # cum_loss += loss.data[0] cum_loss += loss.data.item() if batch % 50 == 0: val_output = graphsage.forward(test) labels_pred_validation = val_output.data.numpy().argmax(axis=1) labels_true_validation = labels[test].flatten() if flag_index == "hate": y_true = [ 1 if v == 2 else 0 for v in labels_true_validation ] y_pred = [ 1 if v == 2 else 0 for v in labels_pred_validation ] else: y_true = [ 1 if v == 1 else 0 for v in labels_true_validation ] y_pred = [ 1 if v == 1 else 0 for v in labels_pred_validation ] print(len(y_true)) fscore = f1_score(y_true, y_pred, labels=None, pos_label=1, average='binary', sample_weight=None) recall = recall_score(y_true, y_pred, labels=None, pos_label=1, average='binary', sample_weight=None) precision = precision_score(y_true, y_pred, labels=None, pos_label=1, average='binary', sample_weight=None) accuracy = accuracy_score(y_true, y_pred) print(confusion_matrix(y_true, y_pred)) print("F-score, recall, precision, accuracy: ", fscore, recall, precision, accuracy) print(batch, cum_loss / 50, fscore) cum_loss = 0 if fscore > 0.65 and flag_index == "hate": break if fscore >= 0.50 and recall > 0.8 and flag_index != "hate": break print( "==========================================================================" ) val_output = graphsage.forward(test) labels_pred_test = val_output.data.numpy().argmax(axis=1) if flag_index == "hate": labels_pred_score = val_output.data.numpy()[:, 2].flatten( ) - val_output.data.numpy()[:, 0].flatten() else: labels_pred_score = val_output.data.numpy()[:, 1].flatten( ) - val_output.data.numpy()[:, 0].flatten() labels_true_test = labels[test].flatten() if flag_index == "hate": y_true = [1 if v == 2 else 0 for v in labels_true_test] y_pred = [1 if v == 2 else 0 for v in labels_pred_test] else: y_true = [1 if v else 0 for v in labels_true_test] y_pred = [1 if v else 0 for v in labels_pred_test] fpr, tpr, _ = roc_curve(y_true, labels_pred_score) auc_test.append(auc(fpr, tpr)) accuracy_test.append(accuracy_score(y_true, y_pred)) f1_test.append(f1_score(y_true, y_pred)) recall_test.append(recall_score(y_true, y_pred)) precision_test.append(precision_score(y_true, y_pred)) print(confusion_matrix(y_true, y_pred)) accuracy_test = np.array(accuracy_test) f1_test = np.array(f1_test) recall_test = np.array(recall_test) auc_test = np.array(auc_test) precision_test = np.array(precision_test) print("Accuracy %0.4f +- %0.4f" % (accuracy_test.mean(), accuracy_test.std())) print("F1 %0.4f +- %0.4f" % (f1_test.mean(), f1_test.std())) print("Recall %0.4f +- %0.4f" % (recall_test.mean(), recall_test.std())) print("AUC %0.4f +- %0.4f" % (auc_test.mean(), auc_test.std())) print("Precision %0.4f +- %0.4f" % (precision_test.mean(), precision_test.std()))
def main(): parser = ArgumentParser() parser.add_argument('-e', '--epoch', help='Number of epochs for training', \ dest='epoch', type=int, required=True) parser.add_argument('-b', '--batchsize', help='Training batch size', \ dest='batch_size', type=int, required=True) parser.add_argument('-c', '--chunksize', help='Inference chunk size', \ dest='chunk_size', type=int, required=True) parser.add_argument('-r', '--random_shuffle', action='store_true', \ help='Shuffle training data set', dest='shuffle', default=False) parser.add_argument('-a', '--app for test', help='application name for test', \ dest='testapp', required=True) options = parser.parse_args() gl_dir = os.environ.get('GRAPHLEARN') #log_dir = 'path..../glog/' log_dir = gl_dir + '/glog/' #Commented out as per Chenhui's suggestion to introduce randomness #in training data via random permutation if not options.shuffle: np.random.seed(1) random.seed(1) test_app=options.testapp print("before-load-time stamp:", dt.now().strftime("%m/%d/%Y %H:%M:%S")) feat_data, labels, adj_lists, train, test = load_graph_data(test_app) num_nodes = feat_data.shape[0] feat_dim = feat_data.shape[1] #hidden_dim = 64 hidden_dim = 128 features = nn.Embedding(num_nodes, feat_dim) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) #features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, feat_dim, hidden_dim, adj_lists, agg1, gcn=False, cuda=False) agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, hidden_dim, adj_lists, agg2, base_model=enc1, gcn=False, cuda=False) agg3 = MeanAggregator(lambda nodes : enc2(nodes).t(), cuda=False) enc3 = Encoder(lambda nodes : enc2(nodes).t(), enc2.embed_dim, hidden_dim, adj_lists, agg3,base_model=enc2, gcn=False, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 enc3.num_samples = 5 graphsage = SupervisedGraphSage(3, enc3) optimizer = torch.optim.Adam(filter(lambda p : p.requires_grad, graphsage.parameters()), \ lr=0.001)#,weight_decay=5e-4) epoch = options.epoch batch_size = options.batch_size chunk_size = options.chunk_size num_batch = len(train)//batch_size if not options.shuffle: #NOTE: Train print("before-train-time stamp:", dt.now().strftime("%m/%d/%Y %H:%M:%S")) graphsage, times, LOSS = train_graph(epoch, num_batch, batch_size, labels, \ train, optimizer, graphsage) #NOTE: Infer print("after-train-time and before-infer-time stamp:", dt.now().strftime("%m/%d/%Y %H:%M:%S")) precision, recall, accuracy, f1, cm = infer_graph(test, graphsage, labels, chunk_size,test_app) print("after-infer-time stamp:", dt.now().strftime("%m/%d/%Y %H:%M:%S")) #NOTE: Summarize now_time = dt.now().strftime("%m/%d/%Y %H:%M:%S") mean_batch_time = np.mean(times) print("Average batch time for training:", mean_batch_time) print('Final loss at the end of the training: ' + str(LOSS) + '\n\n') print("Test Precision: ", precision) print("Test Recall: ", recall) print("Test Accuracy: ", accuracy) print("Test F1: ", f1) fh = open(log_dir + '/' + str(epoch) + '_' + str(batch_size) + \ '_' + str(chunk_size) + '.txt', 'w') fh.write('Timestamp: ' + now_time + '\n\n') fh.write('Final loss at the end of the training: ' + str(LOSS) + '\n\n') fh.write('Average batch time for training: ' + str(mean_batch_time) + '\n\n') fh.write("Test Precision: " + str(precision) + '\n') fh.write("Test Recall: " + str(recall) + '\n') fh.write("Test Accuracy: " + str(accuracy) + '\n') fh.write("Test F1: " + str(f1) + '\n') fh.write(str(cm)) fh.close() else: #NOTE: Introducing randomness stability_stat_ = {} for i in range(0, 5): random.shuffle(train) print("Training on the {}-th random shuffled data ".format(i)) #NOTE: Train print("before-train-time stamp:", dt.now().strftime("%m/%d/%Y %H:%M:%S")) graphsage, times, LOSS = train_graph(epoch, num_batch, batch_size, labels, \ train, optimizer, graphsage) #NOTE: Infer print("after-train-time and before-infer-time stamp:", dt.now().strftime("%m/%d/%Y %H:%M:%S")) precision, recall, accuracy, f1, cm = infer_graph(test, graphsage, labels, chunk_size,test_app) print("after -infer-time stamp:", dt.now().strftime("%m/%d/%Y %H:%M:%S")) #NOTE: Store stat stability_stat_[str(i)] = [precision, recall, accuracy, f1] print('\n\n') stability_stat = ODict(sorted(stability_stat_.items(), key=lambda t: t[1][1], reverse=True)) del stability_stat_ pp.pprint(stability_stat) sh = open(log_dir + '/' + 'stability_stat.table', 'w') scontent = printTable1(stability_stat, \ ['Shuffle No', 'Precision', 'Recall', 'Accuracy', 'F1'] ) sh.write(scontent) sh.close() del stability_stat return
def run_cora(): np.random.seed(1) random.seed(1) num_nodes = 2708 feat_data, labels, adj_lists, adj, degrees, edges = load_cora() neg_adj_list = [ list(set(range(num_nodes)).intersection(adj_lists[node])) for node in range(num_nodes) ] features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) adj = Variable(torch.FloatTensor(adj), requires_grad=False) if torch.cuda.is_available(): features, adj = features.cuda(), adj.cuda() # features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(7, enc2) if torch.cuda.is_available(): graphsage = graphsage.cuda() # rand_indices = np.random.permutation(num_nodes) # test = rand_indices[:1000] # val = rand_indices[1000:1500] # train = list(rand_indices[1500:]) train = list(range(140)) val = np.array(range(200, 500)) test = np.array(range(500, 1500)) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) times = [] for batch in range(100): batch_edges = edges[:256] random.shuffle(batch_edges) nodes1, nodes2 = batch_edges[:, 0], batch_edges[:, 1] # neg_nodes = fixed_unigram_candidate_sampler( # num_sampled=NUM_SAMPLED, # unique=False, # range_max=len(degrees), # distortion=0.75, # unigrams=degrees # ) neg_nodes = sample_negative(nodes1, neg_adj_list) start_time = time.time() optimizer.zero_grad() loss = graphsage.unsup_loss(nodes1, nodes2, neg_nodes) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) if batch % 100 == 0: embeds, _ = graphsage.forward(list(range(num_nodes))) accs = classify(embeds.detach().cpu().numpy(), labels, 0.5) print(batch, loss.item(), accs) times = [] for batch in range(100): batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() batch_labels = Variable(torch.LongTensor( labels[np.array(batch_nodes)])) if torch.cuda.is_available(): batch_labels = batch_labels.cuda() loss = graphsage.loss(batch_nodes, batch_labels) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(batch, loss.item()) _, test_output = graphsage.forward(test) print( "Testing F1:", f1_score(labels[test], test_output.detach().cpu().numpy().argmax(axis=1), average="micro")) print("Average batch time:", np.mean(times))
def run_cora(printout=True): begin = timeit.default_timer() np.random.seed(1) random.seed(1) num_nodes = 2708 feat_data, labels, adj_lists = load_cora() features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) # features.cuda() # MeanAggregator params # features, cuda=False, gcn=False # Encoder params # features, feature_dim, embed_dim, adj_lists, aggregator, num_sample=10, base_model=None, # gcn=False, cuda=False, feature_transform=False agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(7, enc2) # graphsage.cuda() rand_indices = np.random.permutation(num_nodes) # len(rand_indices) = 2708 test = rand_indices[:1000] # 1000 exemplos val = rand_indices[1000:1500] # 1500 exemplos train = list(rand_indices[1500:]) # 1208 exemplos # De onde saiu graphsage.parameters() ???? # A classe chama super() . Onde estah super() ???? optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) times = [] ################################################################################################## train_loss = list() # inicializa o vetor for batch in range(100): batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss( batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) ################################################################################################## train_loss.append(loss.data[0]) # armazena o erro if printout: print batch, loss.data[0] end = timeit.default_timer() elapsed = end - begin val_output = graphsage.forward(val) score = f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro") if printout: print "Validation F1:", score print "Average batch time:", np.mean(times) return train_loss, score, elapsed
cuda_available = False if torch.cuda.is_available(): cuda_available = True feat_data, labels, adj_lists = load_cora() features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) if cuda_available: features.cuda() agg1 = MeanAggregator(features, cuda=cuda_available) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=cuda_available) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=cuda_available) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=cuda_available) model = SupervisedGraphSage(7, enc2) agg1.load_state_dict( torch.load(path + "MeanAggregator1.model",
def run_pubmed(): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') seed = 123 np.random.seed(seed) random.seed(seed) torch.manual_seed(seed) if torch.cuda.is_available(): torch.cuda.manual_seed(seed) num_nodes = 19717 num_feat = 500 num_embed = 128 feat_data, labels, adj_lists = load_pubmed() features = nn.Embedding(num_nodes, num_feat) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) features.to(device) # use gcn as aggregator agg1 = MeanAggregator(features, device) enc1 = Encoder(features, num_feat, num_embed, adj_lists, agg1, device, gcn=True) agg2 = MeanAggregator(lambda nodes: enc1(nodes), device) enc2 = Encoder(lambda nodes: enc1(nodes), num_embed, num_embed, adj_lists, agg2, device, base_model=enc1, gcn=True) # use different nums for different layer according to the paper enc1.num_samples = 10 enc2.num_samples = 25 graphsage = SupervisedGraphSage(3, enc2) graphsage.to(device) rand_indices = np.random.permutation(num_nodes) test = rand_indices[:1000] val = rand_indices[1000:1500] train = list(rand_indices[1500:]) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) times = [] for batch in range(200): batch_nodes = train[:1024] random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss( batch_nodes, torch.LongTensor(labels[np.array(batch_nodes)]).cuda()) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(batch, loss.item()) val_output = graphsage.forward(val) test_output = graphsage.forward(test) print( "Validation F1:", f1_score(labels[val], val_output.cpu().data.numpy().argmax(axis=1), average="micro")) print( "Test F1:", f1_score(labels[test], test_output.cpu().data.numpy().argmax(axis=1), average="micro")) print("Average batch time:", np.mean(times))
def run_cora(): np.random.seed(1) random.seed(1) num_nodes = 2708 """ feat_data 是每篇论文对应的词表 是一个二维数组,共2708行,1433列。 labels 是论文的类别标签,共分7个不同子领域 是一个二维数组,共2708行,1列。每行元素为一个节点对应的label,共7种,从0到6. adj_lists 论文引用关系表。 字典的字典,里面共有2708个元素,每个元素的key为节点编号,值为该节点的邻接点组成的字典 例如其中一个元素为 310: {2513, 74, 747, 668} 由于监督任务是为了区分子领域,因此这个引用关系表被构造成无向图。 """ feat_data, labels, adj_lists = load_cora() # 2708个节点,每个节点生成一个1433维的向量. # 对于每个节点的1433维上,用高斯分布进行初始化。存储在features.weight中。 features = nn.Embedding(2708, 1433) # 用feat_data的值覆盖掉features.weight,且把features.weight转为可训练的状态 features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) # features.cuda() # 初始化agg1对象 # 初始化传参 features = features,尺寸为(2708, 1433) # 在前向传播时,仅仅是对本次batch的每个节点,用其邻接点嵌入的平均来表示它自己, # 结果张量 neigh_feats 的尺寸为(batch_size,1433) agg1 = MeanAggregator(features, cuda=False) # 初始化enc1对象 # 初始化传参 features = features,尺寸为(2708, 1433),feature_dim=1433,embed_dim=128 # 在前向传播时,仅仅相当于对 neigh_feats 进行了一层编码映射(矩阵乘法+激活),从1433维到128维 # 结果张量 combined 的尺寸(128,batch_size) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) # 初始化agg2对象 # 初始化传参 features = enc1输出的转置,尺寸为(batch_size,128) # 在前向传播时,仅仅是对本次batch的每个节点,用其邻接点嵌入的平均来表示它自己, # 结果张量 neigh_feats 的尺寸为(batch_size,128) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) # 初始化enc2对象 # 初始化传参 features = enc1输出的转置,尺寸为(batch_size,128) # 在前向传播时,仅仅相当于对 neigh_feats 进行了一层编码映射(矩阵乘法+激活),从128维到128维 # 结果张量 combined 的尺寸(128,batch_size) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 5 enc2.num_samples = 5 # 通过SupervisedGraphSage类,生成一个完整的计算图,包括前向传播及损失计算 # enc2可被看做一个几乎已串联完成的计算图,输入为features,输出为经过激活的combined graphsage = SupervisedGraphSage(7, enc2) # graphsage.cuda() # 随机化一个节点的序列。即生成一个数组,长度为num_nodes,里面所有元素是对[0,num_nodes-1]一个序列的shuffle。 rand_indices = np.random.permutation(num_nodes) """ 500个节点来测试 2208个节点来训练 """ val = rand_indices[:500] train = rand_indices[500:] # 定义优化器 # 其中filter与lambda的作用是: # 通过判断requires_grad的真假来过滤参数,即SGD只训练那些graphsage.parameters()里需要训练的参数(requires_grad为True) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) for batch in range(120): # 每个batch只跑头256个节点,下一个batch的头256个节点又不一样(因为shuffle了)。 batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() # 计算损失 # batch_nodes 是节点索引的数组 # Variable(...) 是把batch_nodes 转换为节点对应label数组,格式为tensor loss = graphsage.loss(batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) # 计算梯度 loss.backward() # 参数更新 optimizer.step() train_output = graphsage.forward(train) # 用验证集的节点前向传播一次 val_output = graphsage.forward(val) print("Train:", classification_report(labels[train], train_output.data.numpy().argmax(axis=1))) print("Validation:", classification_report(labels[val], val_output.data.numpy().argmax(axis=1))) # 打印f1_score,即认为precision和recall同等重要。 # 因为val是验证集的样本的索引,所以labels[val]即可获得对应的label数组 print("Validation F1:", f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro"))
def run_pubmed(): np.random.seed(1) random.seed(1) num_nodes = 19717 feat_data, labels, adj_lists = load_pubmed() ###################################################################################################################### # TESTAR AS DUAS FORMAS: INCLUIR NA MATRIZ DE FEATURES AS INFORMACOES # (talvez isso nao seja necessario ja que o graphsage faz os embeddings por agregacao) # OU # APENAS USAR O RESULTADO DO K-MEANS PARA SEPARAR OS LOTES ###################################################################################################################### # normalization scaler = preprocessing.StandardScaler().fit(feat_data) feat_data = scaler.transform(feat_data) # Metodo Elbow para encontrar o numero de classes if False: wcss = [] # Within Cluster Sum of Squares for i in range(2, 11): kmeans = KMeans(n_clusters = i, init = 'random') kmeans.fit(feat_data) print i,kmeans.inertia_ wcss.append(kmeans.inertia_) plt.plot(range(2, 11), wcss) plt.title('O Metodo Elbow') plt.xlabel('Numero de Clusters') plt.ylabel('WCSS') plt.show() return None, None # Metodo Elbow encontrou 5 classes kmeans = KMeans(n_clusters = 5, init = 'random') kmeans.fit(feat_data) kmeans.fit_transform(feat_data) klabels = kmeans.labels_ if False: return labels, klabels ###################################################################################################################### ###################################################################################################################### features = nn.Embedding(19717, 500) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) # features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 500, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes : enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes : enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 10 enc2.num_samples = 25 graphsage = SupervisedGraphSage(3, enc2) # graphsage.cuda() rand_indices = np.random.permutation(num_nodes) ################################################################################################################### # AQUI EU ATRIBUO INDICES AOS CONJUNTOS USANDO AS QUANTIDADES PROPORCIONAIS DE CADA K-MEANS CLUSTER ################################################################################################################### #test = rand_indices[:1000] #val = rand_indices[1000:1500] #train = list(rand_indices[1500:]) train, val, test, ratio = _processes_set(klabels, num_clusters = 5, num_examples = num_nodes) ################################################################################################################### ################################################################################################################### optimizer = torch.optim.SGD(filter(lambda p : p.requires_grad, graphsage.parameters()), lr=0.7) times = [] ################################################################################################################### # quantidade proporcional do batch, inicializacao do vetor de erro ################################################################################################################### quantity = np.empty((5,1), dtype=int) quantity[:,0] = ratio * 1024 quantity = list(quantity.flatten()) train_loss = list() ################################################################################################################### ################################################################################################################### for batch in range(200): ################################################################################################## # O QUE EU POSSO FAZER AQUI EH EMBARALHAR OS VERTICES SEPARADAMENTE DENTRO DOS CLUSTERS # PARA MONTAR BATCH_NODES, PEGAR AS QUANTIDADES PROPORCIONAIS ################################################################################################## batch_nodes = list() for key in train: batch_nodes.extend(train[key][:quantity[key]]) random.shuffle(train[key]) random.shuffle(batch_nodes) ################################################################################################## ################################################################################################## #batch_nodes = train[:1024] #random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss(batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time-start_time) ################################################################################################## train_loss.append(loss.data[0]) # armazena o erro print batch, loss.data[0] val_output = graphsage.forward(val) score = f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro") print "Validation F1:", score print "Average batch time:", np.mean(times) return train_loss, score
def run_pubmed(): np.random.seed(1) random.seed(1) num_nodes = 19717 feat_data, labels, adj_lists = load_pubmed() features = nn.Embedding(19717, 500) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) # features.cuda() agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, 500, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) enc1.num_samples = 10 enc2.num_samples = 25 graphsage = SupervisedGraphSage(3, enc2) # graphsage.cuda() rand_indices = np.random.permutation(num_nodes) test = rand_indices[:1000] val = rand_indices[1000:1500] train = list(rand_indices[1500:]) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) times = [] ################################################################################################## train_loss = list() # inicializa o vetor for batch in range(200): batch_nodes = train[:1024] random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss( batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) ################################################################################################## train_loss.append(loss.data[0]) # armazena o erro print batch, loss.data[0] val_output = graphsage.forward(val) score = f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro") print "Validation F1:", score print "Average batch time:", np.mean(times) return train_loss, score
def run_cora(): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # setting random seed seed = 424 np.random.seed(seed) random.seed(seed) torch.manual_seed(seed) if torch.cuda.is_available(): torch.cuda.manual_seed(seed) num_nodes = 2708 num_feat = 1433 num_embed = 128 num_classes = 7 feat_data, labels, adj_lists = load_cora() features = nn.Embedding(num_nodes, num_feat) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) features.to(device) agg1 = MeanAggregator(features, device) enc1 = Encoder(features, num_feat, num_embed, adj_lists, agg1, device, gcn=True) agg2 = MeanAggregator(lambda nodes: enc1(nodes), device) enc2 = Encoder(lambda nodes: enc1(nodes), num_embed, num_embed, adj_lists, agg2, device, base_model=enc1, gcn=True) enc1.num_samples = 5 enc2.num_samples = 5 graphsage = SupervisedGraphSage(num_classes, enc2) graphsage.to(device) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) rand_indices = np.random.permutation(num_nodes) # shuffle index test = rand_indices[:1000] val = rand_indices[1000:1500] train = list(rand_indices[1500:]) times = [] for batch in range(100): batch_nodes = train[:256] # shuffle to random sampling random.shuffle(train) start_time = time.time() optimizer.zero_grad() # 1. batch_nodes -> result (num_nodes, num_classes) # 2. loss(result, labels) loss = graphsage.loss( batch_nodes, torch.LongTensor(labels[np.array(batch_nodes)]).to(device)) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(batch, loss.item()) val_output = graphsage.forward(val) test_output = graphsage.forward(test) # average: # micro total F1-score # macro average of F1 of all classes print( "Validation F1:", f1_score(labels[val], val_output.cpu().data.numpy().argmax(axis=1), average="micro")) print( "Test F1:", f1_score(labels[test], test_output.cpu().data.numpy().argmax(axis=1), average="micro")) print("Average batch time:", np.mean(times)) # numpy's param can be list
def run_cora(three_layer=False): np.random.seed(1) random.seed(1) torch.manual_seed(1) num_nodes = 2708 feat_data, labels, adj_lists = load_cora() features = nn.Embedding(2708, 1433) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) # features.cuda() agg1 = MeanAggregator(features, cuda=True) #agg1 = MaxPoolAggregator(features, 1433, cuda=False) enc1 = Encoder(features, 1433, 128, adj_lists, agg1, gcn=True, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) #agg2 = MaxPoolAggregator(lambda nodes: enc1(nodes).t(), 128, cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, 128, adj_lists, agg2, base_model=enc1, gcn=True, cuda=False) if three_layer: agg3 = MeanAggregator(lambda nodes: enc2(nodes).t(), cuda=False) #agg3 = MaxPoolAggregator(lambda nodes: enc2(nodes).t(), 128, cuda=False) enc3 = Encoder( lambda nodes: enc2(nodes).t(), enc2.embed_dim, 128, adj_lists, agg3, base_model=enc1, gcn=True, cuda=False ) # not exactly sure what base_model does, but it's not referenced anywhere enc3.num_samples = 5 enc1.num_samples = 5 enc2.num_samples = 5 if three_layer: graphsage = SupervisedGraphSage(7, enc3) else: graphsage = SupervisedGraphSage(7, enc2) # graphsage.cuda() rand_indices = np.random.permutation(num_nodes) test = rand_indices[:1000] val = rand_indices[1000:1500] train = list(rand_indices[1500:]) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.7) #optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.01) times = [] for batch in range(100): batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() loss = graphsage.loss( batch_nodes, Variable(torch.LongTensor(labels[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(batch, loss.item()) val_output = graphsage.forward(val) print( "Validation F1:", f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro")) print("Average batch time:", np.mean(times))
def run_bc(sample_count, model_name, output): # np.random.seed(1) #random.seed(1) num_nodes = 10312 feature_dim = 128 embed_dim = 128 # Select training&test set from qualified nodes selected_id = get_partial_list(1500) # Load node2vec features adj_lists, adj_lists_empty, features_node2vec = load_blog_catalog( selected_id) # Build the graph adj_lists_train, adj_lists_test, train, test, adj_lists = preprocessing( selected_id, 300, sample_count, adj_lists, adj_lists_empty, True) # Init the input feature of every node into all-one vector feat_data = np.ones((num_nodes, feature_dim)) features = nn.Embedding(num_nodes, feature_dim) features.weight = nn.Parameter(torch.FloatTensor(feat_data), requires_grad=False) agg1 = MeanAggregator(features, cuda=True) enc1 = Encoder(features, feature_dim, embed_dim, adj_lists_train, agg1, gcn=False, cuda=False) agg2 = MeanAggregator(lambda nodes: enc1(nodes).t(), cuda=False) enc2 = Encoder(lambda nodes: enc1(nodes).t(), enc1.embed_dim, embed_dim, adj_lists_train, agg2, base_model=enc1, gcn=False, cuda=False) # Possible additional layers # agg3 = MeanAggregator(lambda nodes: enc2(nodes).t(), cuda=False) # enc3 = Encoder(lambda nodes: enc2(nodes).t(), enc2.embed_dim, embed_dim, adj_lists_train, agg3, # base_model=enc2, gcn=False, cuda=False) # agg4 = MeanAggregator(lambda nodes: enc3(nodes).t(), cuda=False) # enc4 = Encoder(lambda nodes: enc3(nodes).t(), enc3.embed_dim, embed_dim, adj_lists_train, agg4, # base_model=enc3, gcn=False, cuda=False) enc1.num_sample = sample_count enc2.num_sample = 10 # enc3.num_sample = 15 # enc4.num_sample = 20 # Initialize the Graph-SAGE model graphsage = RegressionGraphSage(enc2) # Prepare the input data for the testing model feat_data_test = np.ones((10312, 128)) features_test = nn.Embedding(num_nodes, feature_dim) features_test.weight = nn.Parameter(torch.FloatTensor(feat_data_test), requires_grad=False) # Set up the model with testing graph structure agg1_test = MeanAggregator(features_test, cuda=True) enc1_test = Encoder(features_test, feature_dim, embed_dim, adj_lists_test, agg1_test, gcn=False, cuda=False) agg2_test = MeanAggregator(lambda nodes: enc1_test(nodes).t(), cuda=False) enc2_test = Encoder(lambda nodes: enc1_test(nodes).t(), enc1_test.embed_dim, embed_dim, adj_lists_test, agg2_test, base_model=enc1_test, gcn=False, cuda=False) # agg3_test = MeanAggregator(lambda nodes: enc2_test(nodes).t(), cuda=False) # enc3_test = Encoder(lambda nodes: enc2_test(nodes).t(), enc2_test.embed_dim, embed_dim, adj_lists_test, agg3_test, # base_model=enc2_test, gcn=False, cuda=False) # agg4_test = MeanAggregator(lambda nodes: enc3_test(nodes).t(), cuda=False) # enc4_test = Encoder(lambda nodes: enc3_test(nodes).t(), enc3_test.embed_dim, embed_dim, adj_lists_test, agg4_test, # base_model=enc3_test, gcn=False, cuda=False) enc1_test.num_sample = sample_count enc2_test.num_sample = 10 # enc3_test.num_sample = 10 # enc4_test.num_sample = 10 optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, graphsage.parameters()), lr=0.3) times = [] for epoch in range(1000): batch_nodes = train[:256] random.shuffle(train) start_time = time.time() optimizer.zero_grad() # Select a random number of the sample size of the first layer and build the training graph according to this sample_count_epoch = random.randint(1, sample_count) adj_lists_train_1, _, _, _, _ = preprocessing(selected_id, 300, sample_count_epoch, adj_lists, adj_lists_empty, False) # adj_lists_train_2, _, _, _, _ = preprocessing(selected_id, 300, 10, adj_lists, adj_lists_empty, True) # Configure the hyperparameters in each epoch enc1.adj_lists = adj_lists_train_1 enc2.adj_lists = adj_lists_train_1 enc1.num_sample = sample_count_epoch # Calculate the loss and back propagate it loss = graphsage.loss( batch_nodes, Variable( torch.FloatTensor(features_node2vec[np.array(batch_nodes)]))) loss.backward() optimizer.step() end_time = time.time() times.append(end_time - start_time) print(epoch, loss) # Every 10 epochs, use the model to run the test graph and data, and compute the current cosine similarity if epoch % 10 == 9: graphsage_test = RegressionGraphSage(enc2_test) graphsage_test.load_state_dict(graphsage.state_dict()) graphsage_test.eval() embed_output = graphsage_test.forward(test) cos = nn.CosineSimilarity(dim=1, eps=1e-6) print( "Cosine similarity: ", cos(embed_output, torch.FloatTensor(features_node2vec[test])).mean(0).item()) # Save model torch.save(graphsage.state_dict(), model_name) # run_bc_test_based_on_group(adj_lists_test, feat_data, test, model_name, output, sample_count) # embed_output = graphsage.forward(test) # cos = nn.CosineSimilarity(dim=1, eps=1e-6) # print("Average Validation Cosine Similarity:", cos(embed_output, torch.FloatTensor(feat_data[test])).mean(0).item()) # # print("Validation F1:", f1_score(labels[val], val_output.data.numpy().argmax(axis=1), average="micro")) print("Average batch time:", np.mean(times))