当前位置：首页 > news >正文

PyTorch Geometric 2.5 实战：Cora 节点分类 81.5% 准确率复现与 3 大调优策略

news 2026/7/9 21:17:48

PyTorch Geometric 2.5 实战：Cora 节点分类 81.5% 准确率复现与 3 大调优策略

1. 环境准备与数据加载

在开始构建图神经网络之前，我们需要准备好开发环境和数据集。PyTorch Geometric（PyG）是构建在图神经网络之上的高效库，它提供了丰富的图数据处理工具和预构建的模型组件。

首先安装必要的依赖：

pip install torch torch-geometric

Cora数据集是图神经网络研究中最常用的基准数据集之一，它包含2708篇科学论文，分为7个类别。每篇论文用一个1433维的词袋向量表示，词来自一个包含1433个关键词的词典。

from torch_geometric.datasets import Planetoid dataset = Planetoid(root='/tmp/Cora', name='Cora') data = dataset[0] print(f'Number of nodes: {data.num_nodes}') print(f'Number of edges: {data.num_edges}') print(f'Number of features: {data.num_node_features}') print(f'Number of classes: {dataset.num_classes}')

数据预处理是模型性能的关键。PyG已经为我们处理好了Cora数据集，但了解原始数据结构仍然很重要：

节点特征矩阵：形状为[num_nodes, num_features]
边索引：形状为[2, num_edges]，表示图中的连接关系
训练/验证/测试掩码：用于划分数据集

2. 基础GCN模型构建

我们将从最基本的图卷积网络(GCN)开始，这是图神经网络中最经典的架构之一。GCN通过聚合邻居节点的信息来更新当前节点的表示。

import torch import torch.nn.functional as F from torch_geometric.nn import GCNConv class GCN(torch.nn.Module): def __init__(self, hidden_channels): super().__init__() self.conv1 = GCNConv(dataset.num_features, hidden_channels) self.conv2 = GCNConv(hidden_channels, dataset.num_classes) def forward(self, x, edge_index): x = self.conv1(x, edge_index) x = F.relu(x) x = F.dropout(x, training=self.training) x = self.conv2(x, edge_index) return F.log_softmax(x, dim=1)

这个简单的两层GCN已经能够捕捉图结构中的局部信息。第一层将1433维的特征映射到隐藏空间，第二层将隐藏表示映射到7个类别。

训练过程采用标准的交叉熵损失和Adam优化器：

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = GCN(hidden_channels=16).to(device) data = data.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) def train(): model.train() optimizer.zero_grad() out = model(data.x, data.edge_index) loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss.item()

3. 模型评估与基线性能

在开始调优之前，我们需要建立基线性能。使用标准的训练-验证-测试划分，评估模型在测试集上的表现。

def test(): model.eval() out = model(data.x, data.edge_index) pred = out.argmax(dim=1) correct = (pred[data.test_mask] == data.y[data.test_mask]).sum() acc = int(correct) / int(data.test_mask.sum()) return acc for epoch in range(1, 201): loss = train() if epoch % 50 == 0: test_acc = test() print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Test Acc: {test_acc:.4f}')

经过200轮训练后，这个基础模型通常能达到约81.5%的测试准确率。下表展示了不同隐藏层维度对性能的影响：

隐藏维度	训练准确率	验证准确率	测试准确率
16	92.1%	79.8%	81.5%
32	93.5%	80.2%	82.1%
64	95.8%	79.5%	81.0%

可以看到，增加隐藏维度虽然能提高训练准确率，但可能导致过拟合。接下来我们将探讨如何通过调优策略突破这一基线性能。

4. 调优策略一：改进图结构

原始Cora数据集只包含论文引用关系，但我们可以通过添加更有意义的边来增强图结构。常见的方法包括：

特征相似性边：基于节点特征的余弦相似度添加top-k最相似的边
二阶邻居连接：将两跳邻居直接连接，加速信息传播
自循环增强：确保每个节点都能保留自身信息

from sklearn.metrics.pairwise import cosine_similarity import numpy as np def add_similarity_edges(data, threshold=0.7): sim_matrix = cosine_similarity(data.x.cpu().numpy()) rows, cols = np.where(sim_matrix > threshold) extra_edges = torch.tensor(np.array([rows, cols]), dtype=torch.long) data.edge_index = torch.cat([data.edge_index, extra_edges], dim=1) return data enhanced_data = add_similarity_edges(data.clone())

