图神经网络入门：从消息传递到GCN/GAT实战-平芜编程栈

很多刚接触图神经网络（GNN）的读者，第一反应往往是“这不就是另一个深度学习框架吗？”实际动手后才发现，从数据结构、消息传递到训练方式，图神经网络和传统神经网络差别非常大。网上的教程要么只讲数学公式，要么直接甩一堆 PyTorch Geometric 代码，缺少一条从概念到实战的完整链路。这篇文章想做的事很简单：把 GNN 背后的核心思想、经典网络（GCN、GAT）、动态图和异构图等进阶方向、以及一套可运行的实战代码串起来，当成一份系统化的入门笔记。看完后，你能理解“图”到底怎么被神经网络消费掉，也能自己动手训练一个节点分类模型。

适合正在学习图表示学习、准备把 GNN 用到推荐系统、知识图谱、社交网络分析或分子性质预测等场景的开发者。如果已经有深度学习基础，理解起来会非常快；如果只熟悉传统机器学习，我会尽量把前置概念也讲清楚。

1. 背景与核心概念

1.1 为什么需要图神经网络

传统深度学习处理的数据通常是规则的欧氏空间数据，比如图像是规则像素网格，文本是顺序排列的 token 序列。卷积神经网络和循环神经网络天然依赖这种规则结构。但现实世界中有大量数据是不规则的图结构，例如社交网络中的用户关系、电商场景中的用户与商品交互、知识图谱中的实体联系、分子结构中的原子连接关系。

这些数据的核心特点是：每个样本不是独立的，样本之间通过边相互关联；每个节点的信息需要结合邻居信息才能完整表达。以社交网络为例，想知道一个用户是否可能购买某款商品，只看用户自身特征是不够的，还需要看他的好友、好友的好友的行为倾向。这种依赖关系很难用传统全连接网络直接建模，因为输入维度不固定，邻居数量不确定，节点顺序也不具有平移不变性。

图神经网络（Graph Neural Network）正是为了解决这类非欧氏空间数据学习问题而设计的。它将图中每个节点表示成一个低维向量，并通过迭代聚合邻居信息来更新节点表示，最终可以用于节点分类、链接预测、图分类等下游任务。

1.2 图的基本数学表示

要理解 GNN，先要熟悉图的标准表示方法。一个图通常记为 ( G = (V, E) )，其中 ( V ) 是节点集合，( E ) 是边集合。在代码中，常见的数据结构包括：

x：节点特征矩阵，形状为[N, F]，其中 N 是节点数量，F 是每个节点的特征维度。
edge_index：边索引，形状为[2, E]，表示边的起点和终点。
edge_attr：边的属性（可选），形状为[E, D]。
y：节点标签（或图标签），用于监督学习。

这里最容易混淆的是edge_index的格式。在 PyTorch Geometric 中，edge_index是一个 2 行矩阵：第一行表示源节点，第二行表示目标节点。例如[[0, 1, 2], [1, 2, 0]]表示三条有向边0->1,1->2,2->0。如果是无向图，一般需要把反向边也加入，或者使用undirected=True参数自动处理。

还有一种常见表示是邻接矩阵 ( A \in \mathbb{R}^{N \times N} )，其中 ( A[i][j]=1 ) 表示节点 i 和 j 之间有边。但邻接矩阵在节点多但边少的大规模图上非常浪费内存，所以实际框架中更常用edge_index或 CSR 格式。

1.3 GNN 和传统神经网络的区别

传统神经网络（如 CNN）处理的是规则网格，卷积核在空间滑动，所有位置的共享权重使得模型具有平移等变性。而图结构没有这种“规则网格”，每个节点的邻居数量都不一样，所以需要一种更通用的“邻居聚合”机制。

GNN 的核心思想可以概括为两句话：

每个节点通过自身特征和邻居特征来更新自己的表示。
通过多层迭代，每个节点的表示可以融合多跳邻居的信息。

这和 CNN 的感受野类似：第一层看到直接邻居，第二层看到两跳邻居，层数越多感受范围越大。区别在于，GNN 的“卷积操作”是定义在任意图结构上的，而不是规则网格上。

