Deep Learning | Yassir Boulaamane

Getting Started with Graph Neural Networks for Protein–Ligand Complexes Using DGL

Sun, 05 Apr 2026 00:00:00 +0000

So you have a set of docked protein–ligand complexes and you want to train a machine learning model on them. Traditional approaches would have you reach for fingerprints or descriptor vectors: flat, fixed-size arrays that compress the 3D interaction into a single number per compound. They work, but they discard a lot of structural information.

Graph Neural Networks (GNNs) offer a richer alternative: represent the molecule as a graph, where atoms are nodes and bonds (or non-covalent contacts) are edges, then let the network learn directly from that topology. The (DGL) makes this surprisingly approachable in PyTorch.

This post walks you through the core ideas from the DGL User Guide, translated into the language of computational drug discovery. No prior GNN experience required.

Why Graphs for Molecules?

A molecule has a natural graph structure. Atoms are nodes, bonds are edges. When you extend this to a protein–ligand complex, you can add edges for non-covalent contacts (hydrogen bonds, hydrophobic interactions, π-stacking) connecting ligand atoms to binding-pocket residues.

The key advantage: a GNN can aggregate information from a node’s neighborhood iteratively, so after a few layers, each atom’s representation encodes not just its own identity but the chemical context around it. This is exactly what a human medicinal chemist does mentally when reading a 2D structure.

The DGL Core: `DGLGraph`

Everything in DGL revolves around the DGLGraph object. Think of it as a PyTorch-native container for graph-structured data.

import dgl
import torch

# Define edges as (source_nodes, destination_nodes)
src = torch.tensor([0, 0, 1, 2])
dst = torch.tensor([1, 2, 2, 3])

g = dgl.graph((src, dst))
print(g)
# Graph(num_nodes=4, num_edges=4, ndata_schemes={}, edata_schemes={})

For molecular graphs, edges are usually undirected (bond A→B is the same as B→A), so use dgl.to_bidirected():

g = dgl.to_bidirected(g)

Attaching Features

Node and edge features are stored as PyTorch tensors directly on the graph:

# Node features: e.g., one-hot atomic number, partial charge, aromaticity...
g.ndata['feat'] = torch.randn(g.num_nodes(), 32)

# Edge features: e.g., bond type, interatomic distance...
g.edata['dist'] = torch.randn(g.num_edges(), 1)

This is the bridge between your cheminformatics featurization pipeline (RDKit, MDAnalysis, etc.) and the GNN. Whatever features you compute, just stick them in ndata or edata.

Heterogeneous Graphs: Protein + Ligand Together

If you want to model protein–ligand contacts explicitly (not just the ligand in isolation), DGL supports heterogeneous graphs: graphs with multiple node and edge types.

g = dgl.heterograph({
    ('ligand_atom', 'bond', 'ligand_atom'): (lig_src, lig_dst),
    ('ligand_atom', 'contacts', 'protein_residue'): (lig_ids, res_ids),
    ('protein_residue', 'contacts', 'ligand_atom'): (res_ids, lig_ids),
})

g.nodes['ligand_atom'].data['feat'] = ligand_atom_features
g.nodes['protein_residue'].data['feat'] = residue_features

This is a more faithful representation of the complex: the network can learn that certain binding-pocket residues modulate the ligand’s representation depending on how they interact.

Message Passing: How GNNs Actually Work

This is the heart of DGL and the heart of every GNN. Message passing works in two steps per layer:

Step 1: Edge-wise (messages): For each edge, compute a “message” from the source node’s features (and optionally the edge’s own features).

Step 2: Node-wise (aggregation + update): Each node collects all incoming messages, aggregates them (sum, mean, or max), and updates its own features.

Mathematically, for node v at layer t+1:

$$h_v^{(t+1)} = \psi\!\left(h_v^{(t)},\ \rho\!\left(\left\{ \phi(h_u^{(t)}, h_v^{(t)}, w_{uv}) : u \in \mathcal{N}(v) \right\}\right)\right)$$

