def benchmark_task_val(args):
graphs = load_data.read_graphfile(args.datadir,
args.bmname,
max_nodes=args.max_nodes)
print('Using node labels')
for G in graphs:
for u in G.nodes():
util.node_dict(G)[u]['feat'] = np.array(
util.node_dict(G)[u]['label'])
for i in range(10):
train_dataset, val_dataset, max_num_nodes, input_dim, assign_input_dim = \
cross_val.prepare_val_data(graphs, args, i, max_nodes=args.max_nodes)
model = encoders.SoftPoolingGcnEncoder(
max_num_nodes,
input_dim,
args.hidden_dim,
args.output_dim,
args.num_classes,
args.num_gc_layers,
args.hidden_dim,
assign_ratio=args.assign_ratio,
num_pooling=args.num_pool,
bn=args.bn,
dropout=args.dropout,
linkpred=args.linkpred,
args=args,
assign_input_dim=assign_input_dim)
train(i, train_dataset, model, args, val_dataset)
def benchmark_task_val(args, writer=None, feat='node-label'):
all_vals = []
graphs = load_data.read_graphfile(args.datadir,
args.bmname,
max_nodes=args.max_nodes)
example_node = util.node_dict(graphs[0])[0]
if feat == 'node-feat' and 'feat_dim' in graphs[0].graph:
print('Using node features')
input_dim = graphs[0].graph['feat_dim']
elif feat == 'node-label' and 'label' in example_node:
print('Using node labels')
for G in graphs:
for u in G.nodes():
util.node_dict(G)[u]['feat'] = np.array(
util.node_dict(G)[u]['label'])
else:
print('Using constant labels')
featgen_const = featgen.ConstFeatureGen(
np.ones(args.input_dim, dtype=float))
for G in graphs:
featgen_const.gen_node_features(G)
for i in range(10):
train_dataset, val_dataset, max_num_nodes, input_dim, assign_input_dim = \
cross_val.prepare_val_data(graphs, args, i, max_nodes=args.max_nodes)
if args.method == 'amg-assign':
print('Method: amd-assign')
model = encoders.AmgPoolingGcnEncoder(
max_num_nodes,
input_dim,
args.hidden_dim,
args.output_dim,
args.num_classes,
args.num_gc_layers,
args.hidden_dim,
assign_ratio=args.assign_ratio,
num_pooling=args.num_pool,
bn=args.bn,
dropout=args.dropout,
linkpred=args.linkpred,
args=args,
assign_input_dim=assign_input_dim).cuda()
_, val_accs = train(train_dataset,
model,
args,
val_dataset=val_dataset,
test_dataset=None,
writer=writer)
all_vals.append(np.array(val_accs))
all_vals = np.vstack(all_vals)
all_vals = np.mean(all_vals, axis=0)
print(all_vals)
print(np.max(all_vals))
print(np.argmax(all_vals))
def benchmark_task_val(args, writer=None, feat='node-label'):
all_vals = []
graphs = load_data.read_graphfile(args.datadir,
args.bmname,
max_nodes=args.max_nodes)
#args.max_nodes = 600, maxnodes
#print("maxnodes=",maxnodes),features
#compute_matching_degree(features)
if feat == 'node-feat' and 'feat_dim' in graphs[0].graph:
print('Using node features')
input_dim = graphs[0].graph['feat_dim']
elif feat == 'node-label' and 'label' in graphs[0].nodes[0]:
print('Using node labels')
for G in graphs:
for u in G.nodes():
G.nodes[u]['feat'] = np.array(G.nodes[u]['label'])
else:
print('Using constant labels')
featgen_const = featgen.ConstFeatureGen(
np.ones(args.input_dim, dtype=float))
for G in graphs:
featgen_const.gen_node_features(G)
for i in range(10):
print("****************", i)
train_dataset, val_dataset, max_num_nodes, input_dim, assign_input_dim = \
cross_val.prepare_val_data(graphs, args, i, max_nodes=args.max_nodes)
temp_input_dim = []
temp_assign_input_dim = []
for i in range(args.num_aspect):
temp_input_dim.append(input_dim)
temp_assign_input_dim.append(assign_input_dim)
input_dim_aspect = temp_input_dim
assign_input_dim_aspect = temp_assign_input_dim
#assign_input_di, max_graph_node_numm_aspect = [assign_input_dim, assign_input_dim, assign_input_dim]
if args.method == 'MxGNN':
print('Method: MxGNN')
if args.merge_method == 'cat':
model = MxGNNCat.SoftPoolingGcnEncoder(
max_num_nodes,
args.num_aspect,
args.multi_conv,
args.multi_pool,
input_dim_aspect,
args.hidden_dim,
args.output_dim,
args.num_classes,
args.num_gc_layers,
args.hidden_dim,
assign_ratio=args.assign_ratio,
num_pooling=args.num_pool,
bn=args.bn,
dropout=args.dropout,
linkpred=args.linkpred,
args=args,
assign_input_dim=assign_input_dim_aspect).cuda()
else:
model = MxGNNSum.SoftPoolingGcnEncoder(
max_num_nodes,
args.num_aspect,
args.multi_conv,
args.multi_pool,
input_dim_aspect,
args.hidden_dim,
args.output_dim,
args.num_classes,
args.num_gc_layers,
args.hidden_dim,
assign_ratio=args.assign_ratio,
num_pooling=args.num_pool,
bn=args.bn,
dropout=args.dropout,
linkpred=args.linkpred,
args=args,
assign_input_dim=assign_input_dim_aspect).cuda()
elif args.method == 'diffpool':
print('Method: diffpool')
model = encoders.SoftPoolingGcnEncoder(
max_num_nodes,
input_dim,
args.hidden_dim,
args.output_dim,
args.num_classes,
args.num_gc_layers,
args.hidden_dim,
assign_ratio=args.assign_ratio,
num_pooling=args.num_pool,
bn=args.bn,
dropout=args.dropout,
linkpred=args.linkpred,
args=args,
assign_input_dim=assign_input_dim).cuda()
else:
print('Method: base')
model = encoders.GcnEncoderGraph(input_dim,
args.hidden_dim,
args.output_dim,
args.num_classes,
args.num_gc_layers,
bn=args.bn,
dropout=args.dropout,
args=args).cuda()
_, val_accs = train(train_dataset,
model,
args,
val_dataset=val_dataset,
test_dataset=None,
writer=writer)
all_vals.append(np.array(val_accs))
all_vals = np.vstack(all_vals)
all_vals = np.mean(all_vals, axis=0)
print(all_vals)
print(np.max(all_vals))
print(np.argmax(all_vals))
result = "./result.txt"
f = open(result, 'a+')
f.write(str(np.max(all_vals)))
f.write("\n")
f.close()
def benchmark_task_val(args, writer=None, feat='node-label'):
all_vals = []
graphs = load_data.read_graphfile(args.datadir,
args.bmname,
max_nodes=args.max_nodes) # have value
example_node = util.node_dict(graphs[0])[0]
if feat == 'node-feat' and 'feat_dim' in graphs[0].graph:
print('Using node features')
input_dim = graphs[0].graph['feat_dim']
elif feat == 'node-label' and 'label' in example_node:
print('Using node labels')
for G in graphs:
for u in G.nodes():
util.node_dict(G)[u]['feat'] = np.array(
util.node_dict(G)[u]['label'])
else:
print('Using constant labels')
featgen_const = featgen.ConstFeatureGen(
np.ones(args.input_dim, dtype=float))
for G in graphs:
featgen_const.gen_node_features(G)
for i in range(
min([
10,
max([
int(
len(graphs) *
(1 - args.train_ratio - args.test_ratio)), 1
])
])):
'''I revised here 10-> min[...]'''
train_dataset, val_dataset, max_num_nodes, input_dim, assign_input_dim = \
cross_val.prepare_val_data(graphs, args, i, max_nodes=args.max_nodes)
if args.method == 'soft-assign':
print('Method: soft-assign')
model = encoders.SoftPoolingGcnEncoder(
max_num_nodes,
input_dim,
args.hidden_dim,
args.output_dim,
args.num_classes,
args.num_gc_layers,
args.hidden_dim,
assign_ratio=args.assign_ratio,
num_pooling=args.num_pool,
num_unpooling=args.num_unpool,
unpool_ratio=args.ratio_unpool,
bn=args.bn,
dropout=args.dropout,
linkpred=args.linkpred,
args=args,
assign_input_dim=assign_input_dim).cuda()
elif args.method == 'base-set2set':
print('Method: base-set2set')
model = encoders.GcnSet2SetEncoder(input_dim,
args.hidden_dim,
args.output_dim,
args.num_classes,
args.num_gc_layers,
bn=args.bn,
dropout=args.dropout,
args=args).cuda()
else:
print('Method: base')
model = encoders.GcnEncoderGraph(input_dim,
args.hidden_dim,
args.output_dim,
args.num_classes,
args.num_gc_layers,
bn=args.bn,
dropout=args.dropout,
args=args).cuda()
_, val_accs = train(train_dataset,
model,
args,
val_dataset=val_dataset,
test_dataset=None,
writer=writer)
all_vals.append(np.array(val_accs))
all_vals = np.vstack(all_vals)
all_vals = np.mean(all_vals, axis=0)
print('all_vals: ', all_vals)
print(np.max(all_vals))
print(np.argmax(all_vals))
def benchmark_task_val(args, writer=None, feat='node-label'):
all_vals = []
graphs = load_data.read_graphfile(args.datadir, args.bmname, max_nodes=args.max_nodes)
if feat == 'node-feat' and 'feat_dim' in graphs[0].graph:
print('Using node features')
input_dim = graphs[0].graph['feat_dim']
elif feat == 'node-label' and 'label' in graphs[0].node[0]:
print('Using node labels')
for G in graphs:
for u in G.nodes():
G.node[u]['feat'] = np.array(G.node[u]['label'])
else:
print('Using constant labels')
featgen_const = featgen.ConstFeatureGen(np.ones(args.input_dim, dtype=float))
for G in graphs:
featgen_const.gen_node_features(G)
for i in range(10):
train_dataset, val_dataset, max_num_nodes, input_dim, assign_input_dim = \
cross_val.prepare_val_data(graphs, args, i, max_nodes=args.max_nodes)
if args.method == 'soft-assign':
print('Method: soft-assign')
model = encoders.SoftPoolingGcnEncoder(
max_num_nodes,
input_dim, args.hidden_dim, args.output_dim, args.num_classes, args.num_gc_layers,
args.hidden_dim, assign_ratio=args.assign_ratio, num_pooling=args.num_pool,
bn=args.bn, dropout=args.dropout, linkpred=args.linkpred, args=args,
assign_input_dim=assign_input_dim).cuda()
elif args.method == 'base-set2set':
print('Method: base-set2set')
model = encoders.GcnSet2SetEncoder(
input_dim, args.hidden_dim, args.output_dim, args.num_classes,
args.num_gc_layers, bn=args.bn, dropout=args.dropout, args=args).cuda()
else:
print('Method: base')
model = encoders.GcnEncoderGraph(
input_dim, args.hidden_dim, args.output_dim, args.num_classes,
args.num_gc_layers, bn=args.bn, dropout=args.dropout, args=args).cuda()
_, val_accs = train(train_dataset, model, args, val_dataset=val_dataset, test_dataset=None,
writer=writer)
all_vals.append(np.array(val_accs))
del train_dataset, val_dataset, model
torch.cuda.empty_cache()
all_vals = np.vstack(all_vals)
with open('log_', 'a+') as f:
f.write('{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}\n'.format(
'method', 'gc', 'dim',
'10-mean', '10-std',
'20-mean', '20-std',
'30-mean', '30-std',
'40-mean', '40-std',
'50-mean', '50-std',
'60-mean', '60-std',
'70-mean', '70-std',
'80-mean', '80-std',
'90-mean', '90-std',
'100-mean', '100-std', 'std'))
f.write('{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}\n'.format(
args.method, args.num_gc_layers, args.output_dim,
all_vals[:, 10-1].mean(), all_vals[:, 10-1].std(),
all_vals[:, 20-1].mean(), all_vals[:, 20-1].std(),
all_vals[:, 30-1].mean(), all_vals[:, 30-1].std(),
all_vals[:, 40-1].mean(), all_vals[:, 40-1].std(),
all_vals[:, 50-1].mean(), all_vals[:, 50-1].std(),
all_vals[:, 60-1].mean(), all_vals[:, 60-1].std(),
all_vals[:, 70-1].mean(), all_vals[:, 70-1].std(),
all_vals[:, 80-1].mean(), all_vals[:, 80-1].std(),
all_vals[:, 90-1].mean(), all_vals[:, 90-1].std(),
all_vals[:, 100-1].mean(), all_vals[:, 100-1].std(),
np.max(np.mean(all_vals, axis=0))))
all_vals = np.mean(all_vals, axis=0)
print(all_vals)
print(np.max(all_vals))
print(np.argmax(all_vals))