2. 环境准备与版本说明

GNN 落地最常用的语言是 Python，基础框架是 PyTorch，配合专门的图深度学习库会大大降低开发成本。目前主流的选择有两个：

PyTorch Geometric（PyG）：基于 PyTorch，API 简洁，内置大量经典模型和数据集，适合快速实验。
DGL（Deep Graph Library）：支持 PyTorch、TensorFlow、PaddlePaddle 等后端，性能优化较好，适合大规模图。

本文的实战部分将以PyTorch Geometric为主。不过，我不建议死记某个具体版本的安装命令，因为 PyG 和 PyTorch 的版本绑定比较严格，不同的 Python 版本、CUDA 版本对应不同的安装方式。如果你在新环境里安装失败，大概率就是版本匹配问题。

下面给出一个通用的安装思路，以 Python 3.9 或 3.10 环境为例：

# 1. 先安装 PyTorch，建议到 PyTorch 官网生成符合你机器的命令 pip install torch # 2. 安装 PyTorch Geometric 及其依赖 pip install torch-scatter torch-sparse torch-cluster torch-spline-conv -f https://data.pyg.org/whl/torch-${TORCH}+${CUDA}.html # 3. 安装主库 pip install torch-geometric

注意，步骤 2 中的${TORCH}和${CUDA}需要替换成你实际的 PyTorch 版本和 CUDA 版本。如果你的环境不支持编译安装，也可以直接尝试：

pip install torch-geometric

PyG 会自动拉取依赖，如果遇到二进制兼容问题，再回到官网选择匹配的 wheel 包。

本文的示例代码大部分只需要 CPU 环境就能运行，数据集是 PyG 内置的 Cora 引文网络，不需要自己准备数据。核心代码在 PyG 2.x 版本下测试通过，如果你用的是老版本，个别 API 可能需要微调。

3. 图神经网络核心原理拆解

3.1 消息传递范式

绝大多数 GNN 模型都可以统一到一种“消息传递”范式上。对于一个节点 ( v )，它的邻居集合记为 ( N(v) )，第 ( k ) 层的节点表示 ( h_v^{(k)} ) 可以通过下面的公式得到：

把邻居节点的特征“发消息”给中心节点。
聚合这些消息（求和、均值、最大值等）。
和中心节点自身特征拼接或加权融合。
通过一个非线性变换得到新的表示。

写成代码风格的过程如下：

# 伪代码，帮助大家理解消息传递流程 import torch def message_passing(h, edge_index): # h: [N, F] # edge_index: [2, E] src, dst = edge_index # src: 源节点，dst: 目标节点 # 1. 构造消息：直接用源节点特征作为消息 msg = h[src] # 2. 聚合消息：把目标节点收到的消息求和 aggr = torch.zeros_like(h) aggr.index_add_(0, dst, msg) # 3. 更新：线性变换 + 激活函数 updated = torch.relu(aggr) return updated

当然这只是最简版本。在真实模型中，消息构造和聚合方式会复杂得多。理解消息传递范式后，再去看 GCN、GAT 等模型，你会发现它们只是这个消息传递框架的不同实例。

3.2 图卷积网络（GCN）

GCN（Graph Convolutional Network）是最经典的图卷积模型，由 Thomas Kipf 等人提出。它的核心思想是把“邻居特征的平均”定义为卷积操作，并加入自环（self-loop）让节点聚合自身特征。

卷积公式如下：

[ H^{(l+1)} = \sigma\left( \tilde{D}^{-\frac{1}{2}} \tilde{A} \tilde{D}^{-\frac{1}{2}} H^{(l)} W^{(l)} \right) ]

其中：

(\tilde{A} = A + I) 表示加了自环的邻接矩阵。
(\tilde{D}) 是 (\tilde{A}) 的度矩阵。
(W^{(l)}) 是第 (l) 层的可学习权重矩阵。
(\sigma) 是激活函数。

