DGL VRGCN 控制变量采样实战:GraphSAGE 大图训练从单卡到多卡

原创2026-09-22 22:31:411,680 阅读
文章标签:深度学习机器学习人工智能图计算分布式训练高性能计算数据科学

DGL VRGCN 控制变量采样实战:GraphSAGE 大图训练从单卡到多卡

本篇文章基于 DGL 官方仓库中的 VRGCN(control variate sampling)示例,系统讲解如何通过"控制变量 + 历史特征"技术,在超大图上以小批量邻居采样方式训练 GraphSAGE 模型。你将掌握 DGL 中 sample_neighbors 与 in_subgraph 组合出的双路采样流程、history 特征的生命周期管理、单卡训练脚本 train_cv.py 的完整实现,以及基于 torch.multiprocessing 与 DistributedDataParallel 的多卡版本 train_cv_multi_gpu.py 的并行改造要点,可直接迁移到其他大图节点分类任务。

一、为什么需要 VRGCN:邻居采样的方差困境

在 Reddit 这类社交网络图上,节点的平均度数高达数百,如果像普通 GraphSAGE 那样在每个批次都聚合"全量邻居",训练会迅速陷入计算与内存爆炸。为此 DGL 提供了多种邻居采样方案,其中 NeighborSampler 示例 采用"每层固定采样 k 个邻居"的方式控制计算量,但采样带来的随机性会放大梯度的方差,模型需要更多迭代才能收敛。

VRGCN 示例采取的思路来自一篇关于图卷积网络方差缩减的论文(README 中标注的参考论文),其核心思想在示例源码中体现为两点:

  1. 维护一份"历史特征"(history):为图中每个节点缓存每一层上一次计算出的表示,即 hist_1, hist_2, ...,作为全邻居聚合结果的无偏估计量(控制变量);
  2. 训练时只采样少量邻居:计算"当前特征与历史特征之差(delta)"在采样子图上的邻居均值,再与"预先在全体邻居上聚合好的历史均值"相加,从而以小采样量逼近全邻居聚合。

用 h_neigh = agg_hbar + hdelta_new 这一行即可概括:历史邻居聚合(全量,但廉价)+ 采样邻居上的增量修正(小量,但精确)。这份 history 每个批次结束后都会用最新的表示原地更新,因此偏差会随训练推进不断缩小。

二、示例全景:文件构成与启动方式

该示例位于仓库的 examples/pytorch/vrgcn 目录,共三个文件:

文件 作用
README.md 示例说明与运行命令
train_cv.py 单 GPU 训练脚本
train_cv_multi_gpu.py 多 GPU 训练脚本

按 README 给出的方式直接运行:

# 单卡训练
python3 train_cv.py --num-epochs 30

# 多卡训练(4 张 GPU)
python3 train_cv_multi_gpu.py --num-epochs 30 --gpu 0,1,2,3

两个脚本均使用 DGL 内置的 RedditDataset(带自环版本),其数据统计如下(来自 python/dgl/data/reddit.py 的类文档):

  • 节点数:232,965
  • 边数:114,615,892
  • 节点特征维度:602
  • 训练 / 验证 / 测试样本:153,431 / 23,831 / 55,703

也就是说,这是一个平均度数约 492 的超大图,恰好是验证 CV 采样技术的典型场景。脚本在加载数据后会调用 g.create_formats_()(train_cv.py)预构建 CSR/COO/CSC 格式,避免训练过程中反复触发格式转换。

三、单卡实现深度解析:train_cv.py

3.1 带控制变量的卷积层 SAGEConvWithCV

模型不是直接复用 dgl.nn.SAGEConv,而是自定义了 SAGEConvWithCV。它内部只有一个 nn.Linear(in_feats * 2, out_feats) 线性层,把"目标节点自身表示"与"邻居聚合表示"拼接后变换输出,并用 Xavier 初始化 + ReLU 激活(最后一层无激活)。

关键在于 forward 的训练 / 推理双分支:

