DGL (Deep Graph Library)

DGL provides several common GNN layers and utility functions. While the library is extensible, the core includes:

• Convolutional Layers: Such as SAGEConv and other graph convolution implementations.
• Dense Convolutional Layers: For dense graph operations.
• Pooling Layers: For graph-level or node-level pooling.
• Utilities: Helper functions for graph neural network construction.

The dgl.transforms module provides a collection of tools to transform graph structures and node/edge features. These transforms can be used to modify the topology of a graph (e.g., adding self-loops, creating line graphs, or computing k-hop graphs) or to apply mathematical normalization and feature engineering (e.g., GCN normalization, PageRank, or Laplacian Positional Encodings).

Most transforms follow a consistent interface where they can be applied to a DGL graph to produce a modified version or a new graph. For complex pipelines, you can use Compose to chain multiple transformations together.

The examples/ directory contains PyTorch implementations of selected research papers related to Graph Neural Networks (GNNs). You can find examples categorized by their publication year and tagged with specific tasks such as:

• Node Classification: (e.g., ARGO, OGC, BGNN, GATv2, SIGN)
• Link Prediction: (e.g., NGGN, SEAL_OGBL)
• Graph Classification: (e.g., Directional GSN, EEG-GCNN, GXN)
• Point Cloud Classification: (e.g., Point Transformer, PCT, BiPointNet)
• Heterogeneous Graphs: (e.g., HGT, TAHIN, MAGNN)
• Molecular Property Prediction: (e.g., DIMENET, Pre-training strategies)

To find a specific implementation, you can search the repository for the paper title or use the search tool on dgl.ai.

DGL provides a variety of pre-implemented modules to accelerate GNN development. These include categories such as:

• Convolutional layers (e.g., SAGEConv)
• Dense convolutional layers
• Pooling layers
• Utility modules

Users can extend DGL by contributing new modules to these categories.

DGL provides a collection of integrated building blocks for GNN models. Depending on your backend, these include:

• Convolutional layers: e.g., SAGEConv.
• Dense convolutional layers.
• Pooling layers.
• Utilities for GNN construction.

For PyTorch users, these are located in the dgl.nn.pytorch namespace.

For massive graphs that exceed a single machine's RAM, DGL uses a parallel data preparation pipeline consisting of two main steps:

1. Graph Partitioning: Calculates partition ownership and saves a partition assignment. This step can use parallel algorithms like ParMETIS.
2. Data Dispatching: Uses the partition assignment to physically partition the graph data, convert it into training-ready formats, and dispatch it to specified machines.

The pipeline is modular; you can replace Step 1 with a custom partitioning algorithm as long as it produces valid partition assignment files.

GraphBolt is a high-flexibility, scalable data loading framework for Graph Neural Networks (GNNs) built on top of DGL and PyTorch.

It integrates with PyTorch datapipe by using a unified MiniBatch data structure to connect different processing stages. This allows GraphBolt to streamline data loading and preprocessing for training, validation, and testing through a pipelined architecture. Because the process is exposed as a pipeline, users can substitute any stage with custom implementations while still benefiting from GraphBolt's optimized scheduling strategy.