这个公式看起来很数学，但理解起来并不难：每个节点的新特征 = 自身特征和邻居特征加权求和后的结果，权重由度的平方根决定，起到归一化的作用，避免度数高的节点特征值过大。

在 PyG 中，GCN 的层可以通过GCNConv直接调用，核心逻辑如下：

import torch import torch.nn.functional as F from torch_geometric.nn import GCNConv class GCN(torch.nn.Module): def __init__(self, in_channels, hidden_channels, out_channels): super().__init__() self.conv1 = GCNConv(in_channels, hidden_channels) self.conv2 = GCNConv(hidden_channels, out_channels) def forward(self, x, edge_index): # x: 节点特征矩阵 [N, in_channels] # edge_index: 边索引 [2, E] x = self.conv1(x, edge_index) x = F.relu(x) x = F.dropout(x, training=self.training) x = self.conv2(x, edge_index) return x

值得注意的是，GCN 的卷积是“各向同性”的，即所有邻居共享相同的权重。这带来一个局限：无法区分不同邻居对中心节点的重要性。例如在社交网络中，显然有些好友对用户的影响更大，GCN 无法学到这种差异。

3.3 图注意力网络（GAT）

为了解决 GCN 的“一刀切”问题，GAT（Graph Attention Network）引入了注意力机制。它让模型自动学习每条边的权重，从而实现不同邻居给予不同的重要程度。

GAT 的计算过程可以拆成三步：

对节点特征做线性变换。
计算一对邻居之间的注意力系数。
对邻居特征做加权求和。

注意力系数公式如下：

[ \alpha_{ij} = \frac{\exp\left(\text{LeakyReLU}(a^T [W h_i | W h_j])\right)}{\sum_{k \in N(i)} \exp\left(\text{LeakyReLU}(a^T [W h_i | W h_k])\right)} ]

其中 (|) 表示向量拼接，(a) 是一个可学习的注意力向量。这个公式和 Transformer 中 scaled dot-product attention 在思想上是一致的，但 GAT 中的注意力是基于邻接关系的，而不是全局所有节点。

PyG 中自带多头注意力实现GATConv：

from torch_geometric.nn import GATConv class GAT(torch.nn.Module): def __init__(self, in_channels, hidden_channels, out_channels, heads=8): super().__init__() self.conv1 = GATConv(in_channels, hidden_channels, heads=heads) self.conv2 = GATConv(hidden_channels * heads, out_channels, heads=1) def forward(self, x, edge_index): x = self.conv1(x, edge_index) x = F.elu(x) x = self.conv2(x, edge_index) return x

这里heads=8表示第一层使用 8 个注意力头，每个头独立计算一份特征，然后拼接输出，所以第二层输入维度需要乘以 8。GAT 比 GCN 更灵活，在结构复杂、邻居重要性差异明显的图上表现通常更好。

3.4 其他经典图神经网络：GraphSAGE、GIN

除了 GCN 和 GAT，GraphSAGE 和 GIN（Graph Isomorphism Network）也是需要了解的经典模型。

GraphSAGE 的核心思想是“采样 + 聚合”。它不直接聚合所有邻居，而是每次随机采样固定数量的邻居，聚合时可以使用 mean、max、LSTM 等不同聚合器。这种设计让模型可以处理超大图，因为每个 batch 只需要局部子图。

GIN 则是从图同构测试的角度设计的。它被认为是目前表达能力最强的 GNN 之一，能够区分大部分不同结构的图。在分子性质预测等图分类任务中，GIN 经常作为 baseline 使用。

from torch_geometric.nn import SAGEConv, GINConv # GraphSAGE 示例 class GraphSAGE(torch.nn.Module): def __init__(self, in_channels, hidden_channels, out_channels): super().__init__() self.conv1 = SAGEConv(in_channels, hidden_channels) self.conv2 = SAGEConv(hidden_channels, out_channels) def forward(self, x, edge_index): x = self.conv1(x, edge_index).relu() x = self.conv2(x, edge_index) return x