def forward(self, block, H, HBar=None):
    if self.training:
        with block.local_scope():
            H_src, H_dst = H
            HBar_src, agg_HBar_dst = HBar
            block.dstdata["agg_hbar"] = agg_HBar_dst
            block.srcdata["hdelta"] = H_src - HBar_src
            block.update_all(fn.copy_u("hdelta", "m"), fn.mean("m", "hdelta_new"))
            h_neigh = block.dstdata["agg_hbar"] + block.dstdata["hdelta_new"]
            h = self.W(th.cat([H_dst, h_neigh], 1))
            ...
    else:
        # 推理分支:直接聚合 H_src,不做任何控制变量修正
        block.srcdata["h"] = H_src
        block.update_all(fn.copy_u("h", "m"), fn.mean("m", "h_new"))
        h_neigh = block.dstdata["h_new"]
        h = self.W(th.cat([H_dst, h_neigh], 1))
        ...

训练分支的数学含义可以拆解为:

  1. 把每个源节点当前的表示 H_src 与其历史表示 HBar_src 相减,得到增量 hdelta;
  2. 通过 fn.copy_u + fn.mean 在采样出的 block 上做一次消息传递,得到增量的邻居均值 hdelta_new;
  3. 将其与外部预先算好的"全邻居历史聚合" agg_hbar 相加,得到最终的邻居表示 h_neigh;
  4. 与目标节点自身表示 H_dst 拼接后过线性层。

推理分支则退化为标准的全邻居聚合——因为推理时不追求方差缩减,直接用真实邻居均值即可(推理逻辑见 SAGE.inference)。

3.2 多层模型 SAGE:块到块的表示传递

SAGE 用 nn.ModuleList 堆叠多层 SAGEConvWithCV,输入维度依次为 in_feats → n_hidden → … → n_classes。

forward 接收 DGL 采样得到的多层 block 列表,逐层推进:

def forward(self, blocks):
    h = blocks[0].srcdata["features"]
    for layer, block in zip(self.layers, blocks):
        h_dst = h[: block.number_of_dst_nodes()]      # LHS 表示 → RHS 目标节点
        hbar_src = block.srcdata["hist"]
        agg_hbar_dst = block.dstdata["agg_hist"]
        h = layer(block, (h, h_dst), (hbar_src, agg_hbar_dst))
        block.dstdata["h_new"] = h
    return h

这里 h_dst = h[: block.number_of_dst_nodes()] 利用了 DGL block 的约定:block 的 LHS(源端)节点排列在张量前部、RHS(目标端)节点紧随其后,因此截取前 number_of_dst_nodes() 行即可取出与 RHS 对应的表示。每层计算完毕后,把新表示 h_new 写回 block.dstdata,供训练循环更新 history 使用。

inference 方法则采取"逐层全量计算、按 batch 分批"的策略(train_cv.py):对每一层,用 dgl.to_block(dgl.in_subgraph(g, batch_nodes), batch_nodes) 构造包含目标节点全部入边的 block,分批算出该层所有节点的表示并写回,再作为下一层输入。这样做避免了多层 block 逐层采样时前几层大量重复计算的问题。

3.3 双路采样器 NeighborSampler:采样块 + 历史块

NeighborSampler 是 CV 训练的核心组件,每个采样步骤同时产出两套 block:

def sample_blocks(self, seeds):
    seeds = th.LongTensor(seeds)
    blocks, hist_blocks = [], []
    for fanout in self.fanouts:
        # 第一路:随机采样 fanout 个邻居(用于增量修正)
        frontier = dgl.sampling.sample_neighbors(self.g, seeds, fanout)
        # 第二路:取全部入边(用于全量聚合历史特征)
        hist_frontier = dgl.in_subgraph(self.g, seeds)
        block = dgl.to_block(frontier, seeds)
        hist_block = dgl.to_block(hist_frontier, seeds)
        seeds = block.srcdata[dgl.NID]   # 下一层的种子节点
        blocks.insert(0, block)
        hist_blocks.insert(0, hist_block)
    return blocks, hist_blocks

逐层处理要点:

  • 采样块(block):通过 dgl.sampling.sample_neighbors(见 python/dgl/sampling/neighbor.py)为每个种子节点随机抽取 fanout 个入邻居,随后 dgl.to_block(见 python/dgl/transforms/to_block.py)将其压缩为用于消息传递的二部图;
  • 历史块(hist_block):通过 dgl.in_subgraph(见 python/dgl/subgraph.py)取出种子节点的全部入边,同样压缩为 block。后续会在该块上对历史特征做一次全邻居 mean 聚合,得到 agg_hist;
  • 下一层种子节点取当前 block 的源端节点 ID,且 block 列表使用 insert(0, ...) 逆序存放,保证与 SAGE.forward 中"第一层在最前"的遍历顺序一致。

