AMGCN图神经网络入门指南：从基础概念到实战应用

1次阅读

共计 2794 个字符，预计需要花费 7 分钟才能阅读完成。

图神经网络（GNN）是处理图结构数据的强大工具，它通过聚合邻居节点的信息来学习节点表征。传统的 GNN 如 GCN（图卷积网络）在同构图（节点和边类型单一）上表现良好，但在面对异构图（多种节点或边类型）时，往往会遇到以下问题：

忽略节点类型差异 ：传统 GCN 对所有节点一视同仁，无法区分不同类型节点的重要性。
边信息利用不足 ：异构图中边的类型和权重差异大，但传统方法难以有效利用这些信息。
过平滑问题 ：随着网络层数增加，节点表征趋于相似，丢失区分度。

AMGCN（Attention-based Multi-hop Graph Convolutional Network）通过引入注意力机制和多跳聚合策略，有效解决了上述问题。它能够自适应地学习不同节点和边的重要性，同时通过多跳聚合捕获更丰富的结构信息。

特性	GCN	GAT	AMGCN
计算复杂度	O(	E	d)
准确率	中等	较高	最高
可解释性	低	中等（注意力权重）	高（多跳注意力）
适用场景	同构图	同构图	异构图

首先，我们需要加载图数据集。以 Cora 数据集为例：

import torch
from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures

dataset = Planetoid(root='data/Cora', name='Cora', transform=NormalizeFeatures())
data = dataset[0]
print(f'Number of nodes: {data.num_nodes}')
print(f'Number of edges: {data.num_edges}')
print(f'Number of classes: {dataset.num_classes}')

AMGCN 的核心是多头注意力和多跳聚合。以下是关键组件实现：

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

class AMGCNLayer(nn.Module):
    def __init__(self, in_channels, out_channels, heads=4, dropout=0.6):
        super().__init__()
        self.attentions = [GATConv(in_channels, out_channels, heads=heads, dropout=dropout) 
                          for _ in range(3)]  # 3 hops
        self.dropout = dropout

    def forward(self, x, edge_index):
        outputs = []
        for attn in self.attentions:
            outputs.append(F.dropout(attn(x, edge_index), p=self.dropout, training=self.training))
        return torch.mean(torch.stack(outputs), dim=0)  # 多跳聚合

class AMGCN(nn.Module):
    def __init__(self, num_features, num_classes):
        super().__init__()
        self.layer1 = AMGCNLayer(num_features, 16)
        self.layer2 = AMGCNLayer(16, num_classes)

    def forward(self, x, edge_index):
        x = F.relu(self.layer1(x, edge_index))
        x = F.dropout(x, p=0.6, training=self.training)
        x = self.layer2(x, edge_index)
        return F.log_softmax(x, dim=1)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = AMGCN(dataset.num_features, dataset.num_classes).to(device)
data = data.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.005, weight_decay=5e-4)

for epoch in range(200):
    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()
    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # 梯度裁剪
    optimizer.step()

    # 验证
    model.eval()
    with torch.no_grad():
        _, pred = out.max(dim=1)
        correct = pred[data.val_mask].eq(data.y[data.val_mask]).sum().item()
        val_acc = correct / data.val_mask.sum().item()
    print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Val Acc: {val_acc:.4f}')

在 Cora 数据集上的实验结果：