总的来说，选择哪个基础模型没有绝对答案：GCN 简单高效，适合入门和中小规模图；GAT 在图结构较复杂时表现更好；GraphSAGE 适合大规模诱导式学习；GIN 适合需要表达能力的图分类任务。

4. 动态图与异构图：进阶方向

4.1 动态图的建模思路

前面介绍的 GCN、GAT 都是针对静态图，节点和边在训练和推理过程中保持不变。但很多真实场景下，图是动态演化的：社交网络每时每刻都有新用户和新好友关系；交易网络中不断出现新的转账边。这类图被称为动态图。

动态图的建模通常有两种思路：

时间快照法：把连续时间切成一个个离散的时间窗口，每个窗口内的图看成一个静态图，然后用静态 GNN 依次处理，再引入 RNN 或 Transformer 建模时序依赖。优点是可以直接复用静态图模型，缺点是需要人为设定窗口大小，可能丢失窗口内部的精细时序信息。
连续时间动态图法：用事件驱动的方式处理每一条边的时间戳，常见模型有 TGAT（Temporal Graph Attention Network）、TGN（Temporal Graph Networks）等。它们把时间编码进注意力计算中，能够精确建模动态变化。

对于初学者，建议先掌握时间快照法，因为它实现简单，也能解决很多实际业务问题。比如按天构图，然后每天学习一个图表示，再用 LSTM 预测未来几天的用户行为。

用 PyG 处理动态图时，往往需要引入额外的time信息。以下是一个简化的时间快照训练流程骨架：

from torch_geometric.loader import DataLoader # 假设 snapshots 是一个 list，每一项是一个 PyG Data 快照 snapshots = [...] # 每个元素有 x, edge_index, y loader = DataLoader(snapshots, batch_size=32, shuffle=True) for batch in loader: x = batch.x edge_index = batch.edge_index # 使用 GCN/GAT 提取当前时刻节点表示 # 再交给时序模块（如 LSTM）预测

4.2 异构图与元路径

异构图是指图中有多种类型的节点或多种类型的边。例如推荐系统里的“用户 - 点击 - 商品 - 属于 - 类目”就是一个典型的异构图，节点类型包含用户、商品、类目，边类型包含点击、属于等。

这种图的主要难点是不同类型的节点有不同的特征维度，不能直接放到同一个 GCN 层里做矩阵运算。异构图建模的核心方法是“按边类型分别处理”。具体来说，可以先把异构边根据类型分成多个同构子图，每个子图使用一个独立的卷积层，再将不同子图的结果映射到同一个特征空间后相加或拼接。

PyTorch Geometric 对异构图有很好的内置支持，使用HeteroData对象定义图，再使用to_hetero方法把同构模型自动转换为异构图模型。

下面是一个简单的异构图构造示例：

from torch_geometric.data import HeteroData data = HeteroData() # 用户节点特征和标签 data['user'].x = torch.randn(100, 16) # 100个用户 data['user'].y = torch.randint(0, 2, (100,)) # 二分类标签 # 商品节点特征 data['item'].x = torch.randn(200, 32) # 200个商品 # 用户到商品的“点击”关系 data['user', 'click', 'item'].edge_index = torch.randint(0, 100, (2, 500)) print(data)

在异构图上训练时，可以借助to_hetero自动适配：

import torch from torch_geometric.nn import to_hetero class GCNEncoder(torch.nn.Module): def __init__(self, hidden_channels, out_channels): super().__init__() self.conv1 = GCNConv(-1, hidden_channels) self.conv2 = GCNConv(hidden_channels, out_channels) def forward(self, x, edge_index): x = self.conv1(x, edge_index).relu() x = self.conv2(x, edge_index) return x model = GCNEncoder(hidden_channels=32, out_channels=16) model = to_hetero(model, metadata=data.metadata(), aggr='sum')

这里-1表示自动推断输入特征维度，metadata记录了节点类型和边类型信息。to_hetero会自动为每种边类型生成独立的卷积层，最后通过aggr参数聚合来自不同类型边的消息。

4.3 图扩散卷积与因果推理