fanout 由命令行参数 --fan-out 提供,默认 "1,1",即每层每节点只采样 1 个邻居——配合 CV 机制,能以极小的采样量维持稳定收敛。

3.4 数据搬运与历史聚合:load_subtensor

load_subtensor 负责把图上节点的特征、标签和历史特征搬运到 GPU,并在历史块上完成聚合:

for i, (block, hist_block) in enumerate(zip(blocks, hist_blocks)):
    hist_col = "features" if i == 0 else "hist_%d" % i
    block.srcdata["hist"] = g.ndata[hist_col][block.srcdata[dgl.NID]]
    hist_block.srcdata["hist"] = g.ndata[hist_col][hist_block.srcdata[dgl.NID]]
    if aggregation_on_device:
        hist_block = hist_block.to(dev_id)
    hist_block.update_all(fn.copy_u("hist", "m"), fn.mean("m", "agg_hist"))
    block = block.int().to(dev_id)
    block.dstdata["agg_hist"] = hist_block.dstdata["agg_hist"]

注意第 0 层的历史列名是 "features"(即原始输入特征本身就充当第一层的历史),之后各层对应 hist_1, hist_2, ...。历史聚合可在 CPU(aggregation_on_device=False)或 GPU 上完成,训练时脚本传入 True 以利用 GPU 加速聚合。

3.5 历史特征的初始化与更新

  • init_history:训练开始前用 model.inference 在全图上跑一遍,把各层的全量表示写入 g.ndata["hist_i"],作为历史特征的初始值;
  • update_history:每个 batch 前向结束后,在 no_grad 下把 block.dstdata["h_new"] 按原始节点 ID 回写到 g.ndata["hist_i"],实现历史特征的滚动更新。

整体训练循环见 run:每个 batch 依次执行采样(DataLoader 的 collate_fn 调用采样器)→ load_subtensor 搬运与历史聚合 → 模型前向 → update_history 更新历史 → 计算交叉熵损失 → 反向传播 → Adam 优化。脚本会打印 Loss、Train Acc、吞吐(samples/sec)与 Epoch Time,并在每个 --eval-every 个 epoch 用验证集评估一次。

3.6 命令行参数总览

两个脚本暴露的参数完全一致(见 train_cv.py 与 train_cv_multi_gpu.py):

参数 默认值 说明
--gpu "0" 使用的 GPU 设备;多卡脚本中可传逗号分隔的列表,如 0,1,2,3
--num-epochs 20 训练轮数(README 示例用 30)
--num-hidden 16 隐藏层维度
--num-layers 2 模型层数
--fan-out "1,1" 每层每个节点采样的邻居数,逗号分隔
--batch-size 1000 每个 batch 的种子节点数
--val-batch-size 1000 验证阶段每批处理的节点数
--log-every 20 每多少步打印一次训练日志
--eval-every 5 每多少轮在验证集上评估一次
--lr 0.003 Adam 学习率
--num-workers-per-gpu 0 每张 GPU 对应的 DataLoader 子进程数

其中 --fan-out 是 CV 训练最敏感的参数:它直接控制每层采样量,与 history 机制共同决定梯度方差与每步开销的平衡。

四、多卡训练深度解析:train_cv_multi_gpu.py

多卡版本在单卡逻辑之上做了四处关键改造:

4.1 进程与数据并行

