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():
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 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 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 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 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_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_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():
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_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 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(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
np.random.seed(1)
random.seed(1)
num_nodes = 2708
path = "/data/ducva/graphsage-simple/data/"
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,
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 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 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_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 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_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(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))