最近的研究中，图扩散卷积（Graph Diffusion Convolution）和 GNN 与因果推理结合是两个热门方向。图扩散卷积通过模拟信息在图上的传播过程来做聚合，把普通的消息传递扩展为多步扩散过程，在一定程度上缓解了邻域爆炸和过平滑问题。

因果推理与 GNN 结合，主要是解决图模型中的混淆偏差问题。例如在商品推荐中，节点特征和边关系同时受到流行度影响，导致模型学到虚假相关性。这类方法较为前沿，工程落地难度也比较大，建议先掌握基础的 GCN/GAT，再逐步阅读相关论文。

5. 完整实战案例：Cora 数据集节点分类

下面我们基于 PyTorch Geometric 内置的 Cora 数据集，完成一个完整的节点分类任务。Cora 是一个引文网络，包含 2708 篇科学论文，每篇论文由一个 1433 维的词袋向量表示，论文之间通过引用关系连接，每篇论文属于 7 个类别之一。

5.1 创建项目结构与加载数据

新建一个项目文件夹，例如gnn_demo，里面创建main.py文件。完整的文件结构如下：

gnn_demo/ └── main.py

然后在main.py中导入数据和模型组件：

import torch import torch.nn.functional as F from torch_geometric.datasets import Planetoid from torch_geometric.transforms import NormalizeFeatures from torch_geometric.nn import GCNConv, GATConv

加载数据集时，Planetoid会自动下载 Cora 数据。首次运行需要网络下载，建议在能联网的环境执行。

# 加载 Cora 数据集，并做特征归一化 dataset = Planetoid(root='data/Cora', name='Cora', transform=NormalizeFeatures()) data = dataset[0] print(f'节点数量: {data.num_nodes}') print(f'边数量: {data.num_edges}') print(f'特征维度: {data.num_node_features}') print(f'类别数量: {dataset.num_classes}')

预期输出类似：

节点数量: 2708 边数量: 10556 特征维度: 1433 类别数量: 7

Cora 数据集已经划分好了训练集、验证集和测试集，分别通过data.train_mask、data.val_mask、data.test_mask标识。

5.2 定义模型

我们分别定义一个 GCN 模型和一个 GAT 模型，方便对比。

class GCN(torch.nn.Module): def __init__(self, in_channels, hidden_channels, out_channels): super().__init__() self.conv1 = GCNConv(in_channels, hidden_channels) self.conv2 = GCNConv(hidden_channels, out_channels) def forward(self, x, edge_index): x = self.conv1(x, edge_index) x = F.relu(x) x = F.dropout(x, p=0.5, training=self.training) x = self.conv2(x, edge_index) return x

GAT 模型：

class GAT(torch.nn.Module): def __init__(self, in_channels, hidden_channels, out_channels, heads=8): super().__init__() self.conv1 = GATConv(in_channels, hidden_channels, heads=heads) self.conv2 = GATConv(hidden_channels * heads, out_channels, heads=1) def forward(self, x, edge_index): x = self.conv1(x, edge_index) x = F.elu(x) x = F.dropout(x, p=0.5, training=self.training) x = self.conv2(x, edge_index) return x

如果你的机器资源有限，可以把 GAT 的hidden_channels调小，例如 8，heads调为 4。

5.3 训练函数与验证函数

训练和验证的逻辑与普通 PyTorch 模型非常相似，核心区别在于数据是整张图载入的，而不是按 batch 载入。对 Cora 这种中等规模图，整图训练完全可行。