主入口(train_cv_multi_gpu.py)先把 --gpu 拆成设备列表,若多于一张卡则用 torch.multiprocessing 的 mp.spawn 为每张卡启动一个训练进程;每个进程内通过 DistributedDataParallel 包装模型,并用 th.distributed.init_process_group(backend="nccl", ...)(默认 tcp://127.0.0.1:12345)初始化进程组。

if n_gpus > 1:
    model = DistributedDataParallel(model, device_ids=[dev_id], output_device=dev_id)
...
else:
    run(0, n_gpus, args, devices, data)          # 单卡直接运行
    # mp.spawn(run, args=(n_gpus, args, devices, data), nprocs=n_gpus)  # 多卡

4.2 数据并行采样

多卡下 DataLoader 改用 th.utils.data.distributed.DistributedSampler(train_cv_multi_gpu.py),使每张卡在每个 epoch 拿到互不重叠的训练节点分片,并在每个 epoch 开始时调用 dist_sampler.set_epoch(epoch) 重新打乱,保证数据分布公平。

4.3 共享内存历史存储

history 张量必须能被多个进程同时读写,因此多卡脚本新增了 create_history_storage:用 th.zeros(g.num_nodes(), dim).share_memory_() 为每一层创建共享内存张量;同理,输入特征也通过 features.share_memory_()(train_cv_multi_gpu.py)放入共享内存。在启动子进程之前就调用 g.create_formats_() 预建图格式,避免每个子进程各自重复构建格式造成内存与 CPU 浪费。

4.4 初始化与日志的去重控制

  • 历史初始化只在 proc_id == 0 的进程执行,随后 th.distributed.barrier() 同步,确保所有进程拿到一致的历史后再开始训练(train_cv_multi_gpu.py);
  • 训练循环中 if proc_id == 0 才打印日志、计时、计算吞吐(吞吐按 len(seeds) * n_gpus 折算总吞吐)并在验证集上评估,其余进程只参与计算;
  • 每个 epoch 结束和进程退出前都有 barrier() 同步,保证收敛步调一致。

由于 DistributedSampler 已按分片分配节点,每张卡的 update_history 只更新自己分到的那批节点的历史,而其他节点保持共享内存中的旧值——这与 CV 方法"历史值可滞后、随训练逐步逼近真实值"的特性完全兼容,也是该设计能在多卡下成立的根基。

五、与底层 DGL API 的对应关系

为了把示例读得更透,可以对照以下源码位置印证每个关键调用:

示例中的调用 底层实现位置 说明
dgl.sampling.sample_neighbors python/dgl/sampling/neighbor.py 按 fanout 对种子节点采样入邻居,支持 edge_dir、prob、replace 等参数
dgl.to_block python/dgl/transforms/to_block.py 把任意图转换为"源节点 + 目标节点"的二部块,供分层消息传递使用
dgl.in_subgraph python/dgl/subgraph.py 取指定节点全部入边诱导出的子图,CV 示例用它构造历史聚合所需的"全邻居"块
RedditDataset python/dgl/data/reddit.py DGL 内置数据集,提供 feat、label、train_mask/val_mask/test_mask 与 num_classes

从这些实现可以看出,CV 训练并未引入任何专用算子,完全建立在 DGL 通用采样与消息传递原语之上:sample_neighbors 负责降采样、in_subgraph 负责全量历史聚合、to_block 统一两者为块结构。这也意味着你可以在任意 DGL 图上复刻这套方案,只需替换数据集并保证 g.ndata 中具备 features、label 与划分掩码。

六、从示例迁移到自有数据的实践要点

  1. 数据适配:脚本固定读取 g.ndata<a href="https://link.gitcode.com/i/c7048260cda4695dc1c8a3c3caff091c" target="_blank">"features"]、g.ndata["label"]、g.ndata["train_mask"]、g.ndata["val_mask"],换成自己的图时需保证这些键存在,并像示例那样把原始 feat 复制为 features 供历史机制复用([train_cv.py);
  2. 调参顺序:先保持默认 --fan-out "1,1" 跑通流程,再根据收敛曲线逐步增大 fan-out 或调低学习率;--batch-size 与 --num-workers-per-gpu 影响数据装载吞吐,可按 GPU 显存与 CPU 核数放宽;
  3. 历史存储规模:history 本质上是"节点数 × 隐藏维度"的全量缓存,多卡场景下必须使用共享内存张量(share_memory_()),否则子进程间无法共享更新结果;
  4. 单卡先行:多卡脚本在 n_gpus == 1 时同样可以运行(走 run(0, n_gpus, ...) 分支),建议先用单卡验证模型正确性,再扩展到多卡排查分布式问题;
  5. 验证流程:验证使用全邻居的 inference,因此 --val-batch-size 只影响评估时的分批粒度,不影响精度,可按显存放宽以加快评估。

通过本文的拆解可以看到,DGL 的 VRGCN 示例虽然 README 只有两行命令,但其背后的"采样块 + 历史块"双路采样、增量修正聚合、共享内存历史更新这套完整机制,正是处理千万级边大图训练的高效范式,值得作为深入理解 DGL 采样体系与分布式训练改造的起点。

登录后查看全文
dgl