def main(args):
# load and preprocess dataset
if args.gpu > 0:
cuda = True
device = torch.device('cuda:{}'.format(args.gpu))
else:
device = torch.device('cpu')
cuda = False
cora_data = NeptuneCoraDataset(device, valid_ratio=0.1, test_ratio=0.2)
#cora_data = CoraDataset(device, valid_ratio=0.1, test_ratio=0.2)
features = cora_data.features
test_set = cora_data.test_set
g = cora_data.g
in_feats = features['h**o'].shape[1]
n_edges = g.number_of_edges()
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
if cuda:
norm = norm.cuda()
g.ndata['norm'] = norm.unsqueeze(1)
# create GCN model
model = GCN(g, in_feats, args.n_hidden, cora_data.n_class, args.n_layers,
F.relu)
model.load_state_dict(torch.load(args.model_path))
if cuda:
model.cuda()
print()
acc = evaluate(model, features['h**o'], test_set)
print("Test accuracy {:.2%}".format(acc))
def main(args):
# load and preprocess dataset
if args.gpu > 0:
cuda = True
device = torch.device('cuda:{}'.format(args.gpu))
else:
device = torch.device('cpu')
cuda = False
cora_data = NeptuneCoraDataset(device, valid_ratio=0.0, test_ratio=0.1)
#cora_data = CoraDataset(device, valid_ratio=0.1, test_ratio=0.2)
features = cora_data.features
# we infer type of nodes in test_set
test_set = cora_data.test_set
g = cora_data.g
in_feats = features['h**o'].shape[1]
n_edges = g.number_of_edges()
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
if cuda:
norm = norm.cuda()
g.ndata['norm'] = norm.unsqueeze(1)
# create GCN model
model = GCN(g, in_feats, args.n_hidden, cora_data.n_class, args.n_layers,
F.relu)
model.load_state_dict(torch.load(args.model_path))
if cuda:
model.cuda()
model.eval()
with torch.no_grad():
logits = model(features['h**o'])
logits = logits[test_set[0]]
_, indices = torch.max(logits, dim=1)
nodes = test_set[0].numpy().tolist()
indices = indices.numpy().tolist()
for idx, label in enumerate(indices):
node_id = nodes[idx]
truth_nid = cora_data.translate_node(node_id)
truth_label = cora_data.translate_label(label)
print(
"{{\"gremlin\":\"g.V(\\\"{}\\\").property(\\\"category\\\", \\\"{}\\\")\"}}"
.format(truth_nid, truth_label))
def write_test(model_name):
test_dataset = Smiles(data_choice='test', pos_weight=my_cfg['pos_weight'], device=device)
test_loader = DataLoader(test_dataset, batch_size=my_cfg['batch_size'], shuffle=False)
best_model = GCN(34, 32, 2)
best_model.load_state_dict(torch.load(model_name))
if torch.cuda.is_available():
best_model = best_model.cuda()
best_model.eval()
print('\nStarting test ...')
results = []
for i, (names, adj, features) in enumerate(test_loader):
res = best_model(features, adj).detach().cpu()
res = res.reshape(-1)
for name, my_res in zip(names, res):
results.append({'name': name, 'res': my_res})
exp_num = my_cfg['exp_num']
model_name = model_name.split('.')[-2][1:]
with open(f'./data/test/output_{model_name}.txt', "w") as f:
f.write('Chemical,Label\n')
assert len(results) == 610
for i in range(len(results)):
my_name = results[i]['name']
my_res = results[i]['res']
my_res = my_res.detach().cpu().numpy()
f.write(f'{my_name},{my_res}\n')
return
def main():
model = GCN(34, 32, 2)
# model.load_state_dict(torch.load('model_40.pth'))
if torch.cuda.is_available():
model = model.cuda()
# model._initialize()
print(my_cfg)
optimizer = torch.optim.Adam(model.parameters(), lr=my_cfg['lr'])
#optimizer = torch.optim.RMSprop(model.parameters(), lr=my_cfg['lr'])
lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(
optimizer, milestones=my_cfg['milestones'], gamma=0.1)
train(model, optimizer, lr_scheduler)
return
def run(rank, world_size, args):
print('Running DDP on rank', rank, 'world size', world_size)
setup(rank, world_size, args)
dev_id = ragdoll.device_id()
if len(args.input_graph) > 0 or len(args.cached_dir) > 0:
data = SynDataset(rank == 0, args)
else:
data = Dataset(rank == 0, args)
feat_size = args.feat_size
features = torch.FloatTensor(data.features).cuda()
labels = torch.LongTensor(data.labels).cuda()
train_mask = torch.BoolTensor(data.train_mask).cuda()
val_mask = torch.BoolTensor(data.val_mask).cuda()
test_mask = torch.BoolTensor(data.test_mask).cuda()
n_classes = args.n_classes
n_nodes = data.n_nodes
local_n_nodes = data.local_n_nodes
model = GCN(data.graph, n_nodes, local_n_nodes, True, feat_size, args.n_hidden, n_classes,
args.n_layers, F.relu, args.dropout, comm_net=args.comm_net)
model.cuda()
model = DDP(model, device_ids=[dev_id])
loss_fcn = torch.nn.CrossEntropyLoss()
# use optimizer
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
optimizer.zero_grad()
dur = []
print("Start training... for {} epochs".format(args.n_epochs))
for epoch in range(args.n_epochs):
print('Epoch {} -------------'.format(epoch))
model.train()
torch.distributed.barrier()
if epoch >= 3:
t0 = time.time()
logits = model(features)
loss = loss_fcn(logits[train_mask], labels[train_mask])
optimizer.zero_grad()
loss.backward()
torch.cuda.synchronize()
t1 = time.time()
optimizer.step()
torch.cuda.synchronize()
t2 = time.time()
if epoch >= 3:
dur.append(time.time() - t0)
# acc, _, _ = evaluate(model, features, labels, val_mask)
# print('acc is {}, loss is {}, this epoch using time {}, avg time {}.'.format(
# acc, loss.item(), dur[-1] if epoch >= 3 else 0, np.mean(dur)))
print('Using time to synchronize model', t2 - t1)
print('Peak memory is {} GB'.format(
torch.cuda.max_memory_allocated(dev_id) / 1e9))
print('this epoch uses time {} s, avg time {} s.'.format(
dur[-1] if epoch >= 3 else 0, np.mean(dur)))
##acc, corr, total = evaluate(model, features, labels, test_mask)
##print('my corr is', corr, 'my total is', total)
##corr = torch.Tensor([corr]).cuda(dev_id)
##total = torch.Tensor([total]).cuda(dev_id)
##corrs, totals = [], []
##for i in range(world_size):
## corrs.append(torch.Tensor([0]).cuda(dev_id))
## totals.append(torch.Tensor([0]).cuda(dev_id))
##torch.distributed.all_gather(corrs, corr)
##torch.distributed.all_gather(totals, total)
##print('corrs is', corrs)
##print('totals is', totals)
##corr = torch.stack(corrs, dim=0).sum(dim=0).item() * 1.0
##total = torch.stack(totals, dim=0).sum(dim=0).item() * 1.0
##print('Test acc is', corr / total)
cleanup()
def main(args):
# load and preprocess dataset
data = load_data(args)
features = torch.FloatTensor(data.features)
labels = torch.LongTensor(data.labels)
train_mask = torch.ByteTensor(data.train_mask)
val_mask = torch.ByteTensor(data.val_mask)
test_mask = torch.ByteTensor(data.test_mask)
in_feats = features.shape[1]
n_classes = data.num_labels
n_edges = data.graph.number_of_edges()
n_nodes = data.graph.number_of_nodes()
print("""----Data statistics------'
#Nodes %d
#Edges %d
#Feature %d
#Classes %d
#Train samples %d
#Val samples %d
#Test samples %d""" %
(n_nodes, n_edges, in_feats, n_classes,
train_mask.sum().item(),
val_mask.sum().item(),
test_mask.sum().item()))
if args.gpu < 0:
cuda = False
else:
cuda = True
torch.cuda.set_device(args.gpu)
features = features.cuda()
labels = labels.cuda()
train_mask = train_mask.cuda()
val_mask = val_mask.cuda()
test_mask = test_mask.cuda()
# graph preprocess and calculate normalization factor
g = data.graph
# add self loop
if args.self_loop:
g.remove_edges_from(g.selfloop_edges())
g.add_edges_from(zip(g.nodes(), g.nodes()))
g = DGLGraph(g)
n_edges = g.number_of_edges()
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
if cuda:
norm = norm.cuda()
g.ndata['norm'] = norm.unsqueeze(1)
# create GCN model
model = GCN(g,
in_feats,
args.n_hidden,
n_classes,
args.n_layers,
F.relu,
args.dropout)
if cuda:
model.cuda()
loss_fcn = torch.nn.CrossEntropyLoss()
# use optimizer
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
# initialize graph
dur = []
for epoch in range(args.n_epochs):
model.train()
if epoch >= 3:
t0 = time.time()
# forward
logits = model(features)
if epoch >= 3:
dur.append(time.time() - t0)
loss = loss_fcn(logits[train_mask], labels[train_mask])
optimizer.zero_grad()
loss.backward()
optimizer.step()
acc = evaluate(model, features, labels, val_mask)
print("Epoch {:05d} | Time(s) {:.4f} | Loss {:.4f} | Accuracy {:.4f} | "
"ETputs(KTEPS) {:.2f}". format(epoch, np.mean(dur), loss.item(),
acc, n_edges / np.mean(dur) / 1000))
print()
acc = evaluate(model, features, labels, test_mask)
print("Test Accuracy {:.4f}".format(acc))
def main(args):
# load and preprocess dataset
# data = load_data(args)
g, graph_labels = load_graphs(
'/yushi/dataset/Amazon2M/Amazon2M_dglgraph.bin')
assert len(g) == 1
g = g[0]
data = g.ndata
features = torch.FloatTensor(data['feat'])
labels = torch.LongTensor(data['label'])
if hasattr(torch, 'BoolTensor'):
train_mask = data['train_mask'].bool()
val_mask = data['val_mask'].bool()
test_mask = data['test_mask'].bool()
# else:
# train_mask = torch.ByteTensor(data.train_mask)
# val_mask = torch.ByteTensor(data.val_mask)
# test_mask = torch.ByteTensor(data.test_mask)
in_feats = features.shape[1]
n_classes = 47
n_edges = g.number_of_edges()
print("""----Data statistics------'
#Edges %d
#Classes %d
#Train samples %d
#Val samples %d
#Test samples %d""" %
(n_edges, n_classes, train_mask.int().sum().item(),
val_mask.int().sum().item(), test_mask.int().sum().item()))
if args.gpu < 0:
cuda = False
else:
cuda = True
torch.cuda.set_device(args.gpu)
features = features.cuda()
labels = labels.cuda()
train_mask = train_mask.cuda()
val_mask = val_mask.cuda()
test_mask = test_mask.cuda()
# graph preprocess and calculate normalization factor
# g = data.graph
# add self loop
# if args.self_loop:
# g.remove_edges_from(nx.selfloop_edges(g))
# g.add_edges_from(zip(g.nodes(), g.nodes()))
# g = DGLGraph(g)
n_edges = g.number_of_edges()
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
if cuda:
norm = norm.cuda()
g.ndata['norm'] = norm.unsqueeze(1)
# create GCN model
model = GCN(g, in_feats, args.n_hidden, n_classes, args.n_layers, F.relu,
args.dropout)
if cuda:
model.cuda()
print(model)
loss_fcn = torch.nn.CrossEntropyLoss()
# use optimizer
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
# initialize graph
dur = []
start = time.time()
for epoch in range(args.n_epochs):
model.train()
if epoch >= 3:
t0 = time.time()
# forward
logits = model(features)
loss = loss_fcn(logits[train_mask], labels[train_mask])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch >= 3:
dur.append(time.time() - t0)
acc = evaluate(model, features, labels, val_mask)
print(
"Epoch {:05d} | Time(s) {:.4f} | Loss {:.4f} | Accuracy {:.4f} | "
"ETputs(KTEPS) {:.2f}".format(epoch, np.mean(dur), loss.item(),
acc, n_edges / np.mean(dur) / 1000))
print()
acc = evaluate(model, features, labels, val_mask) # no test_mask
print("Test accuracy {:.2%}".format(acc))
print(
f'Training Time Consuming: {np.sum(dur)}, all time cost: {time.time() - start}'
)
def main(args):
# load and preprocess dataset
if args.dataset == 'cora':
data = CoraGraphDataset()
elif args.dataset == 'citeseer':
data = CiteseerGraphDataset()
elif args.dataset == 'pubmed':
data = PubmedGraphDataset()
else:
raise ValueError('Unknown dataset: {}'.format(args.dataset))
g = data[0]
if args.gpu < 0:
cuda = False
else:
cuda = True
g = g.int().to(args.gpu)
features = g.ndata['feat']
labels = g.ndata['label']
train_mask = g.ndata['train_mask']
val_mask = g.ndata['val_mask']
test_mask = g.ndata['test_mask']
in_feats = features.shape[1]
n_classes = data.num_labels
n_edges = data.graph.number_of_edges()
print("""----Data statistics------'
#Edges %d
#Classes %d
#Train samples %d
#Val samples %d
#Test samples %d""" %
(n_edges, n_classes,
train_mask.int().sum().item(),
val_mask.int().sum().item(),
test_mask.int().sum().item()))
# add self loop
if args.self_loop:
g = dgl.remove_self_loop(g)
g = dgl.add_self_loop(g)
n_edges = g.number_of_edges()
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
if cuda:
norm = norm.cuda()
g.ndata['norm'] = norm.unsqueeze(1)
# create GCN model
model = GCN(g,
in_feats,
args.n_hidden,
n_classes,
args.n_layers,
F.relu,
args.dropout)
if cuda:
model.cuda()
loss_fcn = torch.nn.CrossEntropyLoss()
# use optimizer
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
# initialize graph
dur = []
for epoch in range(args.n_epochs):
model.train()
if epoch >= 3:
t0 = time.time()
# forward
logits = model(features)
loss = loss_fcn(logits[train_mask], labels[train_mask])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch >= 3:
dur.append(time.time() - t0)
acc = evaluate(model, features, labels, val_mask)
print("Epoch {:05d} | Time(s) {:.4f} | Loss {:.4f} | Accuracy {:.4f} | "
"ETputs(KTEPS) {:.2f}". format(epoch, np.mean(dur), loss.item(),
acc, n_edges / np.mean(dur) / 1000))
print()
acc = evaluate(model, features, labels, test_mask)
print("Test accuracy {:.2%}".format(acc))
def main(args):
path = os.path.join(args.dataDir, args.dataset + ".npz")
data = custom_dataset(path, args.dim, args.classes, load_from_txt=False)
g = data.g
if args.gpu < 0:
cuda = False
else:
cuda = True
g = g.int().to(args.gpu)
features = data.x
labels = data.y
in_feats = features.size(1)
n_classes = data.num_classes
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm = norm.cuda()
g.ndata['norm'] = norm.unsqueeze(1)
if args.model == 'gcn':
model = GCN(g,
in_feats=in_feats,
n_hidden=args.hidden,
n_classes=n_classes,
n_layers=2)
else:
model = GIN(g,
input_dim=in_feats,
hidden_dim=64,
output_dim=n_classes,
num_layers=5)
if cuda: model.cuda()
loss_fcn = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),
lr=1e-2,
weight_decay=5e-4)
torch.cuda.synchronize()
start = time.perf_counter()
for _ in tqdm(range(args.n_epochs)):
model.train()
logits = model(features)
loss = loss_fcn(logits[:], labels[:])
optimizer.zero_grad()
loss.backward()
optimizer.step()
torch.cuda.synchronize()
dur = time.perf_counter() - start
if args.model == 'gcn':
print("DGL GCN (L2-H16) Time: (ms) {:.3f}".format(dur * 1e3 /
args.n_epochs))
else:
print("DGL GIN (L5-H64) Time: (ms) {:.3f}".format(dur * 1e3 /
args.n_epochs))
print()
def main(args):
# load and preprocess dataset
data = load_data(args)
features = torch.FloatTensor(data.features)
labels = torch.LongTensor(data.labels)
if hasattr(torch, "BoolTensor"):
train_mask = torch.BoolTensor(data.train_mask)
val_mask = torch.BoolTensor(data.val_mask)
test_mask = torch.BoolTensor(data.test_mask)
else:
train_mask = torch.ByteTensor(data.train_mask)
val_mask = torch.ByteTensor(data.val_mask)
test_mask = torch.ByteTensor(data.test_mask)
in_feats = features.shape[1]
n_classes = data.num_labels
n_edges = data.graph.number_of_edges()
print("""----Data statistics------'
#Edges %d
#Classes %d
#Train samples %d
#Val samples %d
#Test samples %d""" % (
n_edges,
n_classes,
train_mask.int().sum().item(),
val_mask.int().sum().item(),
test_mask.int().sum().item(),
))
if args.gpu < 0:
cuda = False
else:
cuda = True
torch.cuda.set_device(args.gpu)
features = features.cuda()
labels = labels.cuda()
train_mask = train_mask.cuda()
val_mask = val_mask.cuda()
test_mask = test_mask.cuda()
# graph preprocess and calculate normalization factor
g = data.graph
# add self loop
if args.self_loop:
g.remove_edges_from(nx.selfloop_edges(g))
g.add_edges_from(zip(g.nodes(), g.nodes()))
g = DGLGraph(g)
n_edges = g.number_of_edges()
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
if cuda:
norm = norm.cuda()
g.ndata["norm"] = norm.unsqueeze(1)
# create GCN model
model = GCN(
g,
in_feats,
args.n_hidden,
n_classes,
args.n_layers,
F.relu,
args.dropout,
)
if cuda:
model.cuda()
loss_fcn = torch.nn.CrossEntropyLoss()
# use optimizer
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
# initialize graph
dur = []
for epoch in range(args.n_epochs):
model.train()
if epoch >= 3:
t0 = time.time()
# forward
logits = model(features)
loss = loss_fcn(logits[train_mask], labels[train_mask])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch >= 3:
dur.append(time.time() - t0)
accuracy, precision, recall, fscore, _ = evaluate(
model, features, labels, val_mask)
print("Epoch:", epoch)
print("Loss:", loss.item())
print("Accuracy:", accuracy)
print("Precision:", precision)
print("Recall:", recall)
print("F-Score:", fscore)
print()
print("=" * 80)
print()
accuracy, precision, recall, fscore, class_based_report = evaluate(
model, features, labels, test_mask)
print("=" * 80)
print(" " * 28 + "Final Statistics")
print("=" * 80)
print("Accuracy", accuracy)
print("Precision", precision)
print("Recall", recall)
print("F-Score", fscore)
print(class_based_report)
def main(args):
# load and preprocess dataset
data = load_data(args)
#
structure_features = np.load('../../pretrained/' + args.dataset +
'_structure_8d.npy')
attr_features = np.load('../../pretrained/' + args.dataset +
'_attr_8d.npy')
structure_features = preprocessing.scale(structure_features,
axis=1,
with_mean=True,
with_std=True,
copy=True)
#structure_features = preprocessing.scale(structure_features, axis=0, with_mean=True,with_std=True,copy=True)
structure_features = torch.FloatTensor(structure_features).cuda()
attr_features = preprocessing.scale(attr_features,
axis=1,
with_mean=True,
with_std=True,
copy=True)
#attr_features = preprocessing.scale(attr_features, axis=0, with_mean=True,with_std=True,copy=True)
attr_features = torch.FloatTensor(attr_features).cuda()
in_feats2 = structure_features.shape[1]
in_feats3 = attr_features.shape[1]
print(structure_features.shape, attr_features.shape)
#data.features = preprocessing.scale(data.features, axis=1, with_mean=True,with_std=True,copy=True)
#data.features = preprocessing.scale(data.features, axis=0, with_mean=True,with_std=True,copy=True)
#
features = torch.FloatTensor(data.features)
labels = torch.LongTensor(data.labels)
train_mask = torch.ByteTensor(data.train_mask)
val_mask = torch.ByteTensor(data.val_mask)
test_mask = torch.ByteTensor(data.test_mask)
in_feats1 = features.shape[1]
n_classes = data.num_labels
n_edges = data.graph.number_of_edges()
print("""----Data statistics------'
#Edges %d
#Classes %d
#Train samples %d
#Val samples %d
#Test samples %d""" % (n_edges, n_classes, train_mask.sum().item(),
val_mask.sum().item(), test_mask.sum().item()))
if args.gpu < 0:
cuda = False
else:
cuda = True
torch.cuda.set_device(args.gpu)
features = features.cuda()
labels = labels.cuda()
train_mask = train_mask.cuda()
val_mask = val_mask.cuda()
test_mask = test_mask.cuda()
# graph preprocess and calculate normalization factor
g = data.graph
# add self loop
if args.self_loop:
g.remove_edges_from(g.selfloop_edges())
g.add_edges_from(zip(g.nodes(), g.nodes()))
g = DGLGraph(g)
n_edges = g.number_of_edges()
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
if cuda:
norm = norm.cuda()
g.ndata['norm'] = norm.unsqueeze(1)
# create GCN model
#alpha2_set = [0,0.001,0.002,0.004,0.006,0.008,0.01,0.02,0.03,0.04,0.05]
#alpha3_set = [0,0.001,0.002,0.004,0.006,0.008,0.01,0.02,0.03,0.04,0.05]
alpha2_set = [0.02]
alpha3_set = [0.03]
alpha1 = 1
for alpha2 in alpha2_set:
for alpha3 in alpha3_set:
result = []
for iter in range(30):
model = GCN(g, in_feats1, in_feats2, in_feats3, args.n_hidden,
n_classes, args.n_layers, F.relu, args.dropout,
alpha1, alpha2, alpha3)
if cuda:
model.cuda()
loss_fcn = torch.nn.CrossEntropyLoss()
# use optimizer
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
# initialize graph
dur = []
best_val_acc = 0
best_test_acc = 0
for epoch in range(args.n_epochs):
model.train()
if epoch >= 3:
t0 = time.time()
# forward
logits = model(features, structure_features, attr_features)
loss = loss_fcn(logits[train_mask], labels[train_mask])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch >= 3:
dur.append(time.time() - t0)
val_acc = evaluate(model, features, structure_features,
attr_features, labels, val_mask)
if val_acc >= best_val_acc:
best_val_acc = val_acc
best_test_acc = evaluate(model, features,
structure_features,
attr_features, labels,
test_mask)
#print("Epoch {:05d} | Time(s) {:.4f} | Loss {:.4f} | Accuracy {:.4f} | "
# "ETputs(KTEPS) {:.2f}". format(epoch, np.mean(dur), loss.item(),
# acc, n_edges / np.mean(dur) / 1000))
#print()
#acc = evaluate(model, features,dw_features, labels, test_mask)
#print("Test Accuracy {:.4f}".format(acc))
result.append(best_test_acc)
del model
#print(best_test_acc)
print(alpha2, alpha3, np.average(result), result)
def main(args):
# load and preprocess dataset
if args.gpu > 0:
cuda = True
device = torch.device('cuda:{}'.format(args.gpu))
else:
device = torch.device('cpu')
cuda = False
cora_data = NeptuneCoraDataset(device, valid_ratio=0.1, test_ratio=0.2)
#cora_data = CoraDataset(device, valid_ratio=0.1, test_ratio=0.2)
features = cora_data.features
test_set = cora_data.test_set
valid_set = cora_data.valid_set
train_set = cora_data.train_set
g = cora_data.g
in_feats = features['h**o'].shape[1]
n_edges = g.number_of_edges()
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
if cuda:
norm = norm.cuda()
g.ndata['norm'] = norm.unsqueeze(1)
# create GCN model
model = GCN(g, in_feats, args.n_hidden, cora_data.n_class, args.n_layers,
F.relu, args.dropout)
if cuda:
model.cuda()
loss_fcn = torch.nn.CrossEntropyLoss()
# use optimizer
optimizer = torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
# initialize graph
dur = []
for epoch in range(args.n_epochs):
model.train()
if epoch >= 3:
t0 = time.time()
# forward
logits = model(features['h**o'])
loss = loss_fcn(logits[train_set[0]], train_set[1])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch >= 3:
dur.append(time.time() - t0)
acc = evaluate(model, features['h**o'], valid_set)
print(
"Epoch {:05d} | Time(s) {:.4f} | Loss {:.4f} | Accuracy {:.4f} | "
"ETputs(KTEPS) {:.2f}".format(epoch, np.mean(dur), loss.item(),
acc, n_edges / np.mean(dur) / 1000))
print()
acc = evaluate(model, features['h**o'], test_set)
print("Test accuracy {:.2%}".format(acc))
torch.save(model.state_dict(), args.model_path)
g,
num_feats,
param['hidden_size'],
n_classes,
param['layers'],
F.elu,
param['dropout'],
param['bias'],
param['num_heads'],
)
loss_fcn = torch.nn.BCEWithLogitsLoss()
# use optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=0.005)
model.cuda()
loss_result_list = []
for epoch in range(200):
model.train()
loss_list = []
for train_batch in batch_list:
logits = model(features.float())
loss = loss_fcn(logits[train_batch],
labels[train_batch].float())
optimizer.zero_grad()
loss.backward()
optimizer.step()
loss_list.append(loss.item())
print("Epoch {:05d} | Loss: {:.4f}".format(
epoch + 1,
np.array(loss_list).mean()))