def train(model, data, optimizer, criterion): model.train() optimizer.zero_grad() out = model(data.x, data.edge_index) loss = criterion(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss.item() def evaluate(model, data, mask): model.eval() with torch.no_grad(): logits = model(data.x, data.edge_index) pred = logits.argmax(dim=1) correct = (pred[mask] == data.y[mask]).sum().item() acc = correct / mask.sum().item() return acc

5.4 训练并对比效果

下面分别训练 GCN 和 GAT，各跑 200 个 epoch（看效果可以 100 个 epoch），并输出最优验证准确率对应的测试准确率。

def run_experiment(model_class, data, hidden=32, lr=0.01, epochs=200): if model_class.__name__ == 'GAT': model = model_class(dataset.num_features, 16, dataset.num_classes, heads=8) else: model = model_class(dataset.num_features, hidden, dataset.num_classes) optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=5e-4) criterion = torch.nn.CrossEntropyLoss() best_val_acc = 0 best_test_acc = 0 for epoch in range(epochs): loss = train(model, data, optimizer, criterion) val_acc = evaluate(model, data, data.val_mask) test_acc = evaluate(model, data, data.test_mask) if val_acc > best_val_acc: best_val_acc = val_acc best_test_acc = test_acc if (epoch + 1) % 20 == 0: print(f'Epoch {epoch+1:3d}, Loss: {loss:.4f}, Val Acc: {val_acc:.4f}, Test Acc: {test_acc:.4f}') return best_test_acc print('===== GCN =====') gcn_acc = run_experiment(GCN, data) print(f'GCN 最优测试准确率: {gcn_acc:.4f}') print('===== GAT =====') gat_acc = run_experiment(GAT, data) print(f'GAT 最优测试准确率: {gat_acc:.4f}')

运行结果会因为有随机性而略有浮动。在相同条件下，GAT 通常能比 GCN 高出 1～2 个百分点，但这并不代表 GAT 在所有数据集中都优于 GCN。由于 Cora 数据规模较小，随机种子对结果影响较大，如果想要固定结果，可以在代码开头加：

torch.manual_seed(42) torch.cuda.manual_seed_all(42)

5.5 结果说明

训练完成后，你会得到 GCN 和 GAT 的测试准确率。这里需要解释一下两种模型在 Cora 上的表现差异：

GCN 是均值聚合，所有邻居权重相同，在标签同质性较强的引文网络里已经能取得不错效果。
GAT 通过注意力机制自适应学习邻居权重，能够削弱低质量邻居的影响，理论上表达能力更强。
但由于 Cora 只有 2708 个节点、10556 条边，数据规模小，GAT 的多头注意力机制会增加参数数量，容易过拟合，所以优势不会特别明显，甚至有时会差于 GCN。

这说明一个很重要的工程观点：模型越复杂不一定效果越好，要结合数据规模和数据特性做选择。

6. 常见问题与排查思路

6.1 安装 PyG 总是报错

问题现象	常见原因	解决思路
导入 torch_geometric 报错	依赖库与 PyTorch 版本不匹配	确认 torch、CUDA、Python 版本，重新安装匹配的 wheel 包
缺少 torch_scatter 等模块	未安装扩展包	按官方安装命令安装 torch-scatter、torch-sparse、torch-cluster
版本不匹配导致编译失败	混用了不同源的包	统一从 PyG 官方 wheel 源安装

建议：安装前先查看 PyTorch 版本：

python -c "import torch; print(torch.__version__, torch.version.cuda)"

再去 PyG 官方安装页面生成对应命令。

6.2 edge_index 数据不对导致维度错误

常见报错：

RuntimeError: index 123 is out of bounds for dimension 0 with size 50

这个错误通常是因为edge_index里的节点编号超出了节点数量范围。请检查：

edge_index.max() 应小于 num_nodes edge_index.min() 应大于等于 0

如果你自己构造图，一定要保证节点编号是连续的整数。

6.3 训练 loss 不下降

可能原因：

没有做特征归一化。
学习率设置不合理。
标签 mask 没有正确划分，导致训练集为空。
模型输入输出维度不匹配，导致梯度传播异常。

建议按下面顺序排查：

打印data.x.shape、data.edge_index.shape、data.y.shape是否合理。
打印data.train_mask.sum()确认训练集有样本。
尝试把学习率调到 1e-3 或 1e-2。
使用Linear层做 baseline，排除 GNN 层的问题。

6.4 多层 GNN 叠加后效果变差

很多初学者在堆叠很多层 GCN 后，会发现模型效果不升反降，甚至所有节点的输出趋于一致。这是图神经网络的“过平滑”现象：随着层数增加，每个节点的表示包含的邻居信息过多，节点间的差异性被逐渐抹平。

