GCN实战｜从原理到PyTorch代码：用社交网络数据搞定节点分类（GNN图神经网络丨深度学习）

我们用PyG内置的GCNConv第一层（GCNConv）：输入维度1433（Cora的特征维度），输出维度16（隐藏层），激活函数ReLU；第二层（GCNConv）：输入维度16，输出维度7（Cora的类别数），无激活函数（因为后续要接交叉熵损失，PyTorch的CrossEntropyLoss会自动加Softmax）。# 第一层GCN：输入特征数 → 隐藏层维度# 第二层GCN：隐藏层维度 →

老丁聊AI

791人浏览 · 2025-09-12 16:34:04

老丁聊AI · 2025-09-12 16:34:04 发布

大家好，我是南木——专注AI技术拆解与学习规划的博主。最近后台总收到私信：“GCN理论看了好几遍，一到写代码就卡壳”“邻接矩阵到底要怎么处理才对？”“用社交网络数据做节点分类，步骤到底是什么？”

其实我刚学图神经网络时也踩过同样的坑：公式能看懂，但一涉及“图结构数据怎么适配PyTorch”“归一化为什么能避免梯度爆炸”这类实操问题，就容易一头雾水。

今天这篇文章，我会从基础概念→核心原理→邻接矩阵深度处理→完整PyTorch实战，用社交网络经典数据集Cora手把手教你落地GCN节点分类。全程无晦涩推导，重点标注“避坑点”，无论是刚入门的同学，还是想巩固实战能力的技术人，都能跟着走通。

同时需要学习规划、就业指导、技术答疑和系统课程学习的同学欢迎扫码下方二维码找我交流
点此展开：系统课程大纲
在这里插入图片描述

一、先搞懂：图数据与节点分类到底是什么？

在开始GCN之前，我们得先明确“图”和“节点分类”的核心概念——这是后续所有操作的基础，别跳过。

1.1 图数据的3个核心组件

我们日常接触的“社交网络”（比如微信好友关系、微博关注关系）就是典型的“图（Graph）”结构。在GCN中，我们用3个核心矩阵描述图：

组件	定义	符号/示例（以社交网络为例）
节点（Node）	图中的基本单元，对应现实中的“实体”	社交网络中的“用户”，假设有N个节点，记为 $V$
边（Edge）	连接节点的“关系”，可加权（如“好友亲密度”）或无权（仅表示“是否连接”）	社交网络中的“好友关系”，记为 $E$
特征矩阵（X）	每个节点的“属性信息”，行对应节点，列对应特征维度	用户的“年龄、性别、兴趣标签”，形状为 $[N, F]$ （F是特征数）
邻接矩阵（A）	描述节点间连接关系的矩阵，若节点i和j相连， $A_{i,j}=1$ （无权图）	形状为 $[N, N]$ ，社交网络中 $A_{i,j}=1$ 表示i和j是好友
度矩阵（D）	对角矩阵，对角线元素 $D_{i,i}$ 是节点i的“边数”（度），其他为0	若用户i有5个好友，则 $D_{i,i}=5$

举个具体例子：假设社交网络有3个用户（A、B、C），A和B是好友，B和C是好友，A和C不是好友。那么：

邻接矩阵 $A$ ： $\begin{bmatrix}0&1&0\\1&0&1\\0&1&0\end{bmatrix}$
度矩阵 $D$ ： $\begin{bmatrix}1&0&0\\0&2&0\\0&0&1\end{bmatrix}$ （A有1条边，B有2条边，C有1条边）

1.2 节点分类：GCN要解决的核心问题

节点分类的任务很简单：已知图的结构（A）和部分节点的特征（X）、标签（y），预测剩余节点的标签。

比如在社交网络中：

已知10%用户的“兴趣标签”（如“科技”“娱乐”“教育”）；
已知所有用户的好友关系（A）和基础属性（X，如浏览记录、关注列表）；
用GCN预测剩下90%用户的兴趣标签——这就是典型的节点分类任务。

为什么不能用CNN/RNN？因为CNN适合网格结构（如图片的像素网格），RNN适合序列结构（如文本的词序列），而图结构是“非欧几里得”的（节点邻居数量不固定，没有统一的空间排列），GCN的核心价值就是“把图结构的信息融入特征学习”。

二、GCN核心原理：节点特征是怎么“聚合”的？

