def __init__(self,
in_dim,
hidden_dim_1,
hidden_dim_2,
fc_hidden_1,
fc_hidden_2,
num_classes,
use_cuda=False):
"""
Constructor for the GraphAttConvBinaryClassifier class
Parameters:
in_dim (int): Dimension of features for each node
hidden_dim (int): Dimension of hidden embeddings
num_classes (int): Number of output classes
use_cuda (bool): Indicates whether GPU should be utilized or not
"""
super(SimpleGraphConvBinaryClassifier, self).__init__()
# Model layers
self.conv1 = SGConv(in_dim, hidden_dim_1)
self.conv2 = SGConv(hidden_dim_1, hidden_dim_2)
self.conv3 = SGConv(hidden_dim_2, fc_hidden_1)
self.fc_1 = nn.Linear(fc_hidden_1, fc_hidden_2)
self.fc_2 = nn.Linear(fc_hidden_2, num_classes)
self.out = nn.LogSoftmax(dim=1)
self.use_cuda = use_cuda
def __init__(self,
in_channels,
out_channels,
hids=[],
acts=[],
K=2,
dropout=0.5,
weight_decay=5e-5,
lr=0.2,
use_bias=True):
super().__init__()
if hids or acts:
raise RuntimeError(
f"Arguments 'hids' and 'acts' are not supported to use in SGC (DGL backend)."
)
conv = SGConv(in_channels,
out_channels,
bias=use_bias,
k=K,
cached=True)
self.conv = conv
self.dropout = Dropout(dropout)
self.compile(loss=torch.nn.CrossEntropyLoss(),
optimizer=optim.Adam(conv.parameters(),
lr=lr,
weight_decay=weight_decay),
metrics=[Accuracy()])
def __init__(self, net_params):
super().__init__()
in_dim = net_params['in_dim']
hidden_dim = net_params['hidden_dim']
out_dim = net_params['out_dim']
n_classes = net_params['n_classes']
dropout = net_params['dropout']
self.graph_norm = net_params['graph_norm']
self.batch_norm = net_params['batch_norm']
self.residual = net_params['residual']
self.n_classes = n_classes
self.device = net_params['device']
self.layer = SGConv(in_dim, n_classes, k=2, cached=True, bias=True)
def __init__(self,
in_features,
out_features,
hids=[],
acts=[],
K=2,
dropout=0.,
bias=True):
super().__init__()
if hids or acts:
raise RuntimeError(
f"Arguments 'hids' and 'acts' are not supported to use in SGC (DGL backend)."
)
conv = SGConv(in_features, out_features, bias=bias, k=K, cached=True)
self.dropout = nn.Dropout(dropout)
self.conv = conv
def main(args):
# load and preprocess dataset
train_acc_list = []
test_acc_list = []
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
print('>> no use GPU')
else:
cuda = True
print('>> using GPU ...')
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 = DGLGraph(data.graph)
n_edges = g.number_of_edges()
# add self loop
g.add_edges(g.nodes(), g.nodes())
# create SGC model
model = SGConv(in_feats, n_classes, k=2, cached=True, bias=args.bias)
if cuda: model.cuda()
loss_fcn = torch.nn.CrossEntropyLoss()
# loss_fcn = FocalLoss(gamma=0)
# 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(g, features) # only compute the train set
print(torch.nonzero(train_mask))
print(logits[train_mask].size())
exit()
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, g, features, labels, val_mask)
test_acc = evaluate(model, g, features, labels, test_mask)
print(
"Epoch {:05d} | Time(s) {:.4f} | Loss {:.6f} | Val accuracy {:.6f} | Test accuracy {:.6f} | ETputs(KTEPS) {:.2f}"
.format(epoch, np.mean(dur), loss.item(), acc, test_acc,
n_edges / np.mean(dur) / 1000))
train_acc_list.append(acc)
test_acc_list.append(test_acc)
plot_curve(train_acc_list, test_acc_list, args.dataset)
def main(args):
# load and preprocess dataset
args.dataset = "reddit-self-loop"
data = load_data(args)
g = data.graph
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, g.ndata['train_mask'].int().sum().item(),
g.ndata['val_mask'].int().sum().item(),
g.ndata['test_mask'].int().sum().item()))
# graph preprocess and calculate normalization factor
n_edges = g.number_of_edges()
# normalization
degs = g.in_degrees().float()
norm = torch.pow(degs, -0.5)
norm[torch.isinf(norm)] = 0
g.ndata['norm'] = norm.unsqueeze(1)
# create SGC model
model = SGConv(in_feats,
n_classes,
k=2,
cached=True,
bias=True,
norm=normalize)
if args.gpu >= 0:
model = model.cuda()
# use optimizer
optimizer = torch.optim.LBFGS(model.parameters())
# define loss closure
def closure():
optimizer.zero_grad()
output = model(g, features)[train_mask]
loss_train = F.cross_entropy(output, labels[train_mask])
loss_train.backward()
return loss_train
# initialize graph
for epoch in range(args.n_epochs):
model.train()
optimizer.step(closure)
acc = evaluate(model, features, g, labels, test_mask)
print("Test Accuracy {:.4f}".format(acc))
def choose_model(conf):
if conf['model_name'] == 'GCN':
model = GCN(g=G,
in_feats=features.shape[1],
n_hidden=conf['hidden'],
n_classes=labels.max().item() + 1,
n_layers=1,
activation=F.relu,
dropout=conf['dropout']).to(conf['device'])
elif conf['model_name'] in ['GAT', 'SGAT']:
if conf['model_name'] == 'GAT':
num_heads = 8
else:
num_heads = 1
num_layers = 1
num_out_heads = 1
heads = ([num_heads] * num_layers) + [num_out_heads]
model = GAT(
g=G,
num_layers=num_layers,
in_dim=features.shape[1],
num_hidden=8,
num_classes=labels.max().item() + 1,
heads=heads,
activation=F.relu,
feat_drop=0.6,
attn_drop=0.6,
negative_slope=0.2, # negative slope of leaky relu
residual=False).to(conf['device'])
elif conf['model_name'] == 'GraphSAGE':
model = GraphSAGE(in_feats=features.shape[1],
n_hidden=conf['embed_dim'],
n_classes=labels.max().item() + 1,
n_layers=2,
activation=F.relu,
dropout=0.5,
aggregator_type=conf['agg_type']).to(conf['device'])
elif conf['model_name'] == 'APPNP':
model = APPNP(g=G,
in_feats=features.shape[1],
hiddens=[64],
n_classes=labels.max().item() + 1,
activation=F.relu,
feat_drop=0.5,
edge_drop=0.5,
alpha=0.1,
k=10).to(conf['device'])
elif conf['model_name'] == 'MoNet':
model = MoNet(g=G,
in_feats=features.shape[1],
n_hidden=64,
out_feats=labels.max().item() + 1,
n_layers=1,
dim=2,
n_kernels=3,
dropout=0.7).to(conf['device'])
elif conf['model_name'] == 'SGC':
model = SGConv(in_feats=features.shape[1],
out_feats=labels.max().item() + 1,
k=2,
cached=True,
bias=False).to(conf['device'])
elif conf['model_name'] == 'GCNII':
if conf['dataset'] == 'citeseer':
conf['layer'] = 32
conf['hidden'] = 256
conf['lamda'] = 0.6
conf['dropout'] = 0.7
elif conf['dataset'] == 'pubmed':
conf['hidden'] = 256
conf['lamda'] = 0.4
conf['dropout'] = 0.5
model = GCNII(nfeat=features.shape[1],
nlayers=conf['layer'],
nhidden=conf['hidden'],
nclass=labels.max().item() + 1,
dropout=conf['dropout'],
lamda=conf['lamda'],
alpha=conf['alpha'],
variant=False).to(conf['device'])
return model
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 = 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()))
n_edges = g.number_of_edges()
# add self loop
g = dgl.remove_self_loop(g)
g = dgl.add_self_loop(g)
# create SGC model
model = SGConv(in_feats,
n_classes,
k=2,
cached=True,
bias=args.bias)
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(g, features) # only compute the train set
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, g, 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, g, features, labels, test_mask)
print("Test Accuracy {:.4f}".format(acc))
def main(args):
# load and preprocess dataset
args.dataset = "reddit-self-loop"
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 = DGLGraph(data.graph)
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 SGC model
model = SGConv(in_feats,
n_classes,
k=2,
cached=True,
bias=True,
norm=normalize)
if args.gpu >= 0:
model = model.cuda()
# use optimizer
optimizer = torch.optim.LBFGS(model.parameters())
# define loss closure
def closure():
optimizer.zero_grad()
output = model(g, features)[train_mask]
loss_train = F.cross_entropy(output, labels[train_mask])
loss_train.backward()
return loss_train
# initialize graph
for epoch in range(args.n_epochs):
model.train()
optimizer.step(closure)
acc = evaluate(model, features, g, labels, test_mask)
print("Test Accuracy {:.4f}".format(acc))