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()))