where φ is the message function, ρ is the aggregation (e.g., mean), and ψ is the update function.

In DGL code, the fastest way uses built-in functions:

import dgl.function as fn

# Message: copy source node feature → edge mailbox
# Reduce: average all incoming messages → update node feature
g.update_all(fn.copy_u('h', 'm'), fn.mean('m', 'h'))

This runs as fused CUDA kernels, much faster than writing Python loops.

For custom behavior (e.g., distance-weighted messages):

def weighted_message(edges):
    # edges.src['h']: source node features
    # edges.data['dist']: edge distance
    return {'m': edges.src['h'] * torch.exp(-edges.data['dist'])}

g.update_all(weighted_message, fn.sum('m', 'h'))

Built-in GNN Layers

DGL ships with ready-to-use layers in dgl.nn.pytorch. The most useful for molecular tasks:

Layer	When to use
`GraphConv`	Simplest baseline, no edge features
`GATConv`	Learns per-edge attention weights; great for contacts with varying importance
`NNConv`	Edge-feature-conditioned messages; use when bond type or distance matters
`HeteroGraphConv`	Wraps per-relation convolutions for heterogeneous graphs

A simple two-layer GAT:

import dgl.nn.pytorch as dglnn
import torch.nn as nn
import torch.nn.functional as F

class MolGNN(nn.Module):
    def __init__(self, in_dim, hidden_dim):
        super().__init__()
        self.gat1 = dglnn.GATConv(in_dim, hidden_dim, num_heads=4)
        self.gat2 = dglnn.GATConv(hidden_dim * 4, hidden_dim, num_heads=1)

    def forward(self, g, feat):
        h = F.elu(self.gat1(g, feat).flatten(1))  # (N, hidden*4)
        h = self.gat2(g, h).squeeze(1)             # (N, hidden)
        return h

Graph-Level Prediction: Readout

After message passing, each node has a learned embedding. For a graph-level prediction (e.g., is this compound active?), you need to compress the variable-number of node embeddings into a single fixed-size vector. This is called readout.

DGL provides built-in readout functions:

# Mean of all node features → one vector per graph
graph_embedding = dgl.mean_nodes(g, 'h')

# Also available: dgl.sum_nodes, dgl.max_nodes

For a batch of graphs (many compounds at once):

bg = dgl.batch([g1, g2, g3, ...])  # one disconnected super-graph
# ... run message passing on bg ...
embeddings = dgl.mean_nodes(bg, 'h')  # shape (batch_size, hidden_dim)

dgl.batch() is what makes mini-batch training efficient: DGL treats the batch as a single large graph (with no edges between the individual molecules), runs all convolutions in one GPU call, then recovers per-graph embeddings with readout.

The Full Graph Classification Pipeline

Putting it all together: a classifier that takes a molecule graph and outputs a binary label:

import dgl
import dgl.nn.pytorch as dglnn
import torch
import torch.nn as nn
import torch.nn.functional as F

class GraphClassifier(nn.Module):
    def __init__(self, in_dim, hidden_dim, n_classes=2):
        super().__init__()
        self.conv1 = dglnn.GATConv(in_dim, hidden_dim, num_heads=4)
        self.conv2 = dglnn.GATConv(hidden_dim * 4, hidden_dim, num_heads=1)
        self.classify = nn.Linear(hidden_dim, n_classes)

    def forward(self, g, feat):
        # Message passing
        h = F.elu(self.conv1(g, feat).flatten(1))
        h = self.conv2(g, h).squeeze(1)

        # Store updated features
        with g.local_scope():
            g.ndata['h'] = h
            # Readout: mean over all atoms → graph embedding
            graph_feat = dgl.mean_nodes(g, 'h')

        return self.classify(graph_feat)


