39. Graph Neural Network Architectures

Graph neural networks (GNNs) process relational data. The core idea is not merely reshaping tabular data—but enabling nodes to exchange information via edges. This article focuses on architecture. We’ll first clarify the data flow, key modules, and output layer—then revisit the underlying formulas or code.

I begin by explicitly identifying nodes, edges, and target labels—then decide whether the task is node classification, link prediction, or graph-level classification. Different tasks entail distinct evaluation strategies.

Graph Neural Networks (GNNs) are a class of deep learning models designed specifically for graph-structured data. They are widely applied in domains such as social networks, recommendation systems, and bioinformatics. Unlike traditional neural networks, GNNs effectively capture both local relationships between nodes and the global structural properties of the network.

1. Fundamental Concepts of Graph Neural Networks

In a graph, nodes represent entities, and edges represent relationships among them. GNNs learn node representations through a message-passing mechanism. A typical GNN pipeline consists of the following steps:

While reading this article, treat the progression “Fundamental Concepts → GNN Architecture → Basic Architectures → Advanced Architectures” as a verification checklist: First distinguish the main topic, logical path, and validation points—then return to concrete examples, code, or metrics for cross-checking.

1. Message Passing: Each node receives information from its neighboring nodes.
2. Aggregation: The node updates its state representation based on the received messages.
3. Update: Finally, the node refines its representation using both its own current state and the aggregated neighbor information.

This iterative process enables GNNs to progressively capture increasingly complex structural patterns within the graph.

2. Architectures of Graph Neural Networks

2.1 Basic Architectures

When reading “Graph Neural Network Model Architecture”, treat the accompanying diagrams as navigational aids: First grasp the overall workflow order; then understand why each step is designed that way; finally verify boundary conditions and assumptions.

A foundational GNN architecture is the Graph Convolutional Network (GCN). Its core idea is to extract features via graph convolution operations. The layer-wise update rule is given by:

where $H^{(l)}$ denotes the node feature matrix at layer $l$, $A$ is the graph’s adjacency matrix, $D$ is the degree matrix, $W^{(l)}$ is a learnable weight matrix, and $\sigma$ is an activation function.

2.2 More Advanced Architectures

Beyond GCN, subsequent research has introduced numerous GNN variants tailored to diverse application needs. Examples include:

• Graph Attention Network (GAT): Uses attention mechanisms to assign different weights to neighbors during aggregation—allowing heterogeneous influence from different neighbors.
• GraphSAGE: Samples a fixed-size neighborhood for each node to accelerate training—especially effective for large-scale graphs.

import torch
import torch.nn as nn
from torch_geometric.nn import GCNConv

class GCN(nn.Module):
    def __init__(self, num_features, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(num_features, 16)
        self.conv2 = GCNConv(16, num_classes)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index).relu()
        x = self.conv2(x, edge_index)
        return x

This code implements a simple two-layer GCN for node classification. torch_geometric is a widely used library for handling graph-structured data in PyTorch.

3. Application Cases

3.1 Social Network Analysis

Consider a social network graph where nodes represent users and edges represent interactions (e.g., likes, shares, or follows). Using GNNs, we can predict user interests or behaviors. For instance, by training on historical interaction patterns, a GNN can recommend personalized content to users.

3.2 Molecular Graph Classification

In chemistry, molecules can be naturally represented as graphs: atoms serve as nodes, and chemical bonds as edges. GNNs effectively learn such structural representations and support classification or regression tasks—accelerating applications like novel drug discovery.

If you haven’t yet fully internalized “Graph Neural Network Model Architecture”, revisit this card and walk through its four actions step-by-step.

When reviewing “Graph Neural Network Model Architecture”, avoid launching a full-scale project upfront. Instead, start with one simple example to confirm whether the core logic is clear.

4. Summary and Outlook

Graph neural networks provide powerful, principled tools for modeling graph-structured data—and both their architectural design and application scope continue to evolve rapidly. As underlying technologies mature, we anticipate GNNs will play increasingly pivotal roles across ever more complex real-world tasks.

In the next tutorial, we will delve into performance evaluation for graph neural networks—including how to design rigorous experiments and select appropriate evaluation metrics.