def preprocessing(data, emb_file, seed, trans):
num_graphs = len(data[0])
nx_graphs = [data[0][i].g for i in range(num_graphs)]
dgl_graphs = [dgl.from_networkx(graph) for graph in nx_graphs]
batch_graphs = dgl.batch(dgl_graphs)
num_nodes = len(batch_graphs.nodes())
graph_size = [len(g.nodes()) for g in nx_graphs]
emb = np.loadtxt(emb_file)
if trans:
emb = np.dot(emb,DCT(num_nodes).T)
G = batch_graphs.to_networkx()
Sub = {}
for i in range(num_graphs):
if i == 0:
node_start = 0
else:
node_start = sum(graph_size[:i-1])
node_end = sum(graph_size[:i])
nbunch = [node for node in range(node_start, node_end)]
subgraph = nx.subgraph(G, nbunch)
Sub[data[0][i]] = np.dot(emb, encode(G,subgraph))
idx_list = separate_data(data[0],seed = seed)
return Sub, idx_list, data[0]
def prepare_data_order(args):
graphs, num_classes, max_deg = load_data_order(args.dataset, args.degree_as_tag)
if USE_SAVE_IDX:
try:
train_idx = np.loadtxt('./dataset/%s/10fold_idx/train_idx-%d.txt' % (args.dataset, args.fold_idx+1), dtype=np.int32).tolist()
test_idx = np.loadtxt('./dataset/%s/10fold_idx/test_idx-%d.txt' % (args.dataset, args.fold_idx+1), dtype=np.int32).tolist()
train_graphs, test_graphs = [graphs[i] for i in train_idx], [graphs[i] for i in test_idx]
except:
print("Could not load dataset indicies")
if num_classes >= len(graphs) or args.dont_split:
train_graphs, test_graphs, train_idx, test_idx = graphs, [], 0, 0
else:
train_graphs, test_graphs, train_idx, test_idx = separate_data(graphs, args.seed, args.fold_idx)
else:
if num_classes >= len(graphs) or args.dont_split:
train_graphs, test_graphs, train_idx, test_idx = graphs, [], 0, 0
else:
train_graphs, test_graphs, train_idx, test_idx = separate_data(graphs, args.seed, args.fold_idx)
return train_graphs, test_graphs, train_idx, test_idx, num_classes, max_deg
def main():
# Training settings
# Note: Hyper-parameters need to be tuned in order to obtain results reported in the paper.
parser = argparse.ArgumentParser(description='PyTorch GIN fMRI')
parser.add_argument('--device',
type=int,
default=0,
help='which gpu to use if any')
parser.add_argument('--sourcedir',
type=str,
default='data',
help='path to the data directory')
parser.add_argument('--sparsity',
type=int,
default=30,
help='sparsity M of graph adjacency')
parser.add_argument('--input_feature',
type=str,
default='one_hot',
help='input feature type',
choices=['one_hot', 'coordinate', 'mean_bold'])
parser.add_argument('--batch_size',
type=int,
default=32,
help='input minibatch size for training')
parser.add_argument('--iters_per_epoch',
type=int,
default=50,
help='number of iterations per each epoch')
parser.add_argument('--epochs',
type=int,
default=150,
help='number of epochs to train')
parser.add_argument('--lr',
type=float,
default=0.005,
help='initial learning rate')
parser.add_argument('--lr_step',
type=int,
default=5,
help='learning rate decay step')
parser.add_argument('--lr_rate',
type=float,
default=0.8,
help='learning rate decay rate')
parser.add_argument('--fold_seed',
type=int,
default=0,
help='random seed for splitting the dataset')
parser.add_argument('--fold_idx',
type=int,
default=0,
help='indices of fold in 10-fold validation.')
parser.add_argument('--num_layers',
type=int,
default=5,
help='number of the GNN layers')
parser.add_argument(
'--num_mlp_layers',
type=int,
default=2,
help='number of layers for the MLP. 1 means linear model.')
parser.add_argument('--hidden_dim',
type=int,
default=64,
help='number of hidden units')
parser.add_argument('--beta',
type=float,
default=0.05,
help='coefficient for infograph regularizer')
parser.add_argument('--final_dropout',
type=float,
default=0.5,
help='final layer dropout')
parser.add_argument(
'--graph_pooling_type',
type=str,
default="sum",
choices=["sum", "average"],
help='Pooling for over nodes in a graph: sum or average')
parser.add_argument(
'--neighbor_pooling_type',
type=str,
default="sum",
choices=["sum", "average", "max"],
help='Pooling for over neighboring nodes: sum, average or max')
parser.add_argument(
'--learn_eps',
action="store_true",
help=
'whether to learn the epsilon weighting for the center nodes. Does not affect training accuracy though.'
)
parser.add_argument('--exp',
type=str,
default="graph_neural_mapping",
help='experiment name')
args = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
graphs, num_classes = load_data(args.sourcedir, args.sparsity,
args.input_feature)
os.makedirs('results/{}/saliency/{}'.format(args.exp, args.fold_idx),
exist_ok=True)
os.makedirs('results/{}/latent/{}'.format(args.exp, args.fold_idx),
exist_ok=True)
os.makedirs('results/{}/model/{}'.format(args.exp, args.fold_idx),
exist_ok=True)
train_graphs, test_graphs = separate_data(graphs, args.fold_seed,
args.fold_idx)
model = GIN_InfoMaxReg(args.num_layers, args.num_mlp_layers,
train_graphs[0].node_features.shape[1],
args.hidden_dim, num_classes, args.final_dropout,
args.learn_eps, args.graph_pooling_type,
args.neighbor_pooling_type, device).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = optim.lr_scheduler.StepLR(optimizer,
step_size=args.lr_step,
gamma=args.lr_rate)
train_summary_writer = SummaryWriter('results/{}/summary/{}/train'.format(
args.exp, args.fold_idx),
flush_secs=1,
max_queue=1)
test_summary_writer = SummaryWriter('results/{}/summary/{}/test'.format(
args.exp, args.fold_idx),
flush_secs=1,
max_queue=1)
with open('results/{}/argv.csv'.format(args.exp), 'a', newline='') as f:
writer = csv.writer(f)
writer.writerows(vars(args).items())
latent_space_initial, labels = get_latent_space(model, test_graphs)
np.save(
'results/{}/latent/{}/latent_space_initial.npy'.format(
args.exp, args.fold_idx), latent_space_initial)
np.save('results/{}/latent/{}/labels.npy'.format(args.exp, args.fold_idx),
labels)
del latent_space_initial
del labels
for epoch in tqdm(range(args.epochs), ncols=50, desc=f'{args.fold_idx}'):
loss_train = train(args, model, device, train_graphs, optimizer,
args.beta, epoch)
scheduler.step()
acc_train, precision_train, recall_train = test(
args, model, device, train_graphs)
train_summary_writer.add_scalar('loss/total', loss_train, epoch)
train_summary_writer.add_scalar('metrics/accuracy', acc_train, epoch)
train_summary_writer.add_scalar('metrics/precision', precision_train,
epoch)
train_summary_writer.add_scalar('metrics/recall', recall_train, epoch)
acc_test, precision_test, recall_test = test(args, model, device,
test_graphs)
test_summary_writer.add_scalar('metrics/accuracy', acc_test, epoch)
test_summary_writer.add_scalar('metrics/precision', precision_test, epoch)
test_summary_writer.add_scalar('metrics/recall', recall_test, epoch)
torch.save(model.state_dict(),
'results/{}/model/{}/model.pt'.format(args.exp, args.fold_idx))
latent_space, labels = get_latent_space(model, test_graphs)
saliency_map_0 = get_saliency_map(model, test_graphs, 0)
saliency_map_1 = get_saliency_map(model, test_graphs, 1)
np.save(
'results/{}/latent/{}/latent_space.npy'.format(args.exp,
args.fold_idx),
latent_space)
np.save(
'results/{}/saliency/{}/saliency_female.npy'.format(
args.exp, args.fold_idx), saliency_map_0)
np.save(
'results/{}/saliency/{}/saliency_male.npy'.format(
args.exp, args.fold_idx), saliency_map_1)
def main():
# Training settings
# Note: Hyper-parameters need to be tuned in order to obtain results reported in the paper.
parser = argparse.ArgumentParser(
description=
'PyTorch graph convolutional neural net for whole-graph classification'
)
parser.add_argument('--dataset',
type=str,
default="NCI1",
help='name of dataset (default: MUTAG)')
parser.add_argument('--device',
type=int,
default=0,
help='which gpu to use if any (default: 0)')
parser.add_argument('--batch_size',
type=int,
default=32,
help='input batch size for training (default: 32)')
parser.add_argument(
'--iters_per_epoch',
type=int,
default=50,
help='number of iterations per each epoch (default: 50)')
parser.add_argument(
'--epochs',
type=int,
default=500, #defeat
help='number of epochs to train (default: 350)')
parser.add_argument('--lr',
type=float,
default=0.01,
help='learning rate (default: 0.01)')
parser.add_argument('--wl2',
type=float,
default=0.0,
help='learning rate (default: 0.0)')
parser.add_argument(
'--seed',
type=int,
default=0,
help='random seed for splitting the dataset into 10 (default: 0)')
parser.add_argument(
'--fold_idx',
type=int,
default=0,
help='the index of fold in 10-fold validation. Should be less then 10.'
)
parser.add_argument(
'--num_layers',
type=int,
default=6,
help='number of layers INCLUDING the input one (default: 5)')
parser.add_argument(
'--num_mlp_layers',
type=int,
default=2,
help=
'number of layers for MLP EXCLUDING the input one (default: 2). 1 means linear model.'
)
parser.add_argument('--hidden_dim',
type=int,
default=64,
help='number of hidden units (default: 64)')
parser.add_argument('--final_dropout',
type=float,
default=0.5,
help='final layer dropout (default: 0.5)')
parser.add_argument(
'--graph_pooling_type',
type=str,
default="sum",
choices=["sum", "average"],
help='Pooling for over nodes in a graph: sum or average')
parser.add_argument(
'--neighbor_pooling_type',
type=str,
default="sum",
choices=["sum", "average", "max"],
help='Pooling for over neighboring nodes: sum, average or max')
parser.add_argument(
'--learn_eps',
action="store_true",
help=
'Whether to learn the epsilon weighting for the center nodes. Does not affect training accuracy though.'
)
parser.add_argument(
'--degree_as_tag',
action="store_true",
help=
'let the input node features be the degree of nodes (heuristics for unlabeled graph)'
)
parser.add_argument('--filename',
type=str,
default="meta-guass-pow10",
help='output file')
parser.add_argument(
'--attention',
type=bool,
default=True, #defeault false
help='if attention,defeaut:False')
parser.add_argument('--tqdm', type=bool, default=False, help='if use tqdm')
parser.add_argument(
'--multi_head',
type=int,
default=1, # defeat:3
help='if use tqdm')
parser.add_argument(
'--sum_flag',
type=int,
default=1, #defeatut :1
help='if 0: don;t sum')
parser.add_argument(
'--inter',
type=int,
default=1, #defeult :0
help='if 0: not do unteraction in attention')
parser.add_argument(
'--dire_sigmod',
type=int,
default=0, # defeult :0
help='if 0: do softmax in dire attention,else if 1: sigmod')
parser.add_argument(
'--attention_type',
type=str,
default="mlp-sigmod",
help='attention type:dire(sum or not), mlp-softmax , mlp-sigmod')
args = parser.parse_args()
ISOTIMEFORMAT = '%Y-%m-%d-%H-%M'
theTime = datetime.datetime.now().strftime(ISOTIMEFORMAT)
save_fold_path = "result/save_model/" + args.filename + str(
args.num_layers) + str(theTime) # result save path
writer_path = str(theTime) + args.filename + 'TBX'
writer = SummaryWriter(log_dir=writer_path)
#set up seeds and gpu device
print("lr:", args.lr)
print("attention: ", args.attention)
print("attention_type:", args.attention_type)
print("sum_flag:", args.sum_flag)
print("inter:", args.inter)
print("filename:", args.filename)
if args.attention == True: # if do attention we need sum graph pool information
args.graph_pooling_type = 'sum'
print("data sets:", args.dataset)
print("degree as tag:", args.degree_as_tag)
print("flod_idx:", args.fold_idx)
if args.sum_flag == 1:
print(
"if use directly attention is sum attention ,besides use sigmod attention model"
)
f = open(args.filename + "_train", 'w')
if args.fold_idx == -1:
acc = []
for idx in range(10):
acc_i = cross_val(args, writer, idx, f)
acc.append(acc_i)
writer.close()
np.save("result/" + args.filename + "_all.numpy",
np.array(acc)) # save
else:
torch.manual_seed(0)
np.random.seed(0)
device = torch.device("cuda:" +
str(args.device)) if torch.cuda.is_available(
) else torch.device("cpu")
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
graphs, num_classes = load_data(args.dataset, args.degree_as_tag)
##10-fold cross validation. Conduct an experiment on the fold specified by args.fold_idx.
train_graphs, test_graphs = separate_data(graphs, args.seed,
args.fold_idx)
model = GraphCNN(args.num_layers,
args.num_mlp_layers,
train_graphs[0].node_features.shape[1],
args.hidden_dim,
num_classes,
args.final_dropout,
args.learn_eps,
args.graph_pooling_type,
args.neighbor_pooling_type,
device,
attention=args.attention,
multi_head=args.multi_head,
sum_flag=args.sum_flag,
inter=args.inter,
attention_type=args.attention_type,
dire_sigmod=args.dire_sigmod).to(device)
optimizer = optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.wl2)
scheduler = optim.lr_scheduler.StepLR(optimizer,
step_size=50,
gamma=0.5)
#args.epoch = 1
acc = []
max_acc = 0
for epoch in range(1, args.epochs + 1): #args.epochs
scheduler.step()
avg_loss = train(args, model, device, train_graphs, optimizer,
epoch)
acc_train, acc_test = ftest(args, model, device, train_graphs,
test_graphs, epoch)
max_acc = max(acc_test, max_acc)
writer.add_scalars(
str(args.fold_idx) + '/scalar/acc', {
'train': acc_train,
'val': acc_test
}, epoch)
acc.append(acc_test)
f.write("%f %f %f" % (avg_loss, acc_train, acc_test))
f.write("\n")
print("")
if epoch % 50 == 0:
torch.save(model.state_dict(),
save_fold_path + "_" + str(epoch) + ".pt")
print("****************max acc:", max_acc)
try:
torch.save(model.state_dict(), save_fold_path + "_last.pt")
np.save(
"result/" + args.filename + "_" + str(args.fold_idx) +
"_val_acc.npy", np.array(acc))
writer.close()
except:
print("acc all:", acc)
pass
#print(model.eps)
f.close()
def cross_val(args, writer, idx, f):
fold_idx = idx
print(
"**********************fold:{}**************************************************"
.format(fold_idx))
torch.manual_seed(0)
np.random.seed(0)
device = torch.device(
"cuda:" +
str(args.device)) if torch.cuda.is_available() else torch.device("cpu")
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
graphs, num_classes = load_data(args.dataset, args.degree_as_tag)
##10-fold cross validation. Conduct an experiment on the fold specified by args.fold_idx.
train_graphs, test_graphs = separate_data(graphs, args.seed, fold_idx)
model = GraphCNN(args.num_layers,
args.num_mlp_layers,
train_graphs[0].node_features.shape[1],
args.hidden_dim,
num_classes,
args.final_dropout,
args.learn_eps,
args.graph_pooling_type,
args.neighbor_pooling_type,
device,
attention=args.attention,
multi_head=args.multi_head,
sum_flag=args.sum_flag,
inter=args.inter,
attention_type=args.attention_type,
dire_sigmod=args.dire_sigmod).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5)
f.write("************************************** %d *********" % fold_idx)
max_acc = 0
acc = []
for epoch in range(1, args.epochs + 1):
scheduler.step()
avg_loss = train(args, model, device, train_graphs, optimizer, epoch)
acc_train, acc_test = test(args, model, device, train_graphs,
test_graphs, epoch)
writer.add_scalars('/scalar/acc' + str(fold_idx), {
'train': acc_train,
'val': acc_test
}, epoch)
acc.append(acc_test)
if acc_test > max_acc:
max_acc = acc_test
f.write("%f %f %f" % (avg_loss, acc_train, acc_test))
f.write("\n")
print("")
print("acc:", acc)
try:
f.write(
"**************************************kkk flod_id:{},best:{} *********"
.format(fold_idx, max_acc))
np.save(
"result/" + args.filename + "_" + str(fold_idx) + "_val_acc.npy",
np.array(acc))
print(
"************************************** flod_id:{},best:{} *********"
.format(fold_idx, max_acc))
except:
pass
return acc
data_dir = '../../data'
cleaned_file = 'trauma_los_cleaned.csv'
extract_file = 'trauma_los_cleaned_extract.csv'
desired_headings = [
'sex', 'normalvitals', 'gcs1', 'iss8', 'age65', 'transfer', 'penetrating',
'mechcode', 'bodyregions', 'headany', 'faceany', 'neckany', 'chestany',
'abdoany', 'spineany', 'upperlimbany', 'lowerlimbany', 'head3', 'face3',
'neck3', 'chest3', 'abdo3', 'spine3', 'upper3', 'lower3', 'operation',
'neurosurgery', 'laparotomy', 'thoracotomy', 'married', 'english',
'mentalhealth', 'comorbidity', 'ssa'
]
# trim the input file into only the features we want to use
extract_features(data_dir, cleaned_file, extract_file, desired_headings)
X, y, headings = separate_data(True, data_dir, extract_file)
# convert all strings to ints
X, y = map(lambda x: list(map(int, x)), X), map(int, y)
X, y = np.array(list(X)), np.array(list(y))
n_samples, n_features = X.shape
# create a stratified 10-fold cross-validation iterator that generates the
# indices for us
cv = StratifiedKFold(y=y, n_folds=10, shuffle=True)
# create a support vector machine classifier
clf_svm = svm.SVC(kernel='linear', probability=True)
# create a Gaussian naive Bayes classifier
clf_gauss_nb = GaussianNB()
def main():
# Training settings
parser = argparse.ArgumentParser(description='WL subtree kernel')
parser.add_argument('--dataset',
type=str,
default="MUTAG",
help='name of dataset (default: MUTAG)')
parser.add_argument(
'--seed',
type=int,
default=0,
help='random seed for splitting the dataset into 10 (default: 0)')
parser.add_argument(
'--fold_idx',
type=int,
default=0,
help='the index of fold in 10-fold validation. Should be less then 10.'
)
parser.add_argument('--iter',
type=int,
default=5,
help='Number of iteration for the WL')
parser.add_argument('--normalize',
action="store_true",
help='normalize the feature or not')
parser.add_argument('--filename', type=str, default="", help='output file')
args = parser.parse_args()
np.random.seed(0)
graphs, num_classes = load_data(args.dataset, False)
##10-fold cross validation, consider the particular fold.
train_graphs, test_graphs = separate_data(graphs, args.seed, args.fold_idx)
#SVM hyper-parameter to tune
C_list = [0.01, 0.1, 1, 10, 100]
X_train, y_train = convert(train_graphs)
X_test, y_test = convert(test_graphs)
wl_kernel = GraphKernel(kernel=[{
"name": "weisfeiler_lehman",
"niter": args.iter
}, {
"name": "subtree_wl"
}],
normalize=args.normalize)
K_train = wl_kernel.fit_transform(X_train)
K_test = wl_kernel.transform(X_test)
train_acc = []
test_acc = []
for C in C_list:
clf = SVC(kernel='precomputed', C=C)
clf.fit(K_train, y_train)
y_pred_test = clf.predict(K_test)
y_pred_train = clf.predict(K_train)
train_acc.append(accuracy_score(y_train, y_pred_train) * 100)
test_acc.append(accuracy_score(y_test, y_pred_test) * 100)
print(train_acc)
print(test_acc)
if not args.filename == "":
np.savetxt(args.filename, np.array([train_acc, test_acc]).transpose())
def main():
# Training settings
# Note: Hyper-parameters need to be tuned in order to obtain results reported in the paper.
parser = argparse.ArgumentParser(description='PyTorch graph convolutional neural net for whole-graph classification')
parser.add_argument('--dataset', type=str, default="MUTAG",
help='name of dataset (default: MUTAG)')
parser.add_argument('--device', type=int, default=0,
help='which gpu to use if any (default: 0)')
parser.add_argument('--batch_size', type=int, default=32,
help='input batch size for training (default: 32)')
parser.add_argument('--iters_per_epoch', type=int, default=50,
help='number of iterations per each epoch (default: 50)')
parser.add_argument('--epochs', type=int, default=350,
help='number of epochs to train (default: 350)')
parser.add_argument('--lr', type=float, default=0.01,
help='learning rate (default: 0.01)')
parser.add_argument('--seed', type=int, default=0,
help='random seed for splitting the dataset into 10 (default: 0)')
parser.add_argument('--fold_idx', type=int, default=0,
help='the index of fold in 10-fold validation. Should be less then 10.')
parser.add_argument('--num_layers', type=int, default=5,
help='number of layers INCLUDING the input one (default: 5)')
parser.add_argument('--num_mlp_layers', type=int, default=2,
help='number of layers for MLP EXCLUDING the input one (default: 2). 1 means linear model.')
parser.add_argument('--hidden_dim', type=int, default=64,
help='number of hidden units (default: 64)')
parser.add_argument('--final_dropout', type=float, default=0.5,
help='final layer dropout (default: 0.5)')
parser.add_argument('--graph_pooling_type', type=str, default="sum", choices=["sum", "average"],
help='Pooling for over nodes in a graph: sum or average')
parser.add_argument('--neighbor_pooling_type', type=str, default="sum", choices=["sum", "average", "max"],
help='Pooling for over neighboring nodes: sum, average or max')
parser.add_argument('--opt', type=str, default="adam", choices=["adam", "sgd"])
parser.add_argument('--learn_eps', action="store_true",
help='Whether to learn the epsilon weighting for the center nodes. Does not affect training accuracy though.')
parser.add_argument('--degree_as_tag', action="store_true",
help='let the input node features be the degree of nodes (heuristics for unlabeled graph)')
parser.add_argument('--filename', type = str, default = "",
help='output file')
parser.add_argument('--random', type=int, default=None,
help='the range of random features (default: None). None means it does not add random features.')
args = parser.parse_args()
#set up seeds and gpu device
torch.manual_seed(0)
np.random.seed(0)
device = torch.device("cuda:" + str(args.device)) if torch.cuda.is_available() else torch.device("cpu")
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
if args.dataset in ['TRIANGLE', 'TRIANGLE_EX', 'LCC', 'LCC_EX', 'MDS', 'MDS_EX']:
node_classification = True
train_graphs, _ = load_data(f'dataset/{args.dataset}/{args.dataset}_train.txt', args.degree_as_tag)
test_graphs, _ = load_data(f'dataset/{args.dataset}/{args.dataset}_test.txt', args.degree_as_tag)
for g in train_graphs + test_graphs:
if args.random:
g.node_features = torch.ones(g.node_features.shape[0], 0)
else:
g.node_features = torch.ones(g.node_features.shape[0], 1)
if args.dataset in ['TRIANGLE', 'TRIANGLE_EX', 'MDS', 'MDS_EX']:
num_classes = 2
elif args.dataset in ['LCC', 'LCC_EX']:
num_classes = 3
else:
assert(False)
if args.dataset in ['MDS', 'MDS_EX']:
get_labels = lambda batch_graph, model: torch.LongTensor(MDS_LOCAL(model, batch_graph))
criterion = nn.CrossEntropyLoss()
else:
get_labels = lambda batch_graph, model: torch.LongTensor(sum([graph.node_tags for graph in batch_graph], []))
bc = [0 for i in range(num_classes)]
for G in train_graphs:
for t in G.node_tags:
bc[t] += 1
w = torch.FloatTensor([max(bc) / bc[i] for i in range(num_classes)]).to(device)
criterion = nn.CrossEntropyLoss(weight=w)
else:
node_classification = False
graphs, num_classes = load_data(f'dataset/{args.dataset}/{args.dataset}.txt', args.degree_as_tag)
##10-fold cross validation. Conduct an experiment on the fold specified by args.fold_idx.
train_graphs, test_graphs = separate_data(graphs, args.seed, args.fold_idx)
criterion = nn.CrossEntropyLoss()
get_labels = lambda batch_graph, model: torch.LongTensor([graph.label for graph in batch_graph])
model = GraphCNN(args.num_layers, args.num_mlp_layers, train_graphs[0].node_features.shape[1], args.hidden_dim, num_classes, args.final_dropout, args.learn_eps, args.graph_pooling_type, args.neighbor_pooling_type, args.random, node_classification, device).to(device)
if args.opt == 'adam':
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5)
elif args.opt == 'sgd':
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0.9)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.epochs, gamma=0.5)
for epoch in range(1, args.epochs + 1):
scheduler.step()
avg_loss = train(args, model, device, train_graphs, optimizer, criterion, get_labels, epoch)
acc_train, acc_test = test(args, model, device, train_graphs, test_graphs, num_classes, get_labels, epoch)
if not args.filename == "":
with open(args.filename, 'w') as f:
f.write("%f %f %f" % (avg_loss, acc_train, acc_test))
f.write("\n")
print("")
print(model.eps)
def main():
# Training settings
# Note: Check experiment scripts for hyperparameters
parser = argparse.ArgumentParser(description='PyTorch graph convolutional\
neural net for whole-graph \
classification')
parser.add_argument('--dataset',
type=str,
default="MUTAG",
help='name of dataset (default: MUTAG)')
parser.add_argument('--device',
type=str,
default="0",
help='which gpu to use if any (default: 0)')
parser.add_argument('--batch_size',
type=int,
default=32,
help='input batch size for training (default: 32)')
parser.add_argument(
'--iters_per_epoch',
type=int,
default=50,
help='number of iterations per each epoch (default: 50)')
parser.add_argument('--epochs',
type=int,
default=350,
help='number of epochs to train (default: 350)')
parser.add_argument('--lr',
type=float,
default=0.01,
help='learning rate (default: 0.01)')
parser.add_argument('--seed',
type=int,
default=0,
help='random seed for splitting the dataset into 10\
(default: 0)')
parser.add_argument('--fold_idx',
type=int,
default=0,
help='the index of fold in 10-fold validation. \
Should be less then 10.')
parser.add_argument('--num_layers',
type=int,
default=5,
help='number of layers INCLUDING the input one \
(default: 5)')
parser.add_argument(
'--num_mlp_layers',
type=int,
default=2,
help='number of layers for MLP EXCLUDING the input one \
(default: 2). 1 means linear model.')
parser.add_argument('--hidden_dim',
type=int,
default=64,
help='number of hidden units (default: 64)')
parser.add_argument('--final_dropout',
type=float,
default=0.5,
help='final layer dropout (default: 0.5)')
parser.add_argument(
'--graph_pooling_type',
type=str,
default="sum",
choices=["sum", "average"],
help='Pooling for over nodes in a graph: sum or average')
parser.add_argument('--neighbor_pooling_type',
type=str,
default="sum",
choices=["sum", "average", "max"],
help='Pooling for over neighboring nodes: sum, average\
or max')
parser.add_argument('--learn_eps',
action="store_true",
help='Whether to learn the epsilon \
weighting for the center nodes.')
parser.add_argument('--degree_as_tag',
action="store_true",
help='let the input node features be the degree of \
nodes (heuristics for unlabeled graph)')
parser.add_argument('--filename', type=str, default="", help='output file')
parser.add_argument('--bn',
type=bool,
default=True,
help="Enable batchnorm\
for MLP")
parser.add_argument('--gbn',
type=bool,
default=True,
help="Enable \
batchnorm for graph")
parser.add_argument('--corrupt_label',
action="store_true",
help="Enable label corruption")
parser.add_argument('--N',
type=str,
default="",
help="Label noise configuration N. \
Should be passed as a flattened\
string with row order or a single\
value for symmetrix noise config.")
parser.add_argument('--denoise',
type=str,
default="",
choices=["estimate", "anchors", "exact"],
help="Method to recover the noise matrix C.")
parser.add_argument('--correction',
type=str,
default="backward",
choices=["backward", "forward", "compound"],
help="Type of loss correction function.")
parser.add_argument('--anchors',
type=str,
default="",
help="List of representative train data.")
parser.add_argument('--est_mode',
default="max",
choices=["max", "min"],
help="Type of estimator for C")
parser.add_argument('--skip_new',
action="store_true",
help="Train new model for estimating noise")
args = parser.parse_args()
#set up seeds and gpu device
torch.manual_seed(0)
np.random.seed(0)
if args.device != "cpu":
device = torch.device("cuda:" + args.device)\
if torch.cuda.is_available() else torch.device("cpu")
else:
device = torch.device("cpu")
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
graphs, num_classes = load_data(args.dataset, args.degree_as_tag)
##10-fold cross validation. Conduct an experiment on the fold specified by args.fold_idx.
train_graphs, test_graphs = separate_data(graphs, args.seed, args.fold_idx)
# Corrupt data
if args.corrupt_label:
assert len(args.N) != 0, "Need to pass noise matrix!"
N = np.fromstring(args.N, sep=" ", dtype=float)
if len(N) == 1:
self_prob = N[0]
N = np.ones((num_classes, num_classes)) * \
((1 - self_prob) / (num_classes-1))
np.fill_diagonal(N, self_prob)
# Note: this could potentially cause some numerical problem
elif len(N) == num_classes**2:
N = N.reshape(num_classes, -1)
else:
raise ValueError("N needs to be a single value or square matrix.")
print("Corrupting training label with N:")
print(N)
train_graphs = corrupt_label(train_graphs, N)
if args.denoise != "exact":
model = GraphCNN(args.num_layers, args.num_mlp_layers,
train_graphs[0].node_features.shape[1],
args.hidden_dim, num_classes, args.final_dropout,
args.learn_eps, args.graph_pooling_type,
args.neighbor_pooling_type, device, args.bn,
args.gbn).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = optim.lr_scheduler.StepLR(optimizer,
step_size=50,
gamma=0.5)
for epoch in range(1, args.epochs + 1):
scheduler.step()
avg_loss = train(args, model, device, train_graphs, optimizer,
epoch)
acc_train, acc_test = test(args, model, device, train_graphs,
test_graphs, epoch)
if not args.filename == "":
with open(args.filename, 'w') as f:
f.write("%f %f %f" % (avg_loss, acc_train, acc_test))
f.write("\n")
print("")
print(model.eps)
else:
model = None
if args.denoise in ["estimate", "anchors", "exact"]:
C = None
anchors = None
if args.denoise == "estimate" or args.denoise == "anchors":
anchors = _parse_anchors(args.anchors, train_graphs)
C = estimate_C(model,
train_graphs,
anchors,
est_mode=args.est_mode)
elif args.denoise == "exact":
C = estimate_C(model, train_graphs, anchors, N)
criterion = None
if args.correction == "backward":
criterion = lambda x, y: backward_correction(
x, y, C, device, model.num_classes)
elif args.correction == "forward":
criterion = lambda x, y: forward_correction_xentropy(
x, y, C, device, model.num_classes)
elif args.correction == "compound":
criterion = lambda x, y: compound_correction(
x, y, C, device, model.num_classes)
del model
if not args.skip_new:
print("Training new denoising model")
model = GraphCNN(args.num_layers, args.num_mlp_layers,
train_graphs[0].node_features.shape[1],
args.hidden_dim, num_classes, args.final_dropout,
args.learn_eps, args.graph_pooling_type,
args.neighbor_pooling_type, device, args.bn,
args.gbn).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = optim.lr_scheduler.StepLR(optimizer,
step_size=50,
gamma=0.5)
for epoch in range(1, args.epochs + 1):
scheduler.step()
avg_loss = train(args, model, device, train_graphs, optimizer,
epoch, criterion)
acc_train, acc_test = test(args, model, device, train_graphs,
test_graphs, epoch)
if not args.filename == "":
with open(args.denoise+'_'+args.correction+'_'+args.est_mode\
+'_'+args.filename, 'w') as f:
f.write("%f %f %f" % (avg_loss, acc_train, acc_test))
f.write("\n")
print("")
print(model.eps)
def main():
#
#set up seeds and gpu device
torch.manual_seed(0)
np.random.seed(0)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
dataset = 'MUTAG' # 'IMDBMULTI', 'COLLAB', 'NCI1' # 'REDDITBINARY' # 'MUTAG' # 'PTC' 'PROTEINS'# 'MUTAG'
degree_as_tag = False
graphs, num_classes = load_data(dataset, degree_as_tag)
print(dataset)
##10-fold cross validation. Conduct an experiment on the fold specified by args.fold_idx.
accuracies = {}
for fold_id in range(10):
accuracies[fold_id] = 0
train_graphs, test_graphs = separate_data(graphs, 0, fold_id)
hidden_dim = 32
final_dropout = 0.5
learn_eps = False
graph_pooling_type = 'sum'
neighbor_pooling_type = 'sum' # 'attn1' 'attn2' 'sum' 'average' 'max'
device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
# device = torch.device('cpu')
model = GPN(2, 2, train_graphs[0].node_features.shape[1], hidden_dim,
num_classes)
model.to(device)
optimizer = optim.Adam(model.parameters(), lr=0.005)
# optimizer = optim.RMSprop(model.parameters(), lr=0.005)
scheduler = optim.lr_scheduler.StepLR(optimizer,
step_size=50,
gamma=0.5)
epochs = 100
for epoch in range(1, epochs + 1):
scheduler.step()
from collections import namedtuple
ARGS = namedtuple('ARGS', ['batch_size', 'iters_per_epoch'])
args = ARGS(batch_size=128, iters_per_epoch=50)
avg_loss = train(args, model, device, train_graphs, optimizer,
epoch)
acc_train, acc_test = model_test(args, model, device, train_graphs,
test_graphs, epoch)
print('epoch:{} acc_train: {}, acc_test: {}'.format(
epoch, acc_train, acc_test))
# if not args.filename == "":
# with open(args.filename, 'w') as f:
# f.write("%f %f %f" % (avg_loss, acc_train, acc_test))
# f.write("\n")
# print("")
accuracies[fold_id] = max(accuracies[fold_id], acc_test)
print('fold_id: {} current max acc test {}'.format(
fold_id, accuracies[fold_id]))
# print(model.eps)
print(accuracies)
print(np.mean(list(accuracies.values())),
np.std(list(accuracies.values())))
def main():
# Training settings
# Note: Hyper-parameters need to be tuned in order to obtain results reported in the paper.
parser = argparse.ArgumentParser(description='PyTorch graph convolutional neural net for whole-graph classification')
parser.add_argument('--dataset', type=str, default="NCI1",
help='name of dataset (default: MUTAG)')
parser.add_argument('--device', type=int, default=0,
help='which gpu to use if any (default: 0)')
parser.add_argument('--batch_size', type=int, default=32,
help='input batch size for training (default: 32)')
parser.add_argument('--iters_per_epoch', type=int, default=50,
help='number of iterations per each epoch (default: 50)')
parser.add_argument('--epochs', type=int, default=300, #defeat
help='number of epochs to train (default: 350)')
parser.add_argument('--lr', type=float, default=0.01,
help='learning rate (default: 0.01)')
parser.add_argument('--wl2', type=float, default=0.0,
help='learning rate (default: 0.0)')
parser.add_argument('--seed', type=int, default=0,
help='random seed for splitting the dataset into 10 (default: 0)')
parser.add_argument('--fold_idx', type=int, default=0,
help='the index of fold in 10-fold validation. Should be less then 10.')
parser.add_argument('--num_layers', type=int, default=6,
help='number of layers INCLUDING the input one (default: 5)')
parser.add_argument('--num_mlp_layers', type=int, default=2,
help='number of layers for MLP EXCLUDING the input one (default: 2). 1 means linear model.')
parser.add_argument('--hidden_dim', type=int, default=64,
help='number of hidden units (default: 64)')
parser.add_argument('--final_dropout', type=float, default=0.5,
help='final layer dropout (default: 0.5)')
parser.add_argument('--graph_pooling_type', type=str, default="sum", choices=["sum", "average"],
help='Pooling for over nodes in a graph: sum or average')
parser.add_argument('--neighbor_pooling_type', type=str, default="sum", choices=["sum", "average", "max"],
help='Pooling for over neighboring nodes: sum, average or max')
parser.add_argument('--learn_eps', action="store_true",
help='Whether to learn the epsilon weighting for the center nodes. Does not affect training accuracy though.')
parser.add_argument('--degree_as_tag', action="store_true",
help='let the input node features be the degree of nodes (heuristics for unlabeled graph)')
parser.add_argument('--filename', type = str, default = "yanzheng-MUTAG_sumsoftmax",
help='output file')
parser.add_argument('--attention', type=bool, default=True, #defeault false
help='if attention,defeaut:False')
parser.add_argument('--tqdm', type=bool, default=False,
help='if use tqdm')
parser.add_argument('--multi_head', type=int, default=1, # defeat:3
help='if use tqdm')
parser.add_argument('--sum_flag', type=int, default=1, #defeatut :1
help='if 0: don;t sum')
parser.add_argument('--inter', type=int, default=1, #defeult :0
help='if 0: not do unteraction in attention')
parser.add_argument('--dire_sigmod', type=int, default=0, # defeult :0
help='if 0: do softmax in dire attention,else if 1: sigmod')
parser.add_argument('--attention_type', type=str, default="mlp-sigmod",
help='attention type:dire(sum or not), mlp-softmax , mlp-sigmod')
args = parser.parse_args()
writer_path = args.filename + 'TBX'
writer = SummaryWriter(log_dir=writer_path)
ISOTIMEFORMAT = '%Y-%m-%d-%H-%M'
theTime = datetime.datetime.now().strftime(ISOTIMEFORMAT)
save_fold_path = "result/save_model/" + args.filename + str(theTime) # result save path
#set up seeds and gpu device
print("lr:",args.lr)
print("attention: ",args.attention)
print("attention_type:",args.attention_type)
print("sum_flag:",args.sum_flag)
print("inter:",args.inter)
print("filename:",args.filename)
if args.attention == True: # if do attention we need sum graph pool information
args.graph_pooling_type = 'sum'
print("data sets:",args.dataset)
print("degree as tag:",args.degree_as_tag)
print("flod_idx:",args.fold_idx)
if args.sum_flag == 1:
print("if use directly attention is sum attention ,besides use sigmod attention model")
f = open(args.filename+"_train", 'w')
torch.manual_seed(0)
np.random.seed(0)
device = torch.device("cuda:" + str(args.device)) if torch.cuda.is_available() else torch.device("cpu")
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
graphs, num_classes = load_data(args.dataset, args.degree_as_tag)
##10-fold cross validation. Conduct an experiment on the fold specified by args.fold_idx.
train_graphs, test_graphs = separate_data(graphs, args.seed, args.fold_idx)
model = GraphCNN(args.num_layers, args.num_mlp_layers, train_graphs[0].node_features.shape[1], args.hidden_dim, num_classes, args.final_dropout, args.learn_eps, args.graph_pooling_type, args.neighbor_pooling_type, device,attention=args.attention,multi_head=args.multi_head,sum_flag=args.sum_flag,inter=args.inter,attention_type=args.attention_type,dire_sigmod=args.dire_sigmod).to(device)
model.load_state_dict(torch.load("result/save_model/meta-guass-pow1062019-07-15-13-48_last.pt"))
model.eval()
# acc_train, acc_test = ftest(args, model, device, train_graphs, test_graphs, epoch)
'''
here to decide which dataset to be test!!
'''
test_graphs = train_graphs#train_graphs#train_graphs
output = pass_data_iteratively(model, test_graphs)
pred = output.max(1, keepdim=True)[1]
labels = torch.LongTensor([graph.label for graph in test_graphs]).to(device)
correct = pred.eq(labels.view_as(pred)).sum().cpu().item()
acc_test = correct / float(len(test_graphs))
print("acc test: ",acc_test*100)
def main():
# Training settings
# Note: Hyper-parameters need to be tuned in order to obtain results reported in the paper.
parser = argparse.ArgumentParser(
description=
'PyTorch graph convolutional neural net for whole-graph classification'
)
parser.add_argument('--dataset',
type=str,
default="PROTEINS",
help='name of dataset (default: MUTAG)')
parser.add_argument('--device',
type=int,
default=1,
help='which gpu to use if any (default: 0)')
parser.add_argument('--batch_size',
type=int,
default=32,
help='input batch size for training (default: 32)')
parser.add_argument(
'--iters_per_epoch',
type=int,
default=50,
help='number of iterations per each epoch (default: 50)')
parser.add_argument('--epochs',
type=int,
default=350,
help='number of epochs to train (default: 350)')
parser.add_argument('--lr',
type=float,
default=1e-2,
help='learning rate (default: 0.01)')
# parser.add_argument('--lr_decay', type=float, default=0.8,
# help='learning rate decay with epochs')
parser.add_argument(
'--seed',
type=int,
default=0,
help='random seed for splitting the dataset into 10 (default: 0)')
parser.add_argument(
'--fold_idx',
type=int,
default=0,
help='the index of fold in 10-fold validation. Should be less then 10.'
)
parser.add_argument(
'--num_layers',
type=int,
default=5,
help='number of layers INCLUDING the input one (default: 5)')
parser.add_argument(
'--num_mlp_layers',
type=int,
default=2,
help=
'number of layers for MLP EXCLUDING the input one (default: 2). 1 means linear model.'
)
parser.add_argument('--hidden_dim',
type=int,
default=64,
help='number of hidden units (default: 64)')
parser.add_argument(
'--embedded_dim',
type=int,
default=4,
help=
'number of the embedding dimension using shortest path length to sources'
)
parser.add_argument('--orders',
type=int,
default=1,
help='number of neighbors order use in conv layers')
parser.add_argument('--final_dropout',
type=float,
default=0.5,
help='final layer dropout (default: 0.5)')
parser.add_argument(
'--graph_pooling_type',
type=str,
default="sum",
choices=["sum", "average"],
help='Pooling for over nodes in a graph: sum or average')
parser.add_argument(
'--neighbor_pooling_type',
type=str,
default="sum",
choices=["sum", "average", "max"],
help='Pooling for over neighboring nodes: sum, average or max')
parser.add_argument(
'--learn_eps',
action="store_true",
help=
'Whether to learn the epsilon weighting for the center nodes. Does not affect training accuracy though.'
)
parser.add_argument('--res_connection',
type=bool,
default=False,
help='whether add shortcut or res_connection')
parser.add_argument(
'--degree_as_tag',
type=bool,
default=True,
help=
'let the input node features be the degree of nodes (heuristics for unlabeled graph)'
)
parser.add_argument('--filename', type=str, default="", help='output file')
parser.add_argument('--use_tb',
type=bool,
default=False,
help='use tensorboard to record loss')
args = parser.parse_args()
# SOTA Performance Hyperparameters
# dataset model lr batchsize epoch layers dropout orders test_acc train_acc
# PROTEINS AGAT 5e-3 32 10~20 3 0.5 1 0.794 0.82
# PROTEINS SPGNN 1e-3 32 ~30 2 0.5 2 0.771(15epochs) ~0.77
# PROTEINS SPGNN 1e-3 32 ~80 2 0.5 2 0.786 0.80
#
use_default = False
if not use_default:
args.dataset = 'PTC'
args.device = 0
args.batch_size = 32
args.lr = 1e-2
args.num_layers = 3
args.num_mlp_layers = 3
args.embedded_dim = 6
args.hidden_dim = 32
args.final_dropout = 0.5
args.orders = 3
args.degree_as_tag = True
args.res_connection = True
args.use_tb = True
args.iters_per_epoch = 30
model_ = AGCN
#set up seeds and gpu device
torch.manual_seed(0)
np.random.seed(0)
device = torch.device(
"cuda:" +
str(args.device)) if torch.cuda.is_available() else torch.device("cpu")
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
graphs, num_classes = load_data(
args.dataset,
args.degree_as_tag,
args.embedded_dim,
)
# graphs, num_classes = load_pkl(args.dataset, args.degree_as_tag, args.embedded_dim)
##10-fold cross validation. Conduct an experiment on the fold specified by args.fold_idx.
train_graphs, test_graphs = separate_data(graphs, args.seed, args.fold_idx)
model = model_(args.num_layers, args.num_mlp_layers,
train_graphs[0].node_features.shape[1], args.hidden_dim,
num_classes, args.embedded_dim, args.final_dropout,
args.res_connection, device, args.orders).to(device)
# model = AGAT(args.num_layers, args.num_mlp_layers, train_graphs[0].node_features.shape[1], args.hidden_dim, num_classes, args.embedded_dim, args.final_dropout, args.res_connection, device).to(device)
# model = GIN(args.num_layers, args.num_mlp_layers, train_graphs[0].node_features.shape[1], args.hidden_dim, num_classes, args.final_dropout, args.res_connection, device).to(device)
# pytorch_total_params = sum(p.numel() for p in model.parameters())
print(model)
writer = SummaryWriter(log_dir=log_path) if args.use_tb else None
count_step_size = 15
optimizer = optim.SGD(model.parameters(), lr=args.lr, weight_decay=1e-3)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=60, gamma=0.75)
acc_test_meter = AverageValueMeter()
for epoch in range(1, args.epochs + 1):
scheduler.step()
avg_loss = train(args, model, writer, device, train_graphs, optimizer,
epoch)
acc_train, acc_test = test(args, model, writer, device, train_graphs,
test_graphs, epoch)
acc_test_meter.add(acc_test)
if epoch % count_step_size == 0:
print('------last {} epochs test acc:{}'.format(
count_step_size,
acc_test_meter.value()[0]))
acc_test_meter.reset()
if not args.filename == "":
with open(args.filename, 'w') as f:
f.write("%f %f %f" % (avg_loss, acc_train, acc_test))
f.write("\n")
print("")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset',
type=str,
default="PROTEINS",
help='name of dataset')
parser.add_argument(
'--mod',
type=str,
default="f-scaled",
choices=["origin", "additive", "scaled", "f-additive", "f-scaled"],
help='model to be used: origin, additive, scaled, f-additive, f-scaled'
)
parser.add_argument('--seed', type=int, default=809, help='random seed')
parser.add_argument('--epochs',
type=int,
default=300,
help='number of epochs to train')
parser.add_argument('--lr',
type=float,
default=1e-2,
help='initial learning rate')
parser.add_argument('--wd',
type=float,
default=1e-3,
help='weight decay value')
parser.add_argument('--n_layer',
type=int,
default=4,
help='number of hidden layers')
parser.add_argument('--hid',
type=int,
default=32,
help='size of input hidden units')
parser.add_argument('--heads',
type=int,
default=1,
help='number of attention heads')
parser.add_argument('--dropout',
type=float,
default=0.0,
help='dropout rate')
parser.add_argument('--alpha',
type=float,
default=0.2,
help='alpha for the leaky_relu')
parser.add_argument('--kfold',
type=int,
default=10,
help='number of kfold')
parser.add_argument('--batch_size',
type=int,
default=32,
help='batch size')
parser.add_argument('--readout',
type=str,
default="add",
choices=["add", "mean"],
help='readout function: add, mean')
args = parser.parse_args()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
set_seed(args.seed)
path = osp.join(osp.dirname(osp.realpath(__file__)), '.', 'data',
args.dataset)
dataset = TUDataset(path, name=args.dataset,
pre_transform=Constant()).shuffle()
train_graphs, test_graphs = separate_data(len(dataset), args.kfold)
kfold_num = args.kfold
print('Dataset:', args.dataset)
print('# of graphs:', len(dataset))
print('# of classes:', dataset.num_classes)
test_acc_values = torch.zeros(kfold_num, args.epochs)
for idx in range(kfold_num):
print(
'============================================================================='
)
print(kfold_num, 'fold cross validation:', idx + 1)
idx_train = train_graphs[idx]
idx_test = test_graphs[idx]
train_dataset = dataset[idx_train]
test_dataset = dataset[idx_test]
train_loader = DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
worker_init_fn=args.seed)
test_loader = DataLoader(test_dataset, batch_size=args.batch_size)
t_start = time.time()
best_epoch = 0
config = Config(mod=args.mod,
nhid=args.hid,
nclass=dataset.num_classes,
nfeat=dataset.num_features,
dropout=args.dropout,
heads=args.heads,
alpha=args.alpha,
n_layer=args.n_layer,
readout=args.readout)
model = CPA(config).to(device)
optimizer = optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.wd,
amsgrad=False)
scheduler = MultiStepLR(
optimizer,
milestones=[50, 100, 150, 200, 250, 300, 350, 400, 450, 500],
gamma=0.5)
for epoch in range(args.epochs):
train_loss = train(model, train_loader, optimizer, device)
train_acc = test(model, train_loader, device)
test_acc = test(model, test_loader, device)
test_acc_values[idx, epoch] = test_acc
scheduler.step()
print('Epoch {:03d}'.format(epoch + 1),
'train_loss: {:.4f}'.format(train_loss),
'train_acc: {:.4f}'.format(train_acc),
'test_acc: {:.4f}'.format(test_acc))
print("Optimization Finished!")
print("Total time elapsed: {:.4f}s".format(time.time() - t_start))
print(
'============================================================================='
)
mean_test_acc = torch.mean(test_acc_values, dim=0)
best_epoch = int(torch.argmax(mean_test_acc).data)
print('Best Epoch:', best_epoch + 1)
print('Best Testing Accs:')
for i in test_acc_values[:, best_epoch]:
print('{:0.4f},'.format(i.item()), end='')
print('\n')
print('Averaged Best Testing Acc:')
print('{:0.4f}'.format(mean_test_acc[best_epoch].item()))
1: 'orange',
2: 'yellow',
3: 'green',
4: 'lime',
5: 'blue',
6: 'magenta'
}
#
#cmap = plt.cm.rainbow
#norm = matplotlib.colors.Normalize(vmin=0, vmax=5)
g_att = []
i = 0
np.random.seed(0)
graphs, num_classes = load_data("NCI1", False)
train_graphs, test_graphs = separate_data(graphs, 0, 0)
Gs = train_graphs[0:64]
load_path = input("input which file that you want read:")
att5 = np.load(load_path)
for g in Gs:
n = g.g.number_of_nodes()
g_att.append(list(att5[0, i:i + n]))
i = i + n
i = 0
while (1):
se = input("inout your select:")
print(se)
if se == "w":
i = min(len(Gs) - 1, i + 1)
else:
"fold_idx": 0,
"num_layers": 5,
"num_mlp_layers": 2,
"hidden_dim": 64,
"final_dropout": 0.5,
"graph_pooling_type": 'sum',
"neighbor_pooling_type": 'sum',
"learn_eps": 'store_true',
'degree_as_tag': 'store_true',
'filename': 'output.txt'
})
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
graphs, num_classes = load_data(args.dataset, args.degree_as_tag)
train_graphs, test_graphs = separate_data(graphs, args.seed, args.fold_idx)
labels = tf.constant([graph.label for graph in train_graphs])
model = GraphCNN(args.num_layers, args.num_mlp_layers, args.hidden_dim,
num_classes, args.final_dropout, args.learn_eps,
args.graph_pooling_type, args.neighbor_pooling_type)
optimizer = tf.keras.optimizers.Adam(lr=args.lr)
#def train(loss,model,opt,original):
def train(args, model, train_graphs, opt, epoch):
total_iters = args.iters_per_epoch
pbar = tqdm(range(total_iters), unit='batch')
loss_accum = 0
from sklearn.metrics import roc_auc_score
from sklearn.cross_validation import StratifiedKFold, cross_val_score
data_dir = '../../data'
cleaned_file = 'trauma_los_cleaned.csv'
extract_file = 'trauma_los_cleaned_extract.csv'
desired_headings = ['sex', 'normalvitals', 'gcs1', 'iss8', 'age65', 'transfer',
'penetrating', 'mechcode', 'bodyregions', 'headany', 'faceany', 'neckany',
'chestany', 'abdoany', 'spineany', 'upperlimbany', 'lowerlimbany', 'head3',
'face3', 'neck3', 'chest3', 'abdo3', 'spine3', 'upper3', 'lower3',
'operation', 'neurosurgery', 'laparotomy', 'thoracotomy', 'married',
'english', 'mentalhealth', 'comorbidity', 'ssa']
# trim the input file into only the features we want to use
extract_features(data_dir, cleaned_file, extract_file, desired_headings)
X, y, headings = separate_data(True, data_dir, extract_file)
# convert all strings to ints
X, y = map(lambda x:list(map(int, x)), X), map(int, y)
X, y = np.array(list(X)), np.array(list(y))
n_samples, n_features = X.shape
# create a stratified 10-fold cross-validation iterator that generates the
# indices for us
cv = StratifiedKFold(y=y, n_folds=10, shuffle=True)
# create a support vector machine classifier
clf_svm = svm.SVC(kernel='linear', probability=True)
# create a Gaussian naive Bayes classifier
clf_gauss_nb = GaussianNB()
def main():
# Training settings
# Note: Hyper-parameters need to be tuned in order to obtain results reported in the paper.
parser = argparse.ArgumentParser(
description=
'PyTorch graph convolutional neural net for whole-graph classification'
)
parser.add_argument('--dataset',
type=str,
default="DPGraphGAN_Resampled_IMDB_MULTI",
help='name of dataset')
parser.add_argument('--device',
type=int,
default=0,
help='which gpu to use if any (default: 0)')
parser.add_argument('--batch_size',
type=int,
default=32,
help='input batch size for training (default: 32)')
parser.add_argument(
'--iters_per_epoch',
type=int,
default=50,
help='number of iterations per each epoch (default: 50)')
parser.add_argument('--epochs',
type=int,
default=50,
help='number of epochs to train (default: 350)')
parser.add_argument('--lr',
type=float,
default=0.01,
help='learning rate (default: 0.01)')
parser.add_argument(
'--seed',
type=int,
default=0,
help='random seed for splitting the dataset into 10 (default: 0)')
parser.add_argument(
'--fold_idx',
type=int,
default=0,
help='the index of fold in 10-fold validation. Should be less then 10.'
)
parser.add_argument(
'--num_layers',
type=int,
default=5,
help='number of layers INCLUDING the input one (default: 5)')
parser.add_argument(
'--num_mlp_layers',
type=int,
default=2,
help=
'number of layers for MLP EXCLUDING the input one (default: 2). 1 means linear model.'
)
parser.add_argument('--hidden_dim',
type=int,
default=64,
help='number of hidden units (default: 64)')
parser.add_argument('--final_dropout',
type=float,
default=0.5,
help='final layer dropout (default: 0.5)')
parser.add_argument(
'--graph_pooling_type',
type=str,
default="sum",
choices=["sum", "average"],
help='Pooling for over nodes in a graph: sum or average')
parser.add_argument(
'--neighbor_pooling_type',
type=str,
default="sum",
choices=["sum", "average", "max"],
help='Pooling for over neighboring nodes: sum, average or max')
parser.add_argument(
'--learn_eps',
action="store_true",
help=
'Whether to learn the epsilon weighting for the center nodes. Does not affect training accuracy though.'
)
parser.add_argument(
'--degree_as_tag',
type=int,
default=1,
help=
'let the input node features be the degree of nodes (heuristics for unlabeled graph)'
)
parser.add_argument('--filename',
type=str,
default="log.txt",
help='output file')
args = parser.parse_args()
#set up seeds and gpu device
torch.manual_seed(0)
np.random.seed(0)
device = torch.device(
"cuda:" +
str(args.device)) if torch.cuda.is_available() else torch.device("cpu")
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
graphs, num_classes = load_data(args.dataset, args.degree_as_tag)
##10-fold cross validation. Conduct an experiment on the fold specified by args.fold_idx.
train_graphs, test_graphs = separate_data(graphs, args.seed, args.fold_idx)
model = GraphCNN(args.num_layers, args.num_mlp_layers,
train_graphs[0].node_features.shape[1], args.hidden_dim,
num_classes, args.final_dropout, args.learn_eps,
args.graph_pooling_type, args.neighbor_pooling_type,
device).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5)
best_acc_test = 0
file_path = dir_path + '/logs/' + args.dataset + '_' + args.filename
if os.path.exists(file_path):
os.remove(file_path)
for epoch in range(1, args.epochs + 1):
scheduler.step()
avg_loss = train(args, model, device, train_graphs, optimizer, epoch)
acc_train, acc_test = test(args, model, device, train_graphs,
test_graphs, epoch)
print("%f %f %f" % (avg_loss, acc_train, acc_test))
if acc_test > best_acc_test:
with open(file_path, 'a') as f:
f.write("%f %f %f" % (avg_loss, acc_train, acc_test))
f.write("\n")
best_acc_test = acc_test
print("")
print(model.eps)
def main():
# Training settings
# Note: Hyper-parameters need to be tuned in order to obtain results reported in the paper.
parser = argparse.ArgumentParser(description='PyTorch graph convolutional neural net for whole-graph classification')
parser.add_argument('--dataset', type=str, default="MUTAG",
help='name of dataset (default: MUTAG)')
parser.add_argument('--device', type=int, default=0,
help='which gpu to use if any (default: 0)')
parser.add_argument('--batch_size', type=int, default=32,
help='input batch size for training (default: 32)')
parser.add_argument('--iters_per_epoch', type=int, default=50,
help='number of iterations per each epoch (default: 50)')
parser.add_argument('--epochs', type=int, default=50,
help='number of epochs to train (default: 350)')
parser.add_argument('--lr', type=float, default=0.01,
help='learning rate (default: 0.01)')
parser.add_argument('--seed', type=int, default=0,
help='random seed for splitting the dataset into 10 (default: 0)')
parser.add_argument('--fold_idx', type=int, default=0,
help='the index of fold in 10-fold validation. Should be less then 10.')
parser.add_argument('--num_layers', type=int, default=5,
help='number of layers INCLUDING the input one (default: 5)')
parser.add_argument('--num_mlp_layers', type=int, default=2,
help='number of layers for MLP EXCLUDING the input one (default: 2). 1 means linear model.')
parser.add_argument('--hidden_dim', type=int, default=64,
help='number of hidden units (default: 64)')
parser.add_argument('--final_dropout', type=float, default=0.5,
help='final layer dropout (default: 0.5)')
parser.add_argument('--graph_pooling_type', type=str, default="sum", choices=["sum", "average"],
help='Pooling for over nodes in a graph: sum or average')
parser.add_argument('--neighbor_pooling_type', type=str, default="sum", choices=["sum", "average", "max"],
help='Pooling for over neighboring nodes: sum, average or max')
parser.add_argument('--learn_eps', action="store_true",
help='Whether to learn the epsilon weighting for the center nodes. Does not affect training accuracy though.')
parser.add_argument('--degree_as_tag', action="store_true",
help='let the input node features be the degree of nodes (heuristics for unlabeled graph)')
parser.add_argument('--filename', type = str, default = "",
help='output file')
parser.add_argument('--bn', type=bool, default=True, help="Enable batchnorm for MLP")
parser.add_argument('--gbn', type=bool, default=True, help="Enable batchnorm for graph")
parser.add_argument('--corrupt_label', action="store_true",
help="Enable label corruption")
parser.add_argument('--T', type=str, default="",
help="Label noise configuration T. Should be passed as a flattened string with row order or a single value for symmetrix noise config.")
args = parser.parse_args()
if args.dataset in {"MUTAG", "ENZYMES"}:
load_data = load_tud_data
if args.dataset in {"BIPARTITE"}:
load_data = gen_bipartite
#set up seeds and gpu device
torch.manual_seed(0)
np.random.seed(0)
device = torch.device("cuda:" + str(args.device)) if torch.cuda.is_available() else torch.device("cpu")
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
if args.dataset in {"BIPARTITE"}:
graphs, num_classes = load_data(200, perm_frac=0.0, p=0.2)
else:
graphs, num_classes = load_data(args.dataset, args.degree_as_tag)
acc = []
##10-fold cross validation. Conduct an experiment on the fold specified by args.fold_idx.
for fid in range(10):
train_graphs, test_graphs = separate_data(graphs, args.seed, args.fold_idx)
model = GraphCNN(args.num_layers, args.num_mlp_layers, train_graphs[0].node_tags.shape[1], args.hidden_dim, num_classes, args.final_dropout, args.learn_eps, args.graph_pooling_type, args.neighbor_pooling_type, device, args.bn, args.gbn).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5)
for epoch in range(1, args.epochs + 1):
avg_loss = train(args, model, device, train_graphs, optimizer, epoch)
scheduler.step()
acc_train, acc_test = test(args, model, device, train_graphs, test_graphs, epoch)
if not args.filename == "":
with open(args.filename, 'w') as f:
f.write("%f %f %f" % (avg_loss, acc_train, acc_test))
f.write("\n")
# print("")
# print(model.eps)
acc.append(acc_test)
print(np.mean(acc), np.std(acc))