解决办法：

模型层数控制在 2～3 层。
使用残差连接（Residual Connection）。
使用 JK-Net（Jumping Knowledge Network）或 PairNorm 等技巧。
对于深层邻域信息，不一定非要加层，可以尝试用扩散卷积代替。

7. 最佳实践与工程建议

7.1 数据准备阶段

先检查图连通性。如果图分散为多个不连通子图，注意 batch 内是否包含孤立节点。
对节点特征做归一化。很多图数据的特征取值范围差异大，例如论文词频向量、用户行为计数，不归一化容易导致训练不稳定。
验证标签分布。如果是节点分类，检查训练集、验证集、测试集的类别分布是否接近，避免评估结果失真。

7.2 模型设计阶段

优先从 GCN 开始，建立 baseline。
如果 baseline 效果尚可，再尝试 GAT、GraphSAGE 等复杂模型。
不要盲目堆层。2 层 GNN 已经能捕获二阶邻居信息，大多数中小图场景够用。
对于超大图，使用 GraphSAGE 或 Cluster-GCN 之类的采样训练方式，避免整图 GPU 显存溢出。

7.3 训练与评估阶段

固定随机种子，保证实验可复现。
记录多次实验的均值与标准差，不要只看一次结果。
提前停止策略很重要。使用验证集监控过拟合。
如果类别不平衡，在损失函数中使用类别权重，或者使用 Focal Loss。
测试集准确率只能在调参结束后评估一次，避免信息泄露。

7.4 工程部署与安全边界

GNN 模型上线时，很多团队会遇到“离线效果不错，线上特征对不上”的问题。原因通常是线上图的构造方式和离线不一致，比如离线包含了未来边，或特征时序错位。因此，在工程化时要注意：

明确图构建的采样时间点，保证没有未来信息泄漏。
对边的时效性做衰减或截断，避免老旧的边影响当前预测。
如果涉及用户隐私或商业敏感信息，必须进行脱敏处理，并遵循最小权限原则，在测试环境验证后再发布到生产。
对模型输出做必要的风险控制。例如推荐或反欺诈场景，需要设定置信度阈值，不满足条件的请求走人工审核或兜底策略。

7.5 代码可维护性建议

将图构造、特征工程、模型定义、训练评估拆分为不同模块。
使用 config 文件管理超参数，而不是硬编码在代码里。
为模型增加日志记录，包括 loss、准确率、显存占用等。
将 PyTorch Geometric 版本、PyTorch 版本记录在 requirements.txt 中，保证可复现。

8. 总结与学习路线

这篇文章从图的表示出发，介绍了图神经网络的核心——消息传递机制，并详细拆解了 GCN、GAT 两个最经典的模型。在此基础上，简单延伸了 GraphSAGE、GIN、动态图和异构图等进阶方向，并通过 Cora 节点分类实战跑通了一套完整代码。如果只看不练，理解很难真正落地。建议你对照代码，把 GCN 换成 GAT、GraphSAGE 试一遍，观察不同模型在测试集上的差异，再尝试改造一个自己的数据集。

下一步可以按这样的路径继续深入：

熟悉 PyTorch Geometric 内置的更多数据集，例如 PubMed、CiteSeer、Amazon、Reddit。
掌握DataLoader、NeighborSampler等批量训练方法，向大规模图迈进。
阅读带源码的论文复现项目，例如 GAT、GraphSAGE、GIN、JK-Net。
针对自己的业务场景，尝试把关系型数据建模成同构图或异构图，并完成端到端训练。
入门时不要盲目追求最新模型，先吃透 GCN、GAT 的原理和实现，再看图扩散卷积、因果推理等前沿方向。

如果你在跑代码时遇到问题，优先检查 PyG 版本、edge_index类型和节点编号范围，绝大多数入门坑都集中在这几个地方。希望这篇文章能帮你少走一些弯路。

图神经网络入门：从消息传递到GCN/GAT实战