简介：《深入浅出图神经网络：GNN原理解析》一书的官方配套代码包，面向正阅读该书并希望动手实践图神经网络算法的读者。代码按章节组织，覆盖图卷积网络、图采样、自注意力池化、自编码器等核心主题，并附有交互式笔记本示例与Python脚本，方便对照书中5.4节图滤波器等易错内容进行验证。包内还提供Cora数据集的本地副本，可解决原下载地址失效问题，另有勘误PDF对已知描述错误进行更正，帮助读者减少理解偏差。资源共26个文件，以py脚本、md说明、ipynb笔记本为主，并含graph、pdf等辅助文件，整体仅306KB，轻量易部署。目前已有3484人学习下载，适合深度学习初学者与科研人员作为入门与复现的辅助材料。
1. 别在调库中浪费大半个月：GNN 原理解析配套代码的价值
第一次用 PyTorch 实现 GCN 时，我在邻接矩阵归一化上翻了两天车。A_hat = D^{-1/2}(A+I)D^{-1/2}这个公式看着简单，写到代码里要么维度对不上，要么特征聚合之后数值爆炸。后来我拿到《深入浅出图神经网络》的配套代码，沿着它的 Jupyter Notebook 走了一遍，才搞清楚问题出在度矩阵的np.power(deg, -0.5)没处理除零，以及稀疏矩阵到稠密矩阵的转换时机。这套代码不是帮你调库跑通一个GCNConv就算了，它是把 GNN 里最容易出错的矩阵运算、数据格式转换、训练循环逐段拆开，每一章对应一个 notebook，读者可以一行一行复现。特别适合两类人：一类是刚读完图神经网络理论、想落地的初学者，另一类是需要在自定义数据上改 GCN 做对比实验的工程师。搭配书里的公式编号去看代码，你会明显感觉图卷积从黑匣子变成了可以抠细节的积木块。
2. 项目架构与数据流：从 Notebook 到图数据张量
拿到这套代码之后，我习惯先看目录结构和依赖。因为这类教学型配套代码很容易出现“作者在自己环境跑得好好的，你在另一台机器上一跑就报错”的情况。搞清楚模块之间怎么组织、数据从哪个环节进入模型，后面定位问题会快很多。这一章我把目录结构、数据加载链路和环境依赖拆开讲，每部分都落到具体文件和函数，避免只停留在“这是对的”这种模糊层面。
2.1 目录结构：每个目录负责哪一块
我在本地解压后看到的目录结构大概是这样的：
graph-neural-network/ ├── data/ │ └── cora/ │ ├── ind.cora.x │ ├── ind.cora.y │ ├── ind.cora.graph │ └── ... ├── notebooks/ │ ├── 01_图的基础表示与可视化.ipynb │ ├── 02_图信号处理与卷积定义.ipynb │ ├── 03_从傅里叶到GCN推导.ipynb │ ├── 04_GCN节点分类实战.ipynb │ ├── 05_GraphSAGE与邻居采样.ipynb │ ├── 06_GAT注意力机制与多头.ipynb │ └── utils/ │ ├── load_cora.py │ ├── graph_ops.py │ └── visualization.py ├── models/ │ ├── gcn.py │ ├── gsage.py │ └── gat.py ├── requirements.txt └── README.mdnotebooks里的编号是严格按照书的内容推进的，从图的表示、信号处理到经典的 GCN，再到工业上更常用的 GraphSAGE 和 GAT。每个 notebook 都自包含，先跑utils里的加载函数，然后构建矩阵，再进入models里的网络定义。models下三个文件把三种经典 GNN 架构封装成了可以复用的模块。data里放的是训练用的引文网络数据集，直接读进内存，不需要额外下载。
这套组织方式最实用的地方在于：你不会在一堆.py文件里迷失方向。书里每一章讲到什么，就对应一个 notebook，代码里用注释标了公式编号，能直接对照正文看。对二次开发来说，改模型就是改models里的类，换数据就是替换data目录下的文件，边界很清楚。我第一次跑的时候，把utils/load_cora.py单独拿出来试了一遍，就知道数据进入模型前经过了几次变换，这才是真正的“读代码”而不是“跑代码”。
2.2 数据加载链路：从磁盘文件到内存矩阵
GNN 和普通神经网络最本质的区别在于输入不是一批独立样本，而是一个图结构。我在第一次读源码时最关心的就是：原始数据里那堆互相引用的边，到底是怎么变成模型能吃进去的[N, N]张量的。这个项目的数据加载分三步：
第一步从文件读入节点特征和标签，第二步从graph字典解析出边表，第三步把边表转成邻接矩阵。load_cora.py里最核心的部分可以简化成下面的逻辑：
import numpy as np import pickle def load_cora(data_path): # 从标准格式中读取特征、标签和图结构 with open(data_path + '/ind.cora.x', 'rb') as f: features = pickle.load(f, encoding='latin1') # [N, D] with open(data_path + '/ind.cora.y', 'rb') as f: labels = pickle.load(f, encoding='latin1') # [N] with open(data_path + '/ind.cora.graph', 'rb') as f: graph = pickle.load(f, encoding='latin1') # dict: node_id -> [neighbor_ids] return features, labels, graph这里features是节点属性矩阵，每一行是一个节点的 bag-of-words 特征；labels是节点分类标签，取值为 0 到类别数减一；graph是一个字典，键是节点编号，值是该节点邻居节点编号列表。注意latin1编码是因为老版本 pickle 数据用了这个编码，你用 pandas 或者 json 加载自定义数据时不一定要带这个参数。
拿到graph字典后，边表是由所有节点的邻居对组成的。项目里用了一个非常朴素的转换：
edge_list = [] for src, neighbors in graph.items(): for dst in neighbors: edge_list.append((src, dst))这一步是全网最简单的边表构造方式，但对于理解图结构很有帮助：它直观描述了一个节点“连着谁”。Cora 的图是无向图，所以边在转换时还要补上对称边。后续根据边表构建邻接矩阵的函数我会在第 5 章单独给出，因为它也是你替换自定义数据时必须用的工具。
2.3 邻接矩阵构建：边表如何变成模型能用的矩阵
边表是逻辑上的图，邻接矩阵是数值上的图。utils/graph_ops.py里把这一步封装成了独立的函数，我把它单独摘出来重写一遍，方便你看清所有细节：
import numpy as np from scipy.sparse import coo_matrix def edges_to_adjacency_matrix(edge_list, num_nodes, self_loop=True): """ edge_list: list of (src, dst) 元组 num_nodes: 节点总数 return: numpy 数组形式的邻接矩阵 [N, N] """ adj = np.zeros((num_nodes, num_nodes), dtype=np.float32) for src, dst in edge_list: adj[src, dst] = 1.0 adj[dst, src] = 1.0 if self_loop: adj += np.eye(num_nodes, dtype=np.float32) return adj参数白话说：edge_list是原始数据给出的节点对，num_nodes是图中节点总数，self_loop控制要不要在邻接矩阵的对角线上加 1，也就是给每个节点加一个指向自己的边。在 GCN 里，加自环是必须的，不然节点自己的特征无法聚合进自身表示。dtype=np.float32是为了后续直接转torch.FloatTensor时不会发生类型不匹配。
我一般不建议用这个函数处理大规模图，因为np.zeros和 Python 循环在百万条边上会慢到怀疑人生。实际跑配套代码时，Cora 这种一万节点级别的小图完全够用。如果你要自己换大数据集，可以把循环改成向量化或直接用scipy.sparse构造。这个函数的返回值是稠密矩阵，内存占用随节点数平方增长，Cora 大约一万节点，矩阵约 100 万字节，完全能接受。
2.4 环境与依赖：跑之前先确认版本
看 requirements.txt 是我拿到任何项目的习惯。这份代码的依赖非常克制，没有强行绑一个很大的图神经网络库，这也是它能帮你理解底层的原因：
numpy>=1.19 scipy>=1.5 torch>=1.9 scikit-learn>=0.24 matplotlib>=3.3 pandas>=1.2 jupyter>=1.0 networkx>=2.6这里最大的坑是 PyTorch 版本。项目作者用的可能是 CPU 版本的 torch 1.9，如果你本机装了 torch 2.x，torch.mm这类函数行为基本一致，但有些 deprecated 接口可能报警，不影响运行。另外scipy的稀疏矩阵在更新版本里对.toarray()返回类型有变化，如果遇到报错，把稀疏矩阵显式转np.asarray(...)就能解决。
我自己的经验是，先新建一个虚拟环境，用pip install -r requirements.txt装好，再逐个跑 notebook。不要直接拿全局环境跑，因为这套代码里的utils有自定义类，跟某些库里的同名函数可能冲突。虚拟环境成本很低，但能替你把环境问题隔离掉。装依赖时如果遇到networkx版本太高导致绘图接口变化，优先降到2.6到2.8这个区间，教学代码大多在这个版本下测试过。
3. 核心实现拆解：GCN 前向传播与训练循环
图神经网络的文章越堆越多，但真正把核心讲透的始终绕不开 GCN。这个项目里第 3 章和第 4 章 notebook 是精华，前者把卷积推导完整展开，后者把模型训练跑通。我拆开读的时候发现，作者在代码里用的都是最简单直接的实现，没有一上来就上torch_geometric，这一点对理解 GNN 极其重要。这一章顺着 3.1 归一化、3.2 模型实现、3.3 训练循环、3.4 变体对比这条线往下走，把每段代码的输入输出讲清楚。
3.1 邻接矩阵归一化：这个公式是 GCN 的命根子
如果不理解归一化，后面模型训不出来你都不知道从哪查。GCN 作者提出的聚合方式是：对加了自环的邻接矩阵做对称归一化，也就是公式A_hat = D^{-1/2}(A+I)D^{-1/2}。用代码一句句看：
def symmetric_normalize_adj(adj): # adj: [N, N] 的邻接矩阵，已包含自环 N = adj.shape[0] degree = np.sum(adj, axis=1) # 计算每个节点的度 degree_inv_sqrt = np.power(degree, -0.5) degree_inv_sqrt[np.isinf(degree_inv_sqrt)] = 0.0 # 孤立节点保护 d_mat_inv_sqrt = np.diag(degree_inv_sqrt) return d_mat_inv_sqrt @ adj @ d_mat_inv_sqrt参数说明：adj是上一小节产出的带自环邻接矩阵；degree是每个节点的邻居数；degree_inv_sqrt是度的 -0.5 次方，单独变成对角矩阵d_mat_inv_sqrt后，左乘和右乘分别完成行归一化和列归一化。np.isinf的判断不能省，否则遇到孤立节点会出现除零，结果变 NaN，训练直接崩。
这个写法是裸矩阵乘法，计算复杂度是O(N^2)，理解起来最直观。工程上更大的图会改用稀疏矩阵乘法，比如scipy.sparse再转成torch.sparse，但项目里 Cora 规模不大，裸矩阵足够。你也可以对照书上的公式验证，代码和公式一一对应，数学功底浅的人也能看明白算子到底做了什么。我自己在调试时喜欢把归一化前后的矩阵打印出来，用np.sum(adj, axis=1)检查每一行是否都是 1，这一步能迅速校验归一化是否正确。
3.2 两层 GCN 的 PyTorch 实现
归一化做好之后，模型本身其实特别简单。一个 GCN 层就是先做线性变换，再做邻居聚合。这个项目里的models/gcn.py核心部分长这样：
import torch import torch.nn as nn import torch.nn.functional as F class GCNLayer(nn.Module): def __init__(self, in_features, out_features): super().__init__() self.linear = nn.Linear(in_features, out_features) def forward(self, x, adj): # x: [N, in_features] 节点特征矩阵 # adj: [N, N] 已经对称归一化过的邻接矩阵 h = self.linear(x) # 先线性变换 return torch.mm(adj, h) # 再聚合邻居 class GCN(nn.Module): def __init__(self, num_features, hidden_size, num_classes, dropout=0.5): super().__init__() self.layer1 = GCNLayer(num_features, hidden_size) self.layer2 = GCNLayer(hidden_size, num_classes) self.dropout = dropout def forward(self, x, adj): h = self.layer1(x, adj) h = F.relu(h) h = F.dropout(h, self.dropout, training=self.training) out = self.layer2(h, adj) return F.log_softmax(out, dim=1)逐段看逻辑：GCNLayer把线性变化和邻居聚合分成两步，self.linear是权重矩阵 W，torch.mm是聚合操作。这样设计的好处是和公式H^{(l+1)} = ReLU(A_hat H^{(l)} W^{(l)})严丝合缝，你随时可以拿纸笔对照。GCN是两层结构，第一层把输入维映射到隐藏维，经过 ReLU 和 Dropout，第二层再输出到类别数。torch.mm要求两个参数都是二维矩阵，所以x必须是[N, in_features]，adj必须是[N, N]，维度不匹配时错误信息也很直观。注意adj没有梯度，所以不用转成nn.Parameter；x的梯度通过linear的权重回传，聚合过程只是矩阵乘法，不额外引入参数。
还有一个关键细节：F.dropout在训练时才会随机置零，预测时要传入training=False。项目代码在train()里调用了model.train()，在评估时调用了model.eval()，如果少写这一句，测试时会发现准确率忽高忽低，这就是 Dropout 在预测时还起作用导致的。这种问题不报错，只能靠经验排查。
3.3 训练循环与精度评估
模型定义完，接下来是训练。这个项目里训练循环没有用框架自带 Trainer，而是手写的，这样对每一步的控制感更强：
import torch.optim as optim from sklearn.metrics import accuracy_score def train(model, features, adj, labels, idx_train, idx_val, epochs=200): optimizer = optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) loss_fn = nn.NLLLoss() for epoch in range(epochs): model.train() logits = model(features, adj) loss = loss_fn(logits[idx_train], labels[idx_train]) optimizer.zero_grad() loss.backward() optimizer.step() if (epoch + 1) % 20 == 0: model.eval() with torch.no_grad(): val_logits = model(features, adj) val_pred = torch.argmax(val_logits[idx_val], dim=1) acc = accuracy_score(labels[idx_val].cpu(), val_pred.cpu()) print(f"Epoch {epoch+1:3d} | loss: {loss.item():.4f} | val acc: {acc:.4f}") return model关键点在于索引idx_train和idx_val是预先划分好的节点编号数组，它们负责告诉模型哪些节点的标签用于监督、哪些节点用于验证。GCN 和普通监督学习有一个非常容易踩的认知差：模型在训练时也会用测试节点的特征参与聚合，只是不用它们的标签去算 loss。也就是说，邻居信息会跨训练/测试集流动，这是直推式学习的特点，不是 bug。
训练参数方面，学习率取了0.01，weight_decay是 L2 正则强度，NLLLoss对应模型最终的log_softmax输出。如果你的数据量更大，lr往往要往下调；如果出现 loss 震荡，优先降低lr而不是改模型结构。这套默认参数在 Cora 上能复现书里的准确率，变化一般不超过 1 个百分点。
我还想强调optimizer.zero_grad()的位置。很多新手会把zero_grad()放在loss.backward()之后，这会导致梯度和上一次的累加。PyTorch 默认累积梯度，不清零就等于每个 batch 用了一个更大的有效 batch。这个项目里的位置是正确的，你改代码时也要保持这个顺序。
3.4 对比 GraphSAGE 与 GAT：同一种骨架，三种聚合方式
配套代码里还有 GraphSAGE 和 GAT 的实现，我把它们和 GCN 放在一起对比，能明显看到演进的脉络。GCN 是全图卷积操作，每层都做一次全局矩阵乘法；GraphSAGE 改成采样邻居然后聚合，核心操作变成了torch.index_select；GAT 更激进，把邻接矩阵换成了注意力系数矩阵。实现上最直观的区别我用片段示意：
# GraphSAGE 的邻居聚合：对采样到的邻居特征取平均 neighbor_feat = neighbor_feat.mean(dim=1) # [N, hidden] # GAT 的注意力聚合：用权重系数加权求和 attention_weights = torch.softmax(score, dim=1) h = torch.bmm(attention_weights.unsqueeze(1), neighbor_feat.unsqueeze(1)).squeeze(1)这段代码想说明的是，三种模型最大的差异只是在“怎么把邻居特征合起来”这一步。GCN 是固定的归一化邻接矩阵聚合，GraphSAGE 是等权采样聚合，GAT 是学习出来的注意力权重聚合。当你读懂了 GCN 的torch.mm(adj, h)，再看后两种其实只是替换一种运算，模型的前后计算骨架完全一样。
具体来说，GraphSAGE 的前向过程比 GCN 多了一个邻居采样步骤，所以它能让每个节点的计算只依赖一个固定大小的邻居子集，适合处理超大图。GAT 则是在计算邻居权重时引入了一个可学习的score函数，这个函数通常基于两个节点特征的拼接或点积。这个项目把三种实现放同一目录，不仅展示三个模型，还暗示了一个通用架构：任何 GNN 层都可以拆成“消息构建、消息聚合、特征更新”三个阶段，你的自定义模型也能按照这个框架去组合。
4. 避坑记录：跑配套代码时最常见的 5 个坑
这部分是我自己跑的时候踩过、也在不少交流群里看到别人踩过的真实问题。每条都是“现象 -> 原因 -> 解决”的顺序，方便你按图索骥。前两条是关于数据处理的，后三条涉及训练与调参，踩中任意一个都足以让一个下午报废。
4.1 notebook 里变量被反复执行，模型参数越跑越乱套
现象：一个 notebook 从上到下按顺序执行，第二次重新运行训练单元格时，准确率变的特别诡异，而且显存占用持续上涨。
原因：GCN模型的nn.Linear在每次重新实例化前，如果之前已经执行过构造代码，新的model对象本身参数是新的，但 optimizer 如果定义在旧对象上，梯度会叠加在旧计算图上。更常见的是，adj和features在代码中被多次原地修改，导致维度错乱。这个项目很多变量是全局的，你在训练前可能多次调用了symmetric_normalize_adj，而adj又被重复归一化，数值越来越小，模型永远学不到东西。
解决：跑实验前一定先执行“重启内核”，再重新运行整个 notebook。在 Jupyter 里养成每个实验从Kernel -> Restart & Run All开始的习惯，不要人为跳过初始化单元格。我在改模型时也坚持把模型类写在.py文件里，notebook 只负责调用，这样重启成本低很多。如果你发现变量内容不确定，直接打印adj.shape和adj.min()、adj.max()检查是否在正常范围，GCN 归一化后的矩阵数值通常在 0 到 1 之间。
4.2 邻接矩阵归一化之后 loss 直接变成 NaN
现象：模型训练第一轮 loss 就是nan，之后一直 nan，甚至验证准确率也变成 nan。
原因：大概率是np.power(degree, -0.5)里没有处理度为 0 的节点。Cora 数据中确实存在孤立点，这类节点度数为 0，-0.5 次幂变成无穷，归一化后矩阵里有无穷项，梯度也随之发散。另一个原因是adj是int类型，np.diag返回的是 float 但adj参加运算后被转成 float，如果原值里有非常大的整数也可能溢出，但 Cora 里不太会出现。
解决：按前面 3.1 节那样，在计算后加一行degree_inv_sqrt[np.isinf(degree_inv_sqrt)] = 0.0。另外检查adj的 dtype 是不是float32，如果从int转过来没转类型，torch.mm会报错或者自动转成低精度，也容易出现 NaN。我一般会在归一化函数里加一句assert np.isfinite(adj).all()，直接断言整个矩阵没有非有限值。
4.3 训练损失不下降，准确率一直在基线附近
现象：模型正常执行，loss 也很小，但是验证准确率一直比随机猜测高不了多少。
原因：可能是标签和节点编号没对齐。Cora 数据的标签下标是从0还是从1开始，各个版本的预处理代码不一样。如果labels里存在-1的未标注节点，而你取labels[idx_train]时没有先做筛选，模型收到的标签错位，学不到有效信息。还有一种可能是idx_train和idx_val这两个数组在划分时用错了随机种子，导致训练集和验证集重叠严重，验证集上看到的不是真实效果。
解决：先打印labels的取值集合，确认没有-1，再用标签的索引对齐idx_train。我一般会把idx_train写成显式的布尔掩码，这样至少不会因为索引错位而静默出错。具体做法是：
train_mask = np.zeros(num_nodes, dtype=bool) train_mask[train_nodes] = True loss = loss_fn(logits[train_mask], labels[train_mask])布尔掩码的好处是，当数据顺序变动时更容易被发现，因为形状不匹配会直接报错。如果你还是想用整数索引，至少确保idx_train是从np.arange(num_nodes)里采样出来的，不要手动硬编码节点编号。
4.4 稀疏矩阵打架：scipy sparse 与 torch Tensor 不兼容
现象：用scipy.sparse读图数据之后，直接传入torch.mm报TypeError: must be real number, not csr_matrix。
原因：torch.mm只接受 torch Tensor，而scipy.sparse的csr_matrix并不是 ndarray 子类。项目数据处理链路里，作者在某一环节会调用.toarray()，但不同版本 scipy 对.toarray()的返回行为有细微差别，或者你替换自己的数据时漏掉了转换。
解决：统一在进入模型之前把邻接矩阵转成torch.FloatTensor(adj_array)。推荐做法是：
adj = torch.FloatTensor(symmetric_normalize_adj(adj_np))如果需要稀疏计算，用torch.sparse.FloatTensor(adj_coo)，但配套代码场景下，稠密化就能完成任务，先把它跑通再说。有一个细节：torch.sparse的矩阵乘法要求两个操作数都 sparse，混合使用会报错，所以不要尝试用稠密矩阵去乘 sparse 矩阵。项目里没做稀疏优化，你也别在这里浪费太多时间，教学代码优先保正确性。
4.5 用 CPU 跑 GraphSAGE 慢到怀疑人生
现象：GCN 几十秒跑完一个 epoch，GraphSAGE 的 notebook 却要几分钟，而且还是在只有一个隐藏层的情况下。
原因：GraphSAGE 的邻居采样阶段在纯 Python 循环里对每个节点做random.choice，然后还要做矩阵索引。这种实现是为了讲清楚原理，并没有做 batch 采样优化。在小数据集上都能感觉到慢，是因为 Python 的for循环开销占比很大。Cora 才一万多节点，GraphSAGE 每层都采样 25 个邻居，总采样次数达到几十万次，纯循环自然慢。
解决：如果只是验证模型，把采样邻居数调小，比如num_neighbors = 5而不是 25。或者直接把训练循环改成矩阵并行采样：一次性用np.random.choice为所有节点生成邻居矩阵，然后批量索引。这个坑也提醒我：教学代码默认优先可读性，你拿它做性能实验前要先重写热点函数。另外，如果你的电脑有 GPU，把features和adj调成 CUDA Tensor，训练循环里的矩阵乘法会快一个数量级，但 GraphSAGE 的采样循环依然是瓶颈，所以优先改采样逻辑。
5. 二次开发：把 GCN 换成你自己的数据集和模型
这套配套代码最大的优势在于它没有绑定任何重库，所以替换数据和修改模型都相对容易。我自己做实验时最常用的动作，就是把data换成一组自定义边表，然后重新训练看效果。这一章只讲两个操作：换数据和改模型，同时给一套验证流程，保证你改完不会偏离正确方向。
5.1 从任意边表构建图数据
假设你手上只有一份 CSV 格式的边表，用 pandas 读进来就能复用前面说的edges_to_adjacency_matrix：
import pandas as pd def load_edges_from_csv(csv_path, num_nodes): edges_df = pd.read_csv(csv_path) edge_list = list(zip(edges_df["src"], edges_df["dst"])) adj = edges_to_adjacency_matrix(edge_list, num_nodes, self_loop=True) features = np.eye(num_nodes) # 没有节点特征时用单位向量 return adj, featuresnum_nodes从哪来？可以从边的最大编号加 1 得到，也可以用adj.shape反向推断。单位矩阵作为特征是一种通用 fallback 方案，意思是只用 one-hot 编码节点身份，让模型自己学嵌入。如果你的数据有额外属性，例如论文的关键词向量，拼在features的列维度上即可。要注意 CSV 里边的节点编号必须连续，否则矩阵存储会出现“空洞”，处理方式有两种：一是先做节点重映射，二是用稀疏矩阵记录编号不连续的数据。对于小图，直接重映射最省心。
5.2 修改模型：加深、加 Dropout、换激活函数
最常见的改造是加一层 GCN。在GCN里再插入一个GCNLayer很容易，但要注意隐藏层尺寸的连接、跳连、残差这些设计。我给一个带残差的加深度版本片段：
class DeepGCN(nn.Module): def __init__(self, num_features, hidden_size, num_classes): super().__init__() self.layer1 = GCNLayer(num_features, hidden_size) self.layer2 = GCNLayer(hidden_size, hidden_size) self.layer3 = GCNLayer(hidden_size, num_classes) def forward(self, x, adj): h1 = F.relu(self.layer1(x, adj)) h2 = F.relu(self.layer2(h1, adj)) # 残差：把第一层结果加到第二层输出上 out = self.layer3(h2 + h1, adj) return F.log_softmax(out, dim=1)注意残差连接不是越多越好，GCN 层数超过两层时，重复聚合会使所有节点表示趋于平滑，效果反而下降。我一般最多加到三层，并使用h2 + h1这种简单加法，避免过深。若要换激活函数，把F.relu换成F.elu或F.gelu即可。如果你想加 Dropout，在每层输出后加F.dropout，并把dropout值从 0.5 调到 0.2 试试小图。调参的核心原则是：控制变量，每次只改一个超参。
5.3 验证方法：和你自己的 baseline 对齐
改造后如何验证？我的做法是先在原数据集上复现 GCN 的准确率，再换上自己的边表跑一遍。具体流程是：
- 划分训练/验证/测试节点，用固定随机种子保证可复现；
- 训练后记录 loss 曲线和验证集准确率，看是否收敛；
- 最后用自己的模型和 GCN 原始精度做对比，差距在合理范围才算改成功。
这步想做好，建议在每个 epoch 记录结果，画一张 loss 曲线图。如果 loss 震荡明显，优先调学习率；如果验证准确率低于 GCN 百分之五以上，先怀疑数据和标签是否对齐，再看模型有没有写错。不要一上来就加正则，先把最简单链路跑通。我通常会在训练前打一行日志：
print("Feature shape:", features.shape) print("Adj shape:", adj.shape) print("Label values:", set(labels.tolist()))这行日志能在五分钟内定位八成的问题。从那以后我拿到任何 GNN 项目，都会强制自己先按“目录 -> 数据流 -> 核心模块 -> 踩过的坑”这个顺序过一遍，再动手改代码。这套配套代码帮我省下的调试时间，远不止归一化和稀疏矩阵那几道坎。希望这篇拆解里的踩坑记录能帮你少走两步弯路。
本文还有配套的精品资源，点击获取