GCN（Graph Convolutional Network，图卷积网络）的本质是**“邻居特征聚合”**——每个节点的新特征，由“自身特征+邻居节点特征加权平均”得到。

这部分我们不搞复杂的傅里叶变换推导（想看理论的同学可以看原始论文《Semi-Supervised Classification with Graph Convolutional Networks》），重点讲“能直接指导代码”的核心公式和逻辑。

2.1 GCN的层级传播公式（必背）

GCN的每一层都会对节点特征进行一次“聚合更新”，公式如下：
$H^{(l+1)} = \hat{A} H^{(l)} W^{(l)} + b^{(l)}$
$H^{(l+1)} = \sigma\left( H^{(l+1)} \right)$

别慌，我们逐部分拆解，每个符号都对应实操中的具体数据：

符号	含义	对应实操（以Cora数据集为例）
$H^{(l)}$	第l层的节点特征矩阵	输入层 $H^{(0)}=X$ （Cora中X形状为[2708, 1433]）
$H^{(l+1)}$	第l+1层的节点特征矩阵（更新后的特征）	若l=0， $H^{(1)}$ 是第一层GCN的输出，形状为[2708, hidden_dim]
$\hat{A}$	归一化后的邻接矩阵（核心！）	不是原始A，而是经过“加自环+归一化”处理后的矩阵
$W^{(l)}$	第l层的可学习权重矩阵	形状为[input_dim, output_dim]，如第一层 $W^{(0)}$ 是[1433, 16]
$b^{(l)}$	第l层的偏置项（可选）	形状为[output_dim]
$\sigma$	激活函数（如ReLU、Sigmoid）	通常用ReLU，避免梯度消失

2.2 为什么要对邻接矩阵做“加自环+归一化”？

这是GCN最关键的细节，也是新手最容易踩坑的地方——直接用原始邻接矩阵A会导致两个严重问题：

问题1：原始A不含“自环”，会忽略节点自身特征

原始邻接矩阵A中， $A_{i,i}=0$ （节点不会和自己相连），如果直接用A计算，聚合时会只考虑邻居特征，忽略节点自身的特征——这显然不合理（比如判断用户兴趣，用户自己的浏览记录比好友更重要）。

