重磅好文透彻理解,异构图上 Node 分类理论与DGL源码实战
书接上文，关注过作者历史文章的读者都知道，图上机器学习/深度学习系列文章 从 一文揭开图机器学习的面纱，你确定不来看看吗 开始，已经陆续和大家一起了解了 同构图上的链接预测、节点分类与回归、边分类与回归 等机器学习任务，不熟悉的同学可以去作者的历史文章里查找哦。
如上所说，以前介绍 图上机器学习任务 的文章， 均是在 同构图 上进行的，忽略了图上不同节点以及不同边的独特性质，而是把所有节点当作一种节点来看待的。这个虽然可以解决一部分问题，但是该关系建模能力也不足以覆盖现实世界 中复杂多变的多种关系，所以就轮到我们的 异构图关系建模 文章出马了。
针对 异构图 上关系的建模，因为其 工程实现的复杂性 ，目前的学术界和工业界均存在一定的 实现难度 。我知道的甚至很多图深度学习框架在最新的版本里还 不支持 对异构图的建模。好在亚马逊的DGL框架在最新的几个版本中，已经更新了对异构图的工程实现，下面就让我们结合DGL的实现源码来一起了解下 异构图上节点分类/回归任务 吧 ～ go go go !!!
注意：我们的文章里，把分类回归任务一起囊括了因为这来那个任务除了 输入和损失不同 以外，网络结构并没有别的不同，分类回归任务彼此修改互用也比较容易，这里就不再进行区分了。本文说是节点分类任务，但是其实回归任务也差不太多。
(1) 异构图节点分类任务理论基础
按照惯例，我们还是先从基础定义引出下文的话题。
在以前的文章 一文揭开图机器学习的面纱，你确定不来看看吗 中，我们说图的分类的时候说到了异构图，文中说：图中节点类型和边类型超过两种的图称为异构图。这意思就是说异构图中的节点和同2个节点的边可能有多种，例如：图中包括用户，商品，IP三种类型的节点，其中用户和商品之间又有加购物车与购买这两种关系的边。本文所说的图就是这种类型的 比较复杂 的图。
从 同构图推广 来看，既然在异构图中区分了 节点和边 的不同类型，那我们在处理根据 异构图的局部与全局结构特性 对某个节点进行 定性分析 或则 进行两个节点之间 关系预测 的时候，就需要从 更细粒度 上去对不同的节点和边的关系进行 区分 。既然2个节点的某一种关系决定了一种类型的边，一种比较好的方式是： 根据关系(边)类型去组织不同类型的节点 ，然后进行异构图卷积操作，得到对各个类型的节点的 Embeding，在基于此最终完成 异构图上的机器学习任务 ，就像DGL官方源码实现的那样。
所谓 异构图卷积，顾名思义： 就是对 各种边的关系各自分别进行卷积 ，然后将这些关系对应的各种类型的同类型节点进行融合，默认是Sum , 得到各种同类型节点的Embeding, 注意这里每种类型节点只有一个Embeding。 对于 节点分类 任务，最后在异构图卷积层结束的时候，可以直接接激活函数，然后分别对每种类型的节点计算出一个Logit, 和有监督的某种类型的 label 计算损失进行回传即可。感兴趣的同学，可以看 DGL实现的RGCB节点分类任务的源码验证明晰 以上所说的逻辑。
这里需要特别强调注意 的是： 在异构图RGCN采样的时候，采样了几层邻居节点，异构图卷积层就有几层异构卷积layer, 分别有每个异构卷积layer去处理每一层的邻居节点。
因为采样是由内向外采样的，而聚合是由外向内聚合的。这里要引入DGL实现采样得到的Block的概念，通俗理解 Block其实就是采样得到的子图，而这些子图里的边也有对应这开始节点和结束节点以及边类型等和 全Graph同等 的一些属性 。
我们可以这样理解 ：DGL实现的Block可以把看作一个数组，数组里的每一个元素是图上一层邻居的采样，Block内部节点是 从远到近的顺序排列内部的Block的，Block数组的下标从小到大对应着采样范围由外到内、覆盖范围由远及近，并且 blocks[i+1]的 source node 和 blocks[i]的target node是可以对应上的。我们知道邻居节点采样其实是按照边的关系去采来确认邻居的，所以在DGL的采样过程中，让 blocks[0]的 src node 包含了 blocks[0]的所有dst node，并且dst 节点出现在src 节点序列的前面若干位置 。
所以我们在代码实现的时候，将 外层对应节点的Embeding作为内层节点的输入，构成两个互相挨着的卷积层 ，这里采样与工程实现是 完美互相契合 的。有疑问的同学，可以去看源码验证哦 ～
好吧，整体对异构图的节点分类任务 抽象 一下： 既然我们要对异构图上某节点进行分类，那我们就需要综合异构图上该节点邻居节点的信息，得出所求节点的Embeding 信息。 而该节点周围有多种类别关系的节点，则我们就对各个关系分别进行卷积，求得各个关系里面各个节点的Embeding, 然后将多种关系涵盖的多类同类节点 Embeding进行聚合，后面可以接全链接层，也可以不接全链接层直接接激活函数，得到各个节点类型的结果作为输出。对于异构图，最终 节点分类任务的 Logit 也是 按照节点类别的个数有多个 。
当然针对异构图，我们可以采用 GraphSage还是HAN ？吐血力作综述Graph Embeding 经典好文 文章后半部分里介绍的，使用 MetaPath 结合 Attention 进行 Node 节点级别 与 path语义级别的融合，类似于 HAN 的处理方式。但是 万丈高楼平地起 ，写代码和写文章，也得慢慢来一点一点儿实现不是～
异构图RGCN节点分类任务 整体的流程解析就到这里吧，感觉这个地方，还是得看源码才能说清楚。因为整个源码流程比较长，也为了让最后整个代码demo能够完美的运行起来，本篇文章的代码将从 讲述一个工程的实现 开始。
所以，本文 就让我们一起实现 基于DGL和异构图的RGCN来进行节点分类回归任务 。下面就让我们开始 coding 吧 ～
(2) 代码时光
开篇先吼一嗓子 ， talk is cheap , show me the code !!!
本文的代码讲的是 基于DGL和RGCN实现的异构图上节点分类任务，整个源码流程是一个 小型的工业可用的工程，基于dgl实现，觉得有用赶紧收藏转发吧～
life is short , i use python !!!
(2.1) 数据准备
我们假设可以输入类似于这样的数据, 其中每2列对应这一种关系，例如 用户2352193 购买了商品CEEC9EBF7，用户用了IP 174.74.201.9登录了账号，用户用IP 174.74.201.9 购买了商品 CEEC9EBF7, label 表示着该用户真的购买商品，最终的节点分类任务是预测用户的购买意愿，是否是我们的高意图潜在用户，二分类。
我们可以把这样一份数据存入 source_data.csv 文件中，用 pandas 接口把数据读入：
raw_pdf = pd.read_csv('./source_data.csv')
因为对于 异构图 模型，节点和边的类型均有多种，为了处理方便，我们可以把各种类型的节点进行编码，再到后期对其进行解码，对 pandas 的 dataframe 数据结构的编解码，我们可以使用下面的代码：
@ 欢迎关注微信公众号：算法全栈之路 #编码方法 def encode_map(input_array): p_map={} length=len(input_array) for index, ele in zip(range(length),input_array): # print(ele,index) p_map[str(ele)] = index return p_map #解码方法 def decode_map(encode_map): de_map={} for k,v in encode_map.items(): # index,ele de_map[v]=k return de_map
然后用其中的各列node 进行 编码
@ 欢迎关注微信公众号：算法全栈之路 userid_encode_map=encode_map(set(graph_features_pdf['user_id'].values)) # 解码map userid_decode_map=decode_map(userid_encode_map) graph_features_pdf['user_id_encoded'] = graph_features_pdf['user_id'].apply(lambda e: userid_encode_map.get(str(e),-1)) # print unique值的个数 userid_count=len(set(graph_features_pdf['user_id_encoded'].values)) print(userid_count)
这里仅仅以 用户节点编码 为例，itemId和 IP同理编解码即可。
最后我们可以把图数据保存，供以后的异构图代码 demo使用。
@ 欢迎关注微信公众号：算法全栈之路 final_graph_pdf=graph_features_pdf[['user_id_encoded','ip_encoded','item_id_encoded','label']].sort_values(by='user_id_encoded', ascending=True) final_graph_pdf.to_csv('result_label.csv',index=False)
基于此，异构图的基础准备数据就结束了，下面开始正式的coding了。
（2.2） 导包
老规矩，先导包，基于DGL和RGCN实现的异构图上节点分类任务只需要这些包就可以了。
@ 欢迎关注微信公众号：算法全栈之路 import argparse import torch import torch.nn as nn import dgl import torch.optim as optim from dgl.dataloading import MultiLayerFullNeighborSampler, EdgeDataLoader from dgl.dataloading.negative_sampler import Uniform import numpy as np import pandas as pd import itertools import os import tqdm from dgl import save_graphs, load_graphs import dgl.function as fn import torch import dgl import torch.nn.functional as F from dgl.nn.pytorch import GraphConv, SAGEConv, HeteroGraphConv from dgl.utils import expand_as_pair import tqdm from collections import defaultdict import torch as th import dgl.nn as dglnn from dgl.data.utils import makedirs, save_info, load_info from sklearn.metrics import roc_auc_score import gc gc.collect()
推荐一个工具，tqdm 很好用 哦，结合 dataloading接口 ， 可以看到模型训练以及数据处理执行的进度，赶紧用起来吧～
这里的 sklearn 工具 的导入，仅仅是为了调用他来进行分类模型的离线指标评估，得到AUC等指标而已。
各种模型工具无所谓分类，能解决问题的就是好工具，混用又有何不可呢？ 实用就行！
（2.3） 构图
数据有了，接下来就是构图了，我们构建的是包含 三种节点的异构图 。
@ 欢迎关注微信公众号：算法全栈之路 # user 登录 ip u_e_ip_src = final_graph_pdf['user_id_encoded'].values u_e_ip_dst = final_graph_pdf['ip_encoded'].values # user 购买 item u_e_item_src = final_graph_pdf['user_id_encoded'].values u_e_item_dst = final_graph_pdf['item_id_encoded'].values # item和ip 共同出现 ip_e_item_src = final_graph_pdf['ip_encoded'].values ip_e_item_dst = final_graph_pdf['item_id_encoded'].values # user 购买 label user_node_buy_label = final_graph_pdf['label'].values hetero_graph = dgl.heterograph({ ('user', 'u_e_ip', 'ip'): (u_e_ip_src, u_e_ip_dst), ('ip', 'u_eby_ip', 'user'): (u_e_ip_dst, u_e_ip_src), ('user', 'u_e_item', 'item'): (u_e_item_src, u_e_item_dst), ('item', 'u_eby_item', 'user'): (u_e_item_dst, u_e_item_src), ('ip', 'ip_e_item', 'item'): (ip_e_item_src, ip_e_item_dst), ('item', 'item_eby_ip', 'ip'): (ip_e_item_dst, ip_e_item_src) }) # 给 user node 添加标签 hetero_graph.nodes['user'].data['label'] = torch.tensor(user_node_buy_label) print(hetero_graph)
这里的 异构图是 无向图 ，因为无向，所以双向。 构图的时候就需要构建 双向的边。 代码很好理解，就不再赘述了哈。
（2.4） 模型的自定义函数
这里定义了 异构图上RGCN 会用到的模型的一系列自定义函数，综合看代码注释，结合上文第一小节的抽象理解，希望能理解的更加深入哦。
@ 欢迎关注微信公众号：算法全栈之路 class RelGraphConvLayer(nn.Module): def __init__(self, in_feat, out_feat, rel_names, num_bases, *, weight=True, bias=True, activation=None, self_loop=False, dropout=0.0): super(RelGraphConvLayer, self).__init__() self.in_feat = in_feat self.out_feat = out_feat self.rel_names = rel_names self.num_bases = num_bases self.bias = bias self.activation = activation self.self_loop = self_loop # 这个地方只是起到计算的作用, 不保存数据 self.conv = HeteroGraphConv({ # graph conv 里面有模型参数weight,如果外边不传进去的话,里面新建 # 相当于模型加了一层全链接, 对每一种类型的边计算卷积 rel: GraphConv(in_feat, out_feat, norm='right', weight=False, bias=False) for rel in rel_names }) self.use_weight = weight self.use_basis = num_bases < len(self.rel_names) and weight if self.use_weight: if self.use_basis: self.basis = dglnn.WeightBasis((in_feat, out_feat), num_bases, len(self.rel_names)) else: # 每个关系,又一个weight,全连接层 self.weight = nn.Parameter(th.Tensor(len(self.rel_names), in_feat, out_feat)) nn.init.xavier_uniform_(self.weight, gain=nn.init.calculate_gain('relu')) # bias if bias: self.h_bias = nn.Parameter(th.Tensor(out_feat)) nn.init.zeros_(self.h_bias) # weight for self loop if self.self_loop: self.loop_weight = nn.Parameter(th.Tensor(in_feat, out_feat)) nn.init.xavier_uniform_(self.loop_weight, gain=nn.init.calculate_gain('relu')) self.dropout = nn.Dropout(dropout) def forward(self, g, inputs): g = g.local_var() if self.use_weight: weight = self.basis() if self.use_basis else self.weight # 这每个关系对应一个权重矩阵对应输入维度和输出维度 wdict = {self.rel_names[i]: {'weight': w.squeeze(0)} for i, w in enumerate(th.split(weight, 1, dim=0))} else: wdict = {} if g.is_block: inputs_src = inputs inputs_dst = {k: v[:g.number_of_dst_nodes(k)] for k, v in inputs.items()} else: inputs_src = inputs_dst = inputs # 多类型的边结点卷积完成后的输出 # 输入的是blocks 和 embeding hs = self.conv(g, inputs, mod_kwargs=wdict) def _apply(ntype, h): if self.self_loop: h = h + th.matmul(inputs_dst[ntype], self.loop_weight) if self.bias: h = h + self.h_bias if self.activation: h = self.activation(h) return self.dropout(h) # return {ntype: _apply(ntype, h) for ntype, h in hs.items()} class RelGraphEmbed(nn.Module): r"""Embedding layer for featureless heterograph.""" def __init__(self, g, embed_size, embed_name='embed', activation=None, dropout=0.0): super(RelGraphEmbed, self).__init__() self.g = g self.embed_size = embed_size self.embed_name = embed_name self.activation = activation self.dropout = nn.Dropout(dropout) # create weight embeddings for each node for each relation self.embeds = nn.ParameterDict() for ntype in g.ntypes: embed = nn.Parameter(torch.Tensor(g.number_of_nodes(ntype), self.embed_size)) nn.init.xavier_uniform_(embed, gain=nn.init.calculate_gain('relu')) self.embeds[ntype] = embed def forward(self, block=None): return self.embeds class EntityClassify(nn.Module): def __init__(self, g, h_dim, out_dim, num_bases=-1, num_hidden_layers=1, dropout=0, use_self_loop=False): super(EntityClassify, self).__init__() self.g = g self.h_dim = h_dim self.out_dim = out_dim self.rel_names = list(set(g.etypes)) self.rel_names.sort() if num_bases < 0 or num_bases > len(self.rel_names): self.num_bases = len(self.rel_names) else: self.num_bases = num_bases self.num_hidden_layers = num_hidden_layers self.dropout = dropout self.use_self_loop = use_self_loop self.embed_layer = RelGraphEmbed(g, self.h_dim) self.layers = nn.ModuleList() # i2h self.layers.append(RelGraphConvLayer( self.h_dim, self.h_dim, self.rel_names, self.num_bases, activation=F.relu, self_loop=self.use_self_loop, dropout=self.dropout, weight=False)) # h2h , 这里不添加隐层,只用2层卷积 # for i in range(self.num_hidden_layers): # self.layers.append(RelGraphConvLayer( # self.h_dim, self.h_dim, self.rel_names, # self.num_bases, activation=F.relu, self_loop=self.use_self_loop, # dropout=self.dropout)) # h2o self.layers.append(RelGraphConvLayer( self.h_dim, self.out_dim, self.rel_names, self.num_bases, activation=None, self_loop=self.use_self_loop)) # 输入 blocks,embeding def forward(self, h=None, blocks=None): if h is None: # full graph training h = self.embed_layer() if blocks is None: # full graph training for layer in self.layers: h = layer(self.g, h) else: # minibatch training # 输入 blocks,embeding for layer, block in zip(self.layers, blocks): h = layer(block, h) return h def inference(self, g, batch_size, device="cpu", num_workers=0, x=None): if x is None: x = self.embed_layer() for l, layer in enumerate(self.layers): y = { k: th.zeros( g.number_of_nodes(k), self.h_dim if l != len(self.layers) - 1 else self.out_dim) for k in g.ntypes} sampler = dgl.dataloading.MultiLayerFullNeighborSampler(1) dataloader = dgl.dataloading.NodeDataLoader( g, {k: th.arange(g.number_of_nodes(k)) for k in g.ntypes}, sampler, batch_size=batch_size, shuffle=True, drop_last=False, num_workers=num_workers) for input_nodes, output_nodes, blocks in tqdm.tqdm(dataloader): # print(input_nodes) block = blocks[0].to(device) h = {k: x[k][input_nodes[k]].to(device) for k in input_nodes.keys()} h = layer(block, h) for k in h.keys(): y[k][output_nodes[k]] = h[k].cpu() x = y return y
上面的代码主要分为三大块：分别是 RelGraphConvLayer、 RelGraphEmbed 以及 EntityClassify 。
首先就是：RelGraphConvLayer 。我们可以看到 RelGraphConvLayer 就是我们的 异构图卷积层layer , 其主要是调用了DGL实现的 HeteroGraphConv算子，从上面第一小节我们也详细阐述了异构图卷积算子其实就是： 对各种关系分别进行卷积然后进行同类型的节点的融合。
这里我们需要重点关注的是：RelGraphConvLayer层的返回，从代码中，我们可以看到，对于每种节点类型是返回了一个Embeding, 维度是 out_feat。如果是带了激活函数的，则是返回激活后的一定维度的一个tensor。
过来是 RelGraphEmbed。 从代码中可以看到： 这个python类仅仅返回了一个字典，但是这个字典里却包括了 多个 Embeding Variable, 注意这里的 Variable 均是可以 随着网络训练变化更新 的。我们可以根据节点类型，节点ID取得对应元素的 Embeding 。 这种实现方法是不是解决了 前文 GraphSage与DGL实现同构图 Link 预测，通俗易懂好文强推 和 基于GCN和DGL实现的图上 node 分类, 值得一看!!! 所提到的 动态更新的Embeding 的问题呢。
最后就是 EntityClassify类 了，我们可以看到 这个就是最终的 模型RGCN结构 了，包括了 模型训练的 forward 和用于推断的inference方法
。这里的 inference 可以用于 各个节点的embedding的导出， 我们在后文有实例代码，接着看下去吧～
注意看 forword 方法里 的 for layer, block in zip(self.layers, blocks) 这个位置， 这里就是我们前一小节所说的 采样层数和模型的卷积层数目是相同的说法的由来，可以结合上文说明理解源码哦。
（2.5） 模型采样超参与节点采样介绍
先上代码。
@ 欢迎关注微信公众号：算法全栈之路 # 根据节点类型和节点ID抽取embeding 参与模型训练更新 def extract_embed(node_embed, input_nodes): emb = {} for ntype, nid in input_nodes.items(): nid = input_nodes[ntype] emb[ntype] = node_embed[ntype][nid] return emb # 采样定义,有监督采样和无监督采样不一样 batch_size = 20480 neg_sample_count = 1 # 采样2层全部节点 sampler = MultiLayerFullNeighborSampler(2) # 用户节点采样，这里是对用户的所有邻居采样了2层节点 hetero_graph.nodes['user'].data['train_mask'] = torch.zeros(unique_userid_count, dtype=torch.bool).bernoulli(1.0) all_userid_idx = torch.nonzero(hetero_graph.nodes['user'].data['train_mask'], as_tuple=False).squeeze() user_loader = dgl.dataloading.NodeDataLoader(hetero_graph, {"user": train_userid_nodeids}, sampler,batch_size=batch_size, shuffle=True, num_workers=0) # 训练集和测试集split train_count=(int)(len(all_userid_idx) * 0.9) print(train_count) train_userid_nodeids = all_userid_idx[:train_count] test_userid_nodeids = all_userid_idx[train_count:] # IP节点的邻居采样 hetero_graph.nodes['ip'].data['train_mask'] = torch.zeros(unique_ip_count, dtype=torch.bool).bernoulli(1.0) train_ip_nodeids = hetero_graph.nodes['ip'].data['train_mask'].nonzero(as_tuple=True)[0] ip_loader = dgl.dataloading.NodeDataLoader(hetero_graph, {"ip": train_ip_nodeids}, sampler, batch_size=batch_size, shuffle=True, num_workers=0) # item 邻居节点采样 hetero_graph.nodes['item'].data['train_mask'] = torch.zeros(unique_ip_prefix_count, dtype=torch.bool).bernoulli(1.0) train_ipprefix_nodeids = hetero_graph.nodes['item'].data['train_mask'].nonzero(as_tuple=True)[0] ipprefix_loader = dgl.dataloading.NodeDataLoader(hetero_graph, {"item": train_ipprefix_nodeids}, sampler,batch_size=batch_size, shuffle=True, num_workers=0)
这里的代码作者花了大量时间进行优化，注释和组织形式 尽量写的非常清晰，非常容易理解。
我们这里选择了 NodeDataLoader 来进行训练数据的读入，这其实是一种 分batch训练 的方法，而 不是一次性把图全读入内存 进行训练，而是每次选择 batch的种子节点以及他们采样的邻居节点 读入内存参与训练，这也让大的图神经网络训练成为了可能，是 DGL图深度框架 非常优秀 的实现 ！！！ 大赞 ！
需要 注意的是 ： extract_embed 这个方法可以抽取出对应类别对应节点的 Embeding。 我们这里用了 MultiLayerFullNeighborSampler 这个接口，对每个种子节点采样了2层的全部邻居参与训练，中间因为是节点分类任务，这里需要将该邻居采样算子 和 dgl.dataloading.NodeDataLoader 结合使用。
而 NodeDataLoader 的第二个参数属于一个字典，其中可以放多个 节点类型以及对应的种子nids , 这里为了方便理解，把拆解成了多个 data_loader，来分别对多个类型的节点在图上进行全部邻居的采样，这里的 实现是等价 的。
作者亲测，图训练的 batch_size 能选择大尽可能大一些 吧，不然训练模型会非常慢的～
（2.6） 模型训练超参与单epoch训练
@ 欢迎关注微信公众号：算法全栈之路 # 模型定义 num_class = 2 n_hetero_features = 16 labels = hetero_graph.nodes['user'].data['label'] hidden_feat_dim = n_hetero_features embed_layer = RelGraphEmbed(hetero_graph, hidden_feat_dim) all_node_embed = embed_layer() model = EntityClassify(hetero_graph, hidden_feat_dim, num_class) # 优化模型所有参数,主要是weight以及输入的embeding参数 all_params = itertools.chain(model.parameters(), embed_layer.parameters()) optimizer = torch.optim.Adam(all_params, lr=0.01, weight_decay=0) def train_nodetype_one_epoch(ntype, spec_dataloader): losses = [] # input_nodes 代表计算 output_nodes 的表示所需的节点,input_nodes包含了output_nodes。 # 块 包含了每个GNN层要计算哪些节点表示作为输出，要将哪些节点表示作为输入，以及来自输入节点的表示如何传播到输出节点。 for input_nodes, output_nodes, blocks in tqdm.tqdm(spec_dataloader): emb = extract_embed(all_node_embed, input_nodes) batch_tic = time.time() seeds = output_nodes[ntype] lbl = labels[seeds] # 只取output_nodes部分结点参与训练 logits = model(emb, blocks)[ntype] loss = F.cross_entropy(logits, lbl) loss.backward() optimizer.step() train_acc = torch.sum(logits.argmax(dim=1) == lbl).item() / len(seeds) print('AUC', roc_auc_score(lbl, logits.argmax(dim=1) )) print("Epoch {:05d} | Train Acc: {:.4f} | Train Loss: {:.4f} | Time: {:.4f}". format(epoch, train_acc, loss.item(), time.time() - batch_tic))
从上面的代码我们可以看到： 最终我们是进行了 2分类 ，中间的调用了上面模型定义类 EntityClassify 来定义 异构图上RGCN的模型 结构，因为是分类问题，损失函数选择了 交叉熵损失 。
需要注意的是： all_params = itertools.chain(model.parameters(), embed_layer.parameters()) 这一行代码，我们定义优化器的参数时，将我们自定义的 可随网络更新的 Variable 加入了 itertools.chain 参与模型的训练。
另一个需要注意的点是： spec_dataloader 这个地方，它的返回是 input_nodes, output_nodes和 blocks 这三个元素的tuple 。 其中，input_nodes 代表计算 output_nodes 的表示所需的节点,input_nodes包含了output_nodes。块 包含了每个GNN层要计算哪些节点表示作为输出，要将哪些节点表示作为输入，以及来自输入节点的表示如何传播到输出节点。
这就有了我们进行模型训练所需要的图上结构的全部信息了。
（2.6） 模型多种节点训练
@ 欢迎关注微信公众号：算法全栈之路 # 开始train 模型 for epoch in range(20): print("start epoch:", epoch) model.train() train_nodetype_one_epoch('user', user_loader) train_nodetype_one_epoch('user', user_loader) train_nodetype_one_epoch('user', user_loader)
从代码中我们可以知道： 对于异构图，其实我们也是以 各种类型的节点作为种子节点， 然后进行图上的邻居采样，分别进行训练然后更新整个模型结构 的。
（2.7） 模型保存与节点Embeding导出
@ 欢迎关注微信公众号：算法全栈之路 # 图数据和模型保存 save_graphs("graph.bin", [hetero_graph]) torch.save(model.state_dict(), "model.bin") # 每个结点的embeding,自己初始化,因为参与了训练,这个就是最后每个结点输出的embeding print("node_embed:", all_node_embed['user'][0]) # 模型预估的结果,最后应该使用 inference,这里得到的是logit # 注意,这里传入 all_node_embed,选择0,选1可能会死锁,最终程序不执行 inference_out = model.inference(hetero_graph, batch_size, 'cpu', num_workers=0, all_node_embed) print(inference_out["user"].shape) print(inference_out['user'][0])
这里我们可以看到， 我们使用了 model.inference 接口进行模型的节点 Embeding导出。
这里需要注意的是： 这个地方 num_workers应该设置0 ,即为不用多线程, 不然会互锁,导致预估任务不执行。这里是 深坑 啊，反正经过很长时间的纠结和查找，最终发现是这个原因，希望读者可以避免遇到相似的问题 ～
其实对于异构图，要写出对它的一些应用的理解，我也是怯生生的。但是，凡事必先骑上虎背 。管它呢，上吧，能写到哪一步是哪一步吧！ 欢迎关注作者并留言和我一起讨论，彼此一起学习交流 ～
到这里，重磅好文透彻理解, 异构图上 Node 分类理论与DGL源码实战 的全文就写完了。上面的代码demo 在环境没问题的情况下，全部复制到一个python文件里，就可以完美运行起来。本文的 代码是一个小型的商业可以用的工程项目，希望可以对你有参考作用 ～
码字不易，觉得有收获就动动小手转载一下吧，你的支持是我写下去的最大动力 ～
更多更全更新内容 ： 算法全栈之路
