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 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(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 main(args):
data = load_data(args)
features = torch.FloatTensor(data.features)
labels = torch.FloatTensor(data.labels)
train_mask = torch.BoolTensor(data.train_mask)
val_mask = torch.BoolTensor(data.val_mask)
test_mask = torch.BoolTensor(data.test_mask)
g = data.graph
n_feats = features.shape[1]
n_labels = data.num_labels
n_edges = g.number_of_edges()
print("""----Data statistics------'
#Features %d
#Edges %d
#Labels %d
#Train samples %d
#Val samples %d
#Test samples %d""" %
(n_feats, n_edges, n_labels, train_mask.int().sum().item(),
val_mask.int().sum().item(), test_mask.int().sum().item()))
dataset_train = CampusDataset(features, labels)
dict_users = iid_users(dataset_train, args.n_users)
if args.gnnbase == 'gcn':
g = DGLGraph(g)
n_edges = g.number_of_edges()
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
g.ndata['norm'] = norm.unsqueeze(1)
model = GCN(g, n_feats, args.n_hidden, n_labels, args.n_layers, F.relu,
args.dropout)
if args.gnnbase == 'gat':
g.remove_edges_from(nx.selfloop_edges(g))
g = DGLGraph(g)
g.add_edges(g.nodes(), g.nodes())
n_edges = g.number_of_edges()
heads = ([args.n_heads] * args.n_layers) + [args.n_out_heads]
model = GAT(g, args.n_layers, n_feats, args.n_hidden, n_labels, heads,
F.elu, args.in_drop, args.attn_drop, args.negative_slope,
args.residual)
if args.gnnbase == 'sage':
g.remove_edges_from(nx.selfloop_edges(g))
g = DGLGraph(g)
n_edges = g.number_of_edges()
model = GraphSAGE(g, n_feats, args.n_hidden, n_labels, args.n_layers,
F.relu, args.dropout, args.aggregator_type)
print(model)
model.train()
w_glob = model.state_dict()
loss_train = []
timecost = []
for epoch in range(args.n_epochs):
time_begin = time.time()
w_locals, loss_locals = [], []
m = max(int(args.frac * args.n_users), 1)
idxs_users = np.random.choice(range(args.n_users), m, replace=False)
for idx in idxs_users:
local = LocalUpdate(args=args,
dataset=dataset_train,
idxs=dict_users[idx],
mask=train_mask)
w, loss = local.train(model=copy.deepcopy(model))
w_locals.append(copy.deepcopy(w))
loss_locals.append(copy.deepcopy(loss))
w_glob = FedAvg(w_locals)
model.load_state_dict(w_glob)
time_end = time.time()
timecost.append(time_end - time_begin)
loss_avg = sum(loss_locals) / len(loss_locals)
print('Epoch {:3d}, Average loss {:.3f}'.format(epoch, loss_avg))
loss_train.append(loss_avg)
train_errX, train_errY = eval_error(model, features, labels,
train_mask)
val_errX, val_errY = eval_error(model, features, labels, val_mask)
test_errX, test_errY = eval_error(model, features, labels, test_mask)
print(
"Epoch {:3d} | TrainRMSEX {:.4f} | TrainRMSEY {:.4f} | ValRMSEX {:.4f} | ValRMSEY {:.4f} | TestRMSEX {:.4f} | TestRMSEY {:.4f}"
.format(epoch, train_errX, train_errY, val_errX, val_errY,
test_errX, test_errY))
print("Time cost {:.4f}".format(sum(timecost) / args.n_epochs))
base_errX, base_errY = calc_error(features[test_mask, :2],
labels[test_mask])
print("TestRMSEX-Base {:.4f} | TestRMSEY-Base {:.4f}".format(
base_errX, base_errY))
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model_path = 'Results/model_exp2.pth'
num_classes = 80
train_path = '/home/user/Data/coco2014/train2014'
train_ann_file = '/home/user/Data/coco2014/annotations/instances_train2014.json'
val_path = '/home/user/Data/coco2014/val2014'
val_ann_file = '/home/user/Data/coco2014/annotations/instances_val2014.json'
train_pickle_file = 'train.pickle'
val_pickle_file = 'val.pickle'
adj = pickle.load(open('adj.pickle', 'rb'))
adj = np.float32(adj / np.max(adj) + np.identity(num_classes))
adj_tensor = torch.from_numpy(adj)
model = GCN(adj_tensor, num_classes, 80, num_classes)
model.load_state_dict(torch.load(model_path))
train_dataset = CocoDataset(train_path, train_ann_file, num_classes)
val_dataset = CocoDataset(val_path, val_ann_file, num_classes)
train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True, num_workers=1)
val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False, num_workers=1)
train_detections = pickle.load(open(train_pickle_file, 'rb'))
val_detections = pickle.load(open(val_pickle_file, 'rb'))
total_train_images = len(train_loader)
total_val_images = len(val_loader)
model.eval()
print('Running...')