解决方法：加自环——给A的对角线元素赋值1，得到 $A^{'} = A + I$ （I是单位矩阵）。这样聚合时，节点会把自己的特征也加进去。

问题2：原始A未归一化，会导致特征值爆炸/梯度消失

假设一个节点有100个邻居，原始A聚合时会把100个邻居的特征直接相加，导致节点特征值越来越大（前向传播时），或梯度越来越小（反向传播时）。

解决方法：归一化——用“度矩阵”对 $A^{'}$ 进行归一化，核心是让“每个节点的聚合特征 = （自身特征 + 邻居特征）/ （节点度数+1）”（+1是因为加了自环）。

归一化的具体步骤（记牢，代码里要实现）：

加自环： $A^{'} = A + I$ ；
计算度矩阵 $D^{'}$ ： $D'_{i,i} = \sum_j A'_{i,j}$ （节点i的“加自环后的度”）；
对称归一化： $\hat{A} = D'^{-1/2} A' D'^{-1/2}$ （最常用的方式，保证归一化后矩阵的对称性）。

举个小例子验证：
假设加自环后的 $\begin{bmatrix}1&1&0\\1&1&1\\0&1&1\end{bmatrix}$ ，则度矩阵 $\begin{bmatrix}2&0&0\\0&3&0\\0&0&2\end{bmatrix}$ 。
计算 $D'^{-1/2} = \begin{bmatrix}1/\sqrt{2}&0&0\\0&1/\sqrt{3}&0\\0&0&1/\sqrt{2}\end{bmatrix}$ ，最终 $\hat{A}$ 为：
$\hat{A} = \begin{bmatrix}1/\sqrt{2}&0&0\\0&1/\sqrt{3}&0\\0&0&1/\sqrt{2}\end{bmatrix} \begin{bmatrix}1&1&0\\1&1&1\\0&1&1\end{bmatrix} \begin{bmatrix}1/\sqrt{2}&0&0\\0&1/\sqrt{3}&0\\0&0&1/\sqrt{2}\end{bmatrix}$
这样得到的 $\hat{A}$ ，每个节点的“聚合权重”会被度数平滑，避免特征值异常。

2.3 GCN与传统NN的核心区别

用一张表直观对比，你就明白GCN为什么能处理图数据：

对比维度	传统全连接神经网络（FC）	GCN
输入数据	仅节点特征X，忽略图结构	节点特征X + 图结构 $\hat{A}$ ，融合结构信息
特征更新逻辑	每个节点的特征仅由自身X和权重W计算，与其他节点无关	每个节点的特征由“自身+邻居”特征加权聚合得到
适用场景	非结构化数据（如表格数据）	图结构数据（如社交网络、知识图谱）

三、邻接矩阵处理：从原始A到 $\hat{A}$ 的完整代码拆解

邻接矩阵是GCN的“骨架”，处理不好直接影响模型效果。这部分我们结合PyTorch代码，手把手教你实现“加自环→算度矩阵→归一化→稀疏存储”的全流程。

先明确：在实际项目中，图数据通常是“稀疏的”（比如Cora数据集，2708个节点只有5429条边，原始邻接矩阵99.9%以上都是0），所以我们不会用稠密矩阵存储A，而是用稀疏矩阵（只存储非零元素的位置和值），节省内存和计算量。

3.1 环境准备：PyTorch与PyTorch Geometric

处理图数据需要用到PyTorch Geometric（简称PyG）——这是PyTorch官方推荐的图神经网络库，内置了常用数据集（如Cora）、图卷积层（如GCNConv）和稀疏矩阵工具。

安装命令（注意：需要匹配PyTorch版本，这里以PyTorch 2.0+、CUDA 11.8为例）：

# 先安装PyTorch（如果没装的话）
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 安装PyTorch Geometric依赖
pip install torch_geometric
pip install torch_scatter torch_sparse torch_cluster torch_spline_conv -f https://data.pyg.org/whl/torch-2.0.0+cu118.html

如果安装失败，参考PyG官方文档：Installation — PyTorch Geometric Documentation

3.2 邻接矩阵处理四步走（附代码）

我们以Cora数据集为例，用PyG加载数据后，逐步处理邻接矩阵。首先加载数据，看看原始数据的结构：

步骤1：加载Cora数据集，查看原始图结构

import torch
from torch_geometric.datasets import Planetoid
from torch_geometric.utils import to_dense_adj, add_self_loops, degree
import matplotlib.pyplot as plt
import numpy as np

# 加载Cora数据集（自动下载到data文件夹）
dataset = Planetoid(root='./data', name='Cora')
data = dataset[0]  # Cora数据集只有一个图，所以取索引0

# 查看数据结构
print("=== Cora数据集基本信息 ===")
print(f"节点数：{data.num_nodes}")          # 输出：2708
print(f"边数：{data.num_edges}")            # 输出：5429（注意：PyG中边是无向的，会存储双向，实际是2714条独特边）
print(f"特征维度：{data.num_node_features}")# 输出：1433（每个节点的特征是1433维的词袋向量）
print(f"类别数：{dataset.num_classes}")     # 输出：7（论文的7个类别，如"神经网络"、"强化学习"等）
print(f"训练集节点数：{data.train_mask.sum()}") # 输出：140（每个类别20个训练样本）
print(f"验证集节点数：{data.val_mask.sum()}")   # 输出：500
print(f"测试集节点数：{data.test_mask.sum()}")   # 输出：1000

# 查看邻接矩阵的存储形式：PyG用edge_index表示邻接矩阵（稀疏格式）
print("\n=== 邻接矩阵存储形式 ===")
print(f"edge_index形状：{data.edge_index.shape}") # 输出：(2, 5429)，第一行是源节点，第二行是目标节点
print("edge_index前10个元素：")
print(data.edge_index[:, :10])  # 输出如：tensor([[0, 0, 0, ..., 1, 1], [1, 2, 3, ..., 4, 5]])

这里要注意：PyG中不用稠密矩阵A存储邻接关系，而是用edge_index（形状为[2, E]）——第一行是“源节点ID”，第二行是“目标节点ID”，每一列代表一条边。比如edge_index[:,0] = [0,1]表示节点0和节点1相连。

步骤2：加自环（Add Self-Loops）

用PyG的add_self_loops函数给每个节点加一条“自边”（即节点自己连接自己）：

# 给edge_index加自环
edge_index_with_self_loop, _ = add_self_loops(data.edge_index, num_nodes=data.num_nodes)

# 验证自环是否添加成功
print(f"\n=== 加自环后 ===")
print(f"原始edge_index边数：{data.edge_index.shape[1]}")  # 输出：5429
print(f"加自环后edge_index边数：{edge_index_with_self_loop.shape[1]}")  # 输出：5429 + 2708 = 8137（每个节点加1条自环）

# 查看自环：比如节点0的自环是否存在
self_loop_mask = (edge_index_with_self_loop[0] == edge_index_with_self_loop[1])
print(f"自环数量：{self_loop_mask.sum()}")  # 输出：2708（每个节点1条自环，正确）

步骤3：计算度矩阵（Degree Matrix）

度矩阵 $D^{'}$ 是对角矩阵，对角线元素 $D'_{i,i}$ 是“节点i加自环后的度”（即节点i的边数+1）。我们用PyG的degree函数计算：

# 计算每个节点的度（加自环后的度）
# degree函数的第一个参数是"目标节点ID"，第二个参数是节点总数
degrees = degree(edge_index_with_self_loop[1], num_nodes=data.num_nodes, dtype=torch.float)

# 构建度矩阵（稠密格式，仅用于演示，实际不用存储稠密矩阵）
D = torch.diag(degrees)
print(f"\n=== 度矩阵信息 ===")
print(f"度矩阵形状：{D.shape}")  # 输出：(2708, 2708)
print("前5个节点的度：", degrees[:5])  # 输出如：tensor([4., 3., 3., 2., 3.])
print("度矩阵前5行前5列：")
print(D[:5, :5])

这里的关键是：degree函数接收“目标节点ID”（edge_index_with_self_loop[1]），因为edge_index的第二行是目标节点，统计每个目标节点出现的次数就是度。

步骤4：对称归一化（Symmetric Normalization）

根据之前的公式，我们需要计算 $\hat{A} = D'^{-1/2} A' D'^{-1/2}$ 。但由于A'是稀疏的（用edge_index表示），我们不需要显式计算稠密矩阵乘法，而是通过“权重赋值”的方式实现归一化——这是PyG中处理稀疏邻接矩阵的核心技巧。

具体逻辑：对于每条边 $(u, v)$ （包括自环），其归一化权重为 $\frac{1}{\sqrt{D'_{u,u}} \cdot \sqrt{D'_{v,v}}}$ ，其中 $D'_{u,u}$ 是节点u的度， $D'_{v,v}$ 是节点v的度。

代码实现：

# 1. 计算D'^(-1/2)：每个节点的度的平方根的倒数
degrees_inv_sqrt = torch.pow(degrees, -0.5)
# 避免出现无穷大（如果某个节点的度为0，pow后会是inf，这里用nan_to_num替换为0）
degrees_inv_sqrt[degrees_inv_sqrt == float('inf')] = 0.0

# 2. 计算每条边的归一化权重：1/(sqrt(D_u) * sqrt(D_v))
# edge_index_with_self_loop[0]是源节点u，edge_index_with_self_loop[1]是目标节点v
weights = degrees_inv_sqrt[edge_index_with_self_loop[0]] * degrees_inv_sqrt[edge_index_with_self_loop[1]]

print(f"\n=== 归一化权重信息 ===")
print(f"权重数量：{weights.shape[0]}")  # 输出：8137（和加自环后的边数一致）
print("前10条边的归一化权重：")
print(weights[:10])  # 输出如：tensor([0.5000, 0.2887, 0.2887, ...])

# 验证：以节点0的自环为例，假设节点0的度是4，那么权重应该是1/(sqrt(4)*sqrt(4))=1/4=0.25？
# 先找到节点0的自环对应的权重
self_loop_idx = torch.where((edge_index_with_self_loop[0] == 0) & (edge_index_with_self_loop[1] == 0))[0]
print(f"\n节点0的自环权重：{weights[self_loop_idx]}")  # 输出：tensor([0.2500])，正确！

到这里，我们就完成了邻接矩阵的全部处理：从原始edge_index到“加自环+归一化权重”的edge_index_with_self_loop和weights。后续在GCN层中，我们会用这两个变量来实现特征聚合。

四、完整实战：用GCN做Cora节点分类（PyTorch代码）

有了前面的基础，我们现在可以搭建完整的GCN模型，实现Cora数据集的节点分类。整个流程分为：模型定义→训练函数→测试函数→模型训练与结果分析。

4.1 定义GCN模型

我们用PyG内置的GCNConv层（已经帮我们实现了邻接矩阵的归一化和特征聚合，不用自己写底层逻辑），搭建一个2层的GCN模型：

第一层（GCNConv）：输入维度1433（Cora的特征维度），输出维度16（隐藏层），激活函数ReLU；
第二层（GCNConv）：输入维度16，输出维度7（Cora的类别数），无激活函数（因为后续要接交叉熵损失，PyTorch的CrossEntropyLoss会自动加Softmax）。

代码实现：

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

class GCN(torch.nn.Module):
    def __init__(self, hidden_dim):
        super().__init__()
        # 第一层GCN：输入特征数 → 隐藏层维度
        self.conv1 = GCNConv(dataset.num_node_features, hidden_dim)
        # 第二层GCN：隐藏层维度 → 类别数
        self.conv2 = GCNConv(hidden_dim, dataset.num_classes)

    def forward(self, data):
        # data.x：节点特征矩阵 [2708, 1433]
        # data.edge_index：邻接矩阵（加自环前，GCNConv会自动加自环并归一化！）
        x, edge_index = data.x, data.edge_index

        # 第一层GCN：特征聚合 + ReLU激活
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        # 可选：加Dropout防止过拟合（训练时生效，测试时关闭）
        x = F.dropout(x, training=self.training, p=0.5)

        # 第二层GCN：输出类别logits
        x = self.conv2(x, edge_index)

        return x

# 初始化模型（隐藏层维度设为16，这是GCN原始论文中的参数）
model = GCN(hidden_dim=16)
print("=== GCN模型结构 ===")
print(model)

避坑点：PyG的GCNConv会自动对邻接矩阵加自环并做对称归一化，所以我们不需要把之前处理好的edge_index_with_self_loop传进去——直接传原始的data.edge_index即可！如果手动传加过自环的edge_index，会导致重复加自环，结果错误。

4.2 定义训练与测试函数

训练函数：

负责单轮训练，计算训练集损失，更新模型参数：

def train(model, data, optimizer, criterion):
    model.train()  # 开启训练模式（Dropout生效）
    optimizer.zero_grad()  # 清空梯度

    # 前向传播：得到所有节点的类别logits
    out = model(data)
    # 计算训练集损失：只考虑训练集节点（data.train_mask是布尔掩码）
    loss = criterion(out[data.train_mask], data.y[data.train_mask])

    # 反向传播 + 优化器更新
    loss.backward()
    optimizer.step()

    # 计算训练集准确率
    pred = out.argmax(dim=1)  # 对logits取argmax，得到预测类别
    train_correct = pred[data.train_mask] == data.y[data.train_mask]
    train_acc = int(train_correct.sum()) / int(data.train_mask.sum())

    return loss.item(), train_acc

测试函数：

负责验证集/测试集的准确率计算，不更新模型参数：

def test(model, data, mask):
    model.eval()  # 开启评估模式（Dropout关闭）
    with torch.no_grad():  # 禁用梯度计算，节省内存
        out = model(data)
        pred = out.argmax(dim=1)

        # 计算指定掩码（验证集/测试集）的准确率
        correct = pred[mask] == data.y[mask]
        acc = int(correct.sum()) / int(mask.sum())

    return acc

4.3 模型训练与结果分析

超参数设置：

# 损失函数：交叉熵损失（适合多分类任务）
criterion = torch.nn.CrossEntropyLoss()
# 优化器：Adam（GCN原始论文用的优化器，学习率0.01）
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
# 训练轮数：200轮（原始论文参数）
epochs = 200

# 记录训练过程中的损失和准确率
train_losses = []
train_accs = []
val_accs = []

开始训练：

print("\n=== 开始训练 ===")
for epoch in range(1, epochs + 1):
    # 单轮训练
    train_loss, train_acc = train(model, data, optimizer, criterion)
    # 计算验证集准确率
    val_acc = test(model, data, data.val_mask)

    # 记录结果
    train_losses.append(train_loss)
    train_accs.append(train_acc)
    val_accs.append(val_acc)

    # 每10轮打印一次结果
    if epoch % 10 == 0:
        print(f"Epoch: {epoch:3d}, Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, Val Acc: {val_acc:.4f}")

# 训练结束后，计算测试集准确率
test_acc = test(model, data, data.test_mask)
print(f"\n=== 训练结束 ===")
print(f"Test Acc: {test_acc:.4f}")

结果可视化：

用matplotlib画出训练损失和准确率的变化曲线，直观分析模型训练过程：

# 设置中文字体（避免乱码）
plt.rcParams['font.sans-serif'] = ['WenQuanYi Zen Hei']
plt.rcParams['axes.unicode_minus'] = False

# 创建画布
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

# 左图：训练损失曲线
ax1.plot(range(1, epochs + 1), train_losses, label='训练损失', color='blue')
ax1.set_xlabel('训练轮数（Epoch）')
ax1.set_ylabel('损失值')
ax1.set_title('GCN训练损失变化')
ax1.legend()
ax1.grid(True, alpha=0.3)

# 右图：训练准确率和验证准确率曲线
ax2.plot(range(1, epochs + 1), train_accs, label='训练准确率', color='blue')
ax2.plot(range(1, epochs + 1), val_accs, label='验证准确率', color='orange')
ax2.axhline(y=test_acc, color='red', linestyle='--', label=f'测试准确率: {test_acc:.4f}')
ax2.set_xlabel('训练轮数（Epoch）')
ax2.set_ylabel('准确率')
ax2.set_title('GCN准确率变化')
ax2.legend()
ax2.grid(True, alpha=0.3)

# 保存图片
plt.tight_layout()
plt.savefig('gcn_cora_results.png', dpi=300, bbox_inches='tight')
plt.show()

4.4 实战结果分析

正常情况下，训练200轮后，测试集准确率应该在80%~83% 之间（这是GCN在Cora数据集上的经典性能，和原始论文结果一致）。

如果你的结果不理想，可能是以下原因：

过拟合：训练集准确率接近100%，但验证集/测试集准确率低。解决方法：增加Dropout概率（如0.6）、减小隐藏层维度、增加权重衰减（weight_decay）。
梯度消失：训练损失下降缓慢，准确率低。解决方法：检查学习率（太小会导致收敛慢，太大可能震荡）、减少模型层数（GCN一般2~3层足够，层数多了容易梯度消失）。
数据加载错误：比如手动加了两次自环，或掩码用错（把验证集当训练集）。解决方法：打印data.train_mask、data.edge_index的形状，验证数据正确性。

五、进阶：邻接矩阵的优化与GCN的扩展方向

如果你已经走通了上面的实战，恭喜你掌握了GCN的核心！这部分我们聊聊“如何让模型更优”，以及GCN的扩展方向，帮你应对更复杂的实际场景。

5.1 邻接矩阵的进阶处理

1. 加权邻接矩阵（Weighted Adjacency Matrix）

前面我们用的是“无权图”（边的权重都是1），但实际场景中，边的“重要性”不同。比如社交网络中：

两个用户互动频繁（如每天聊天），边的权重可以设为2；
两个用户仅加过好友，从未互动，边的权重可以设为0.5。

如何实现加权邻接矩阵？只需在GCNConv中传入edge_weight参数即可：

# 假设我们有一个edge_weights向量，形状为[E]，表示每条边的权重
edge_weights = torch.tensor([2.0, 0.5, ...], dtype=torch.float)  # 示例，实际需要根据业务定义

# 在GCNConv中传入edge_weight
x = self.conv1(x, edge_index, edge_weight=edge_weights)

2. 处理有向图（Directed Graph）

前面的Cora是无向图，但实际场景中很多图是有向的（如“关注”关系：A关注B，B不一定关注A）。

GCN默认处理无向图，对于有向图，需要修改归一化方式为“随机游走归一化”（Random Walk Normalization）：
$\hat{A} = D'^{-1} A'$
这种方式更适合有向图，因为它考虑了“从节点u到v的概率”。在PyG中，只需在GCNConv中设置improved=False（默认是True，对应对称归一化；False对应随机游走归一化）：

self.conv1 = GCNConv(in_channels, out_channels, improved=False)

5.2 GCN的扩展方向

如果Cora的80%准确率满足不了你的需求，可以尝试以下更先进的模型：

GAT（Graph Attention Network）：用“注意力机制”动态调整邻居的权重，而不是GCN固定的“度数归一化权重”，在Cora上准确率可达85%左右。
GCNII：解决GCN层数加深后梯度消失的问题，通过“残差连接+初始特征复用”，支持更深的层数（如64层），在Cora上准确率可达87%左右。
GraphSAGE：解决GCN“需要全图结构”的问题，通过“邻居采样”实现大规模图的训练（如百万级节点），适合工业级社交网络。