This is an experimentation framework assessing how well graph neural networks (GNN) can minimize various attributed graph functions on the node domain.

Author: Emmanouil (Manios) Krasanakis
Contact: [email protected]
License: Apache 2

• Based on torch geometric.
• Modular architecture definition.
• Implementation of several diffusion-based architectures (GCN, GCNII, APPNP, S2GC, DeepSet on graphs).
• Several benchmarking tasks for the ability to approximate equivariant attributed graph functions.
• Uniform interface that treats multiple graphs as one disconnected graph.

First declare a predictive task on which to assess a GNN architecture, and obtain its training-test-validation data subtasks. If there are multiple graphs, they are packed together in one unconnected graph. A quick way for creating this setup is:

from ugnn import tasks
import torch

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
task = tasks.DegreeTask(nodes=20, max_density=0.5, graphs=1000).to(device)
splits = task.split() # default split dictionary 

Then declare an architecture and train it. Training returns the test accuracy, but test nodes are never used for training or validation. Training has a default patience=100 that waits for that many epochs for either training or validation loss to decrease. Losses and predictive performances are obtained from the predictive tasks.

from ugnn import architectures
from ugnn.utils import training

model = architectures.APPNP(task.feats, task.classes, hidden=64).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
acc = training(
    model=model,
    optimizer=optimizer,
    **splits # the previously obtained splits
)
print(f'{model.__class__.__name__} accuracy {acc:.4f}')