# Training loop sketch
model = GraphClassifier(in_dim=32, hidden_dim=64)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()

for epoch in range(100):
    for batched_graphs, labels in dataloader:
        feats = batched_graphs.ndata['feat']
        logits = model(batched_graphs, feats)
        loss = loss_fn(logits, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Building a Dataset

DGL has a dataset API that handles caching processed graphs to disk, important when building graphs from PDB/SDF files is slow.

class MolDataset(dgl.data.DGLDataset):
    def __init__(self, raw_dir):
        super().__init__(name='mol_dataset', raw_dir=raw_dir)

    def process(self):
        self.graphs, self.labels = [], []
        for path in self._get_files():
            g, label = self._build_graph(path)   # your featurization here
            self.graphs.append(g)
            self.labels.append(label)

    def __getitem__(self, i):
        return self.graphs[i], self.labels[i]

    def __len__(self):
        return len(self.graphs)

    def has_cache(self):
        return os.path.exists(self.save_path)

    def save(self):
        dgl.save_graphs(self.save_path, self.graphs,
                        {'labels': torch.tensor(self.labels)})

    def load(self):
        self.graphs, label_dict = dgl.load_graphs(self.save_path)
        self.labels = label_dict['labels'].tolist()

Pair this with a DataLoader using dgl.dataloading.GraphDataLoader (or PyTorch’s standard DataLoader with a custom collate_fn that calls dgl.batch()).

Multiple Instances per Compound: the Bag Approach

A common scenario in ensemble docking: you dock one compound against N different receptor conformations and get N poses, each a separate graph. You want to make one prediction per compound, not one per pose.

This is a natural fit for Multiple Instance Learning (MIL). The trick with DGL:

def predict_bag(model, bag_of_graphs):
    # Stack all N pose-graphs into one batched graph
    bg = dgl.batch(bag_of_graphs)
    feats = bg.ndata['feat']

    # Run GNN — poses stay disconnected (no cross-pose edges)
    h = model.encode(bg, feats)          # node embeddings

    with bg.local_scope():
        bg.ndata['h'] = h
        pose_embeds = dgl.mean_nodes(bg, 'h')   # (N, h_dim) — one per pose

    # MIL aggregation over the bag
    bag_embed = pose_embeds.mean(0, keepdim=True)   # mean pooling
    return model.classify(bag_embed)

The key insight: dgl.batch() keeps the poses structurally independent (no edges cross between them), so the GNN respects the fact that each pose is a separate physical structure. The MIL aggregation then decides how to combine them for the final prediction.

For a more expressive aggregation, use attention MIL:

class AttentionMIL(nn.Module):
    def __init__(self, h_dim):
        super().__init__()
        self.attention = nn.Sequential(
            nn.Linear(h_dim, 64),
            nn.Tanh(),
            nn.Linear(64, 1)
        )

    def forward(self, pose_embeds):           # (N, h_dim)
        scores = self.attention(pose_embeds)  # (N, 1)
        weights = torch.softmax(scores, dim=0)
        return (weights * pose_embeds).sum(0) # (h_dim,)

Attention MIL has a nice bonus: weights tells you which poses contributed most to the prediction, interpretable by design.

Which Chapters to Read First

If you’re using this post as a reading guide alongside the :

Priority	Chapter	Why
⭐⭐⭐	Ch 1.2–1.5: Graphs, features, heterograph	Core data structure
⭐⭐⭐	Ch 2.1–2.2: Message passing API	The computation engine
⭐⭐⭐	Ch 5.4: Graph classification	Your prediction task
⭐⭐	Ch 3: GNN modules	Ready-to-use layers
⭐⭐	Ch 4: Data pipeline	Dataset + caching
⭐	Ch 6–8: Stochastic / distributed / mixed precision	Only if dataset is huge

Summary

DGL wraps the complexity of graph-structured computation behind a clean PyTorch API. For molecular applications, the workflow is:

Build a DGLGraph for each complex: atoms as nodes, bonds/contacts as edges, features from your cheminformatics toolkit
Choose a GNN layer: GATConv is a strong default
Run message passing: each atom aggregates information from its neighbors
Apply readout (dgl.mean_nodes) to get a fixed-size graph embedding
Feed into a standard MLP classifier

The library handles batching, GPU transfer, and efficient sparse operations under the hood. Once you get the featurization right, the training code looks almost identical to a standard PyTorch image classifier.

Point Cloud Classification with Graph Neural Networks Using PyTorch Geometric

Sun, 05 Apr 2026 00:00:00 +0000

When we think about machine learning on 3D data, we usually think about images or voxel grids — discretised, regular structures that fit neatly into convolution pipelines. But a lot of 3D data in the real world doesn’t look like that. It looks like a point cloud: a raw, unordered set of coordinates in space, sometimes accompanied by extra measurements like surface normals or colour.

Protein structures, LiDAR scans, molecular conformations, cryo-EM densities — all of these are fundamentally point clouds. (PyG) makes it straightforward to apply Graph Neural Networks directly to this type of data, without voxelising it or projecting it onto a grid.

This post walks through PyG’s point cloud tutorial from first principles. No prior graph ML experience assumed.

What Is a Point Cloud?

A point cloud is simply a collection of points in 3D space:

P = { (x₁, y₁, z₁), (x₂, y₂, z₂), ..., (xₙ, yₙ, zₙ) }

There is no inherent connectivity — no bonds, no edges, no grid. The points can be in any order, and there can be any number of them. This is what makes point clouds tricky for standard deep learning: CNNs expect a fixed-size, ordered grid, but a point cloud is neither.

Graph Neural Networks sidestep this by constructing a graph from the points — connecting nearby points with edges — and then running message passing on that graph to learn local geometric structure.

The PyG `Data` Object

Everything in PyTorch Geometric revolves around the Data object — a flexible container for graph-structured data. For point clouds specifically, the key attribute is pos:

from torch_geometric.data import Data
import torch

# A simple point cloud: 5 points in 3D
data = Data(pos=torch.randn(5, 3))
print(data)
# Data(pos=[5, 3])

data.pos holds the 3D coordinates of each point. Other common attributes you’ll encounter:

Attribute	Shape	Meaning
`data.pos`	`[N, 3]`	3D coordinates of N points
`data.x`	`[N, F]`	Node feature vectors (optional)
`data.edge_index`	`[2, E]`	Graph connectivity — pairs of connected point indices
`data.y`	`[1]` or `[N]`	Label(s) — graph-level or point-level
`data.batch`	`[N]`	Batch assignment vector (added automatically during batching)

The Data object is intentionally minimal — you only include what you have.

The Dataset: GeometricShapes

PyG includes GeometricShapes, a synthetic dataset of 3D meshes representing simple geometric shapes (cubes, spheres, pyramids, and more). It’s a convenient sandbox for learning.

from torch_geometric.datasets import GeometricShapes

dataset = GeometricShapes(root='data/GeometricShapes')
print(dataset)
# GeometricShapes(40)

data = dataset[0]
print(data)
# Data(pos=[32, 3], face=[3, 30], y=[1])

Each object is stored as a mesh — vertices (pos) and their triangular connectivity (face). But we want to work with point clouds, not meshes. This is where transforms come in.

Transforms: From Mesh to Point Cloud to Graph

PyG has a rich transforms system (torch_geometric.transforms). Transforms are functions that take a Data object and return a modified one. You can compose multiple transforms together.

Step 1: Sample points from the mesh surface

SamplePoints uniformly samples a fixed number of 3D points from the mesh’s surface, proportional to face area. It discards the mesh connectivity and replaces it with a point cloud.

import torch_geometric.transforms as T

dataset.transform = T.SamplePoints(num=256)
data = dataset[0]
print(data)
# Data(pos=[256, 3], y=[1])

We now have 256 points sampled from the surface of the shape. The face attribute is gone — we only have coordinates.

Note: SamplePoints is stochastic — you get a different set of points every time you access the same example. This acts as data augmentation during training for free.

Step 2: Build a graph with k-nearest neighbours

A point cloud alone has no edges. To run a GNN, we need to connect the points. The standard approach is k-nearest neighbour (k-NN) graph construction: for each point, connect it to its k geometrically closest neighbours.

dataset.transform = T.Compose([
    T.SamplePoints(num=256),
    T.KNNGraph(k=6),
])

data = dataset[0]
print(data)
# Data(pos=[256, 3], edge_index=[2, 1536], y=[1])

We now have 1536 edges — exactly 6 per point. edge_index is a [2, E] tensor where edge_index[0] contains source node indices and edge_index[1] contains destination node indices.

Why k-NN and not a fixed radius? k-NN always gives exactly k neighbours per point regardless of local density, which keeps the graph regular. A radius-based graph (radius_graph) is an alternative when you care more about physical scale than computational regularity.

PointNet++: The Architecture

(Qi et al., NeurIPS 2017) is the foundational architecture for learning from point clouds. It works by iteratively:

Grouping — constructing a local neighbourhood graph (e.g., via k-NN)
Aggregating — running a GNN layer that collects information from each point’s neighbours
Downsampling — reducing the number of points (like pooling in a CNN) to capture larger-scale structure

For simplicity, we focus here on the grouping and aggregation steps, which are the core of the method.

The PointNet++ Layer: MessagePassing from Scratch

PyG provides a MessagePassing base class that handles all the bookkeeping of graph message propagation — you just define what message to send, and how to aggregate them.

The PointNet++ update rule for node i at layer ℓ+1 is:

$$h_i^{(\ell+1)} = \max_{j \in \mathcal{N}(i)} \text{MLP}\!\left(h_j^{(\ell)},\ \mathbf{p}_j - \mathbf{p}_i\right)$$

In words: for each neighbour j of point i, concatenate j’s features with the relative position of j with respect to i, pass that through a small MLP, then take the maximum over all neighbours. The relative position p_j - p_i is what gives the layer its geometric awareness — the network learns to respond to local shape, not just content.

Here is a full implementation from scratch using MessagePassing:

from torch import Tensor
from torch.nn import Sequential, Linear, ReLU
from torch_geometric.nn import MessagePassing

class PointNetLayer(MessagePassing):
    def __init__(self, in_channels: int, out_channels: int):
        # "max" aggregation: take the maximum over all incoming messages
        super().__init__(aggr='max')

        # MLP: maps (neighbour features + relative position) → message
        # Input size = in_channels (neighbour features) + 3 (relative xyz)
        self.mlp = Sequential(
            Linear(in_channels + 3, out_channels),
            ReLU(),
            Linear(out_channels, out_channels),
        )

    def forward(self, h: Tensor, pos: Tensor, edge_index: Tensor) -> Tensor:
        # Trigger message passing:
        # pos=(pos, pos) passes source and destination positions to message()
        return self.propagate(edge_index, h=h, pos=pos)

    def message(self, h_j: Tensor, pos_j: Tensor, pos_i: Tensor) -> Tensor:
        # h_j: features of neighbouring points (the "j" suffix = source nodes)
        # pos_j - pos_i: relative position of neighbour w.r.t. current point
        # The "_j" and "_i" suffixes are a PyG convention for source/destination
        relative_pos = pos_j - pos_i
        msg_input = torch.cat([h_j, relative_pos], dim=-1)
        return self.mlp(msg_input)

A few things worth understanding here:

The _j and _i suffix convention. In PyG’s MessagePassing, when you name a tensor in message() with a _j suffix, PyG automatically selects the features of the source nodes (neighbours). The _i suffix selects features of the destination node (the central point). This is just syntactic sugar — PyG does the indexing for you.

Why relative position, not absolute? Using pos_j - pos_i instead of absolute coordinates makes the layer translation-invariant — it responds to the shape of the local neighbourhood, not where it is in global space. This is important for generalisation.

Why max aggregation? Max pooling is permutation-invariant (order of neighbours doesn’t matter) and selects the most “active” incoming signal. It empirically works better than mean for point clouds, because the most distinctive geometric feature often comes from a single key neighbour, not the average.

Building the Full Network

Now we assemble the PointNetLayer into a full classifier. PyG handles mini-batching by concatenating all points from all examples in the batch into a single tensor, using a batch vector to track which points belong to which example.

import torch
import torch.nn.functional as F
from torch_geometric.nn import global_max_pool

class PointNet(torch.nn.Module):
    def __init__(self, num_classes: int):
        super().__init__()
        # Two PointNet++ layers: 3D coords → 32 features → 64 features
        self.conv1 = PointNetLayer(in_channels=3, out_channels=32)
        self.conv2 = PointNetLayer(in_channels=32, out_channels=64)
        # Final classifier
        self.classifier = torch.nn.Linear(64, num_classes)

    def forward(self, pos: Tensor, edge_index: Tensor, batch: Tensor) -> Tensor:
        # Initial node features = raw 3D coordinates
        h = pos

        # Layer 1: each point aggregates from its k-NN neighbours
        h = self.conv1(h, pos, edge_index)
        h = F.relu(h)

        # Layer 2: aggregate again with updated features
        h = self.conv2(h, pos, edge_index)
        h = F.relu(h)

        # Global readout: reduce all N points → one vector per graph
        # global_max_pool uses the `batch` vector to know which points belong together
        graph_embedding = global_max_pool(h, batch)  # shape: [B, 64]

        # Classify
        return self.classifier(graph_embedding)

Understanding `global_max_pool` and the `batch` vector

This is one of PyG’s most important design choices, and it’s worth understanding clearly.

When you load a mini-batch of 10 point clouds, each with 256 points, PyG doesn’t create a list of 10 separate tensors. Instead, it concatenates everything into a single tensor of shape [2560, 3] — all 2560 points together — and creates a batch vector:

batch = [0, 0, ..., 0, 1, 1, ..., 1, ..., 9, 9, ..., 9]
          ↑ 256 zeros   ↑ 256 ones         ↑ 256 nines

This batch vector tells global_max_pool which points belong to which example, so it can reduce each group of 256 points into a single 64-dimensional embedding. The output shape is [10, 64] — one vector per shape in the batch.

This approach is computationally efficient because all operations (message passing, MLP forward passes) run on contiguous tensors, not Python lists of variable-size arrays.

Using the Built-in `PointNetConv`

If you don’t want to implement the layer from scratch, PyG ships a ready-to-use version:

from torch_geometric.nn import PointNetConv
from torch.nn import Sequential, Linear, ReLU, BatchNorm1d

local_nn = Sequential(
    Linear(3 + 3, 64),    # 3 (neighbour features) + 3 (relative pos)
    ReLU(),
    Linear(64, 64),
    BatchNorm1d(64),
)

conv = PointNetConv(local_nn=local_nn, add_self_loops=True)

PointNetConv implements the same operation but with additional options like a global_nn (applied after aggregation) and support for self-loops.

Putting It All Together: Dataset, Loader, and Training

import torch
import torch_geometric.transforms as T
from torch_geometric.datasets import GeometricShapes
from torch_geometric.loader import DataLoader
from torch_geometric.nn import global_max_pool

# --- Data ---
transform = T.Compose([T.SamplePoints(num=256), T.KNNGraph(k=6)])

train_dataset = GeometricShapes(root='data/GeometricShapes', train=True)
train_dataset.transform = transform
test_dataset = GeometricShapes(root='data/GeometricShapes', train=False)
test_dataset.transform = transform

train_loader = DataLoader(train_dataset, batch_size=10, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=10)

# --- Model, optimizer, loss ---
model = PointNet(num_classes=dataset.num_classes)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
criterion = torch.nn.CrossEntropyLoss()

# --- Training loop ---
def train():
    model.train()
    total_loss = 0
    for data in train_loader:
        optimizer.zero_grad()
        logits = model(data.pos, data.edge_index, data.batch)
        loss = criterion(logits, data.y)
        loss.backward()
        optimizer.step()
        total_loss += float(loss) * data.num_graphs
    return total_loss / len(train_loader.dataset)

@torch.no_grad()
def test(loader):
    model.eval()
    total_correct = 0
    for data in loader:
        logits = model(data.pos, data.edge_index, data.batch)
        pred = logits.argmax(dim=-1)
        total_correct += int((pred == data.y).sum())
    return total_correct / len(loader.dataset)

for epoch in range(1, 51):
    loss = train()
    train_acc = test(train_loader)
    test_acc = test(test_loader)
    print(f'Epoch {epoch:02d} | Loss: {loss:.4f} | Train: {train_acc:.2%} | Test: {test_acc:.2%}')

The training loop is standard PyTorch — the only PyG-specific things are the DataLoader (which handles batching of graphs) and the data.pos, data.edge_index, data.batch attributes you pass to the model.

Going Further: Farthest Point Sampling

The tutorial also introduces Farthest Point Sampling (FPS) — a downsampling strategy used in PointNet++ to progressively reduce the number of points across layers, similar to how a CNN reduces spatial resolution via pooling.

FPS iteratively selects the point furthest from all already-selected points, ensuring good coverage of the shape’s surface:

from torch_cluster import fps

# Sample 25% of the points, keeping those most spread out
sampled_indices = fps(data.pos, ratio=0.25)
downsampled_pos = data.pos[sampled_indices]

After downsampling, you’d rebuild a new k-NN graph on the reduced point set and run another PointNet++ layer. This hierarchical approach — aggregate, downsample, repeat — is what gives PointNet++ its ability to capture multi-scale geometric structure.

Key Concepts to Remember

From mesh to point cloud: SamplePoints does this in one line. The stochastic sampling acts as free data augmentation.

From point cloud to graph: KNNGraph(k=6) connects each point to its 6 nearest neighbours. The graph is re-constructed dynamically every time you access the data.

Message passing in PyG: Subclass MessagePassing, define message(), and use _j/_i suffixes to access neighbour/central node attributes. PyG handles all the scatter-gather indexing under the hood.

Relative position is the key: The term pos_j - pos_i in the message function is what gives the network its geometric awareness. Without it, the network would be blind to the shape of the neighbourhood.

Batching via the batch vector: PyG concatenates all graphs in a batch into one large disconnected graph. global_max_pool(h, batch) then recovers one embedding per graph using the batch assignment vector.

Comparison with DGL

If you read the , you’ll notice both libraries share the message-passing paradigm. The key practical differences for point cloud work:

	PyG	DGL
Graph construction	`KNNGraph`, `radius_graph` transforms	Manual or external
Point cloud support	First-class (`SamplePoints`, `PointNetConv`)	General-purpose
Message passing	`MessagePassing` base class, `_j/_i` suffix convention	`update_all` + `fn.*` built-ins
Batching	`batch` vector, `global_*_pool`	`dgl.batch`, `dgl.mean_nodes`
Built-in PointNet	`PointNetConv`	Not built-in

For point cloud tasks specifically, PyG’s transform pipeline and built-in PointNet support give it an edge. For heterogeneous molecular graphs, DGL’s heterograph API is more expressive.

Next post: building atom-level node features from protein–ligand complexes with RDKit and MDAnalysis, and connecting them to a PyG or DGL training pipeline.