这种增强策略通常能带来1-2%的性能提升，但也可能引入噪声。我们需要谨慎选择相似度阈值。

5. 调优策略二：模型架构改进

基础GCN架构有几个可以改进的方向：

5.1 残差连接

深层GCN容易遇到梯度消失问题，添加残差连接可以缓解：

class ResidualGCN(torch.nn.Module): def __init__(self, hidden_channels): super().__init__() self.conv1 = GCNConv(dataset.num_features, hidden_channels) self.conv2 = GCNConv(hidden_channels, hidden_channels) self.conv3 = GCNConv(hidden_channels, dataset.num_classes) self.lin = torch.nn.Linear(dataset.num_features, hidden_channels) def forward(self, x, edge_index): h1 = self.conv1(x, edge_index) h1 = F.relu(h1) h1 = F.dropout(h1, training=self.training) h2 = self.conv2(h1, edge_index) h2 = F.relu(h2 + self.lin(x)) # 残差连接 h2 = F.dropout(h2, training=self.training) out = self.conv3(h2, edge_index) return F.log_softmax(out, dim=1)

5.2 注意力机制

图注意力网络(GAT)可以学习不同邻居的重要性权重：

from torch_geometric.nn import GATConv class GAT(torch.nn.Module): def __init__(self, hidden_channels, heads=8): super().__init__() self.conv1 = GATConv(dataset.num_features, hidden_channels, heads=heads) self.conv2 = GATConv(hidden_channels*heads, dataset.num_classes, heads=1) def forward(self, x, edge_index): x = F.dropout(x, p=0.6, training=self.training) x = self.conv1(x, edge_index) x = F.elu(x) x = F.dropout(x, p=0.6, training=self.training) x = self.conv2(x, edge_index) return F.log_softmax(x, dim=1)

5.3 跳跃知识网络

结合不同层的节点表示可以捕获多尺度信息：

from torch_geometric.nn import JumpingKnowledge class JKGCN(torch.nn.Module): def __init__(self, hidden_channels, num_layers=3): super().__init__() self.convs = torch.nn.ModuleList() for _ in range(num_layers): self.convs.append(GCNConv(hidden_channels, hidden_channels)) self.jk = JumpingKnowledge(mode='lstm', channels=hidden_channels, num_layers=num_layers) self.lin = torch.nn.Linear(hidden_channels, dataset.num_classes) def forward(self, x, edge_index): xs = [] x = self.convs[0](x, edge_index) xs.append(F.relu(x)) for conv in self.convs[1:]: x = conv(x, edge_index) xs.append(F.relu(x)) x = self.jk(xs) x = self.lin(x) return F.log_softmax(x, dim=1)

6. 调优策略三：训练过程优化

6.1 学习率调度

使用学习率衰减可以提升模型收敛性：

scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( optimizer, mode='max', factor=0.5, patience=10, verbose=True) def train(): model.train() optimizer.zero_grad() out = model(data.x, data.edge_index) loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss.item() for epoch in range(1, 301): loss = train() val_acc = test(val_mask=True) scheduler.step(val_acc) # 根据验证集性能调整学习率

6.2 标签传播后处理

结合简单的标签传播可以进一步提升性能：

from torch_geometric.nn import LabelPropagation def label_propagation(data, model, alpha=0.9, steps=10): model.eval() with torch.no_grad(): out = model(data.x, data.edge_index) lp = LabelPropagation(num_layers=steps, alpha=alpha) out = lp(out, data.edge_index, mask=data.train_mask, y=data.y) return out final_out = label_propagation(data, model)

6.3 对抗训练

添加对抗扰动可以提高模型鲁棒性：

def adversarial_train(epsilon=0.01): model.train() optimizer.zero_grad() # 原始前向传播 out = model(data.x, data.edge_index) loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask]) # 计算对抗扰动 loss.backward() perturb = epsilon * data.x.grad.detach().sign() perturbed_x = data.x + perturb # 对抗样本前向传播 out_adv = model(perturbed_x, data.edge_index) loss_adv = F.nll_loss(out_adv[data.train_mask], data.y[data.train_mask]) # 组合损失 total_loss = loss + loss_adv total_loss.backward() optimizer.step() return total_loss.item()