心得

 #安装依赖
 #!pip install paddlepaddle==1.8.5
!pip install pgl

2. GraphSage采样函数实现

GraphSage的作者提出了采样算法来使得模型能够以Mini-batch的方式进行训练，算法伪代码见论文附录A。

1. 假设我们要利用中心节点的k阶邻居信息，则在聚合的时候，需要从第k阶邻居传递信息到k-1阶邻居，并依次传递到中心节点。
2. 采样的过程刚好与此相反，在构造第t轮训练的Mini-batch时，我们从中心节点出发，在前序节点集合中采样 Nt个邻居节点加入采样集合。
3. 接着将邻居节点作为新的中心节点继续进行第t-1轮训练的节点采样，以此类推。
4. 最后将采样到的节点和边一起构造得到子图。

下面请将GraphSage的采样函数补充完整。

%%writefile userdef_sample.py

import numpy as np

def traverse(item):
    """traverse
    """
    if isinstance(item, list) or isinstance(item, np.ndarray):
        for i in iter(item):
            for j in traverse(i):
                yield j
    else:
        yield item


def flat_node_and_edge(nodes):
    """flat_node_and_edge
    """
    nodes = list(set(traverse(nodes)))
    return nodes


def my_graphsage_sample(graph, batch_train_samples, samples):
    """
    输入：graph - 图结构 Graph
         batch_train_samples - 中心节点 list (batch_size,)
         samples - 采样时的最大邻节点数列表 list 
    输出：被采样节点下标的集合 
         对当前节点进行k阶采样后得到的子图 
    """
    
    start_nodes = batch_train_samples
    nodes = start_nodes
    edges = []
    for max_deg in samples:
        #################################
        # 请在这里补充每阶邻居采样的代码：此部分课堂实践内容已详细讲解，加油~
        # 提示：graph.sample_predecessor(该 API用于获取目标节点对应的源节点，具体用法到 pgl.Graph 结构中查看)
        pred_nodes = graph.sample_predecessor(nodes, max_deg)
        for dst_node, src_nodes in zip(start_nodes, pred_nodes):
            for node in src_nodes:
                edges.append((node, dst_node))
        #################################

        # 合并已采样节点并找出新的节点作为start_nodes
        last_nodes = nodes
        nodes = [nodes, pred_nodes]
        nodes = flat_node_and_edge(nodes)
        start_nodes = list(set(nodes) - set(last_nodes))
        if len(start_nodes) == 0:
            break

    subgraph = graph.subgraph(
         nodes=nodes,
         edges=edges,
         with_node_feat=False,
         with_edge_feat=False)
         
    return nodes, subgraph

运行一下代码看看自己实现的采样算法与PGL相比效果如何吧~

!python train.py --use_my_sample

3. GraphSage聚合函数实现

对于GraphSage中的聚合函数，首先用PGL中的Send和Receive接口实现邻居信息的聚合，然后分别学习两个全连接层，映射得到当前节点和邻居信息的表示，最后将二者拼接起来经过L2标准化，得到新的的节点表示。不同聚合函数的区别就在于信息传递机制的不同。

3.1 Mean Aggregator示例代码

以下代码实现了Mean Aggregator的消息传递机制，得到邻居聚合信息后的代码与其他聚合函数相同。具体实现细节可参考第三节实践教程中的消息传递机制。

def graphsage_mean(gw, feature, hidden_size, act, name):
    # 消息的传递和接收
    def copy_send(src_feat, dst_feat, edge_feat):
        return src_feat["h"]
    def mean_recv(feat):
        return fluid.layers.sequence_pool(feat, pool_type="average")
    msg = gw.send(copy_send, nfeat_list=[("h", feature)])
    neigh_feature = gw.recv(msg, mean_recv)

    # 自身表示和邻居表示的结合
    self_feature = feature
    self_feature = fluid.layers.fc(self_feature,
                                   hidden_size,
                                   act=act,
                                   name=name + '_l')
    neigh_feature = fluid.layers.fc(neigh_feature,
                                    hidden_size,
                                    act=act,
                                    name=name + '_r')
    output = fluid.layers.concat([self_feature, neigh_feature], axis=1)
    output = fluid.layers.l2_normalize(output, axis=1)
    return output

3.2 MaxPool Aggregator实现

MaxPool Aggregator在进行邻居聚合时会选取最大的值作为当前节点接收到的消息，实现API可参考Paddle文档。

实际实现的时候，与上述给出的例子 Mean Aggregator 非常类似。大家可以自行填空完成。

%%writefile userdef_maxpool.py
import paddle.fluid as fluid

def my_graphsage_maxpool(gw,
                      feature,
                      hidden_size,
                      act,
                      name,
                      inner_hidden_size=512):
    """
    输入：gw - GraphWrapper对象
         feature - 当前节点表示 (num_nodes, embed_dim)
         hidden_size - 新的节点表示维数 int
         act - **函数名 str
         name - 聚合函数名 str
         inner_hidden_size - 消息传递过程中邻居信息的维数 int
    输出：新的节点表示
    """
    
    ####################################
    # 请在这里实现MaxPool Aggregator

    def copy_send(src_feat, dst_feat, edge_feat):
         return src_feat["h"]
    def maxpool_recv(feat):
         return fluid.layers.sequence_pool(feat, pool_type="max")

    # 补充消息传递机制触发代码
    neigh_feature = fluid.layers.fc(feature, inner_hidden_size, act="relu")
    msg = gw.send(copy_send, nfeat_list=[("h", neigh_feature)])
    neigh_feature = gw.recv(msg, maxpool_recv)
    ####################################
    
    # 自身表示和邻居表示的结合
    self_feature = feature
    self_feature = fluid.layers.fc(self_feature,
                                   hidden_size,
                                   act=act,
                                   name=name + '_l')
    neigh_feature = fluid.layers.fc(neigh_feature,
                                    hidden_size,
                                    act=act,
                                    name=name + '_r')
    output = fluid.layers.concat([self_feature, neigh_feature], axis=1)
    output = fluid.layers.l2_normalize(output, axis=1)
    return output

运行一下代码看看自己实现的采样算法与PGL相比效果如何吧~

!python train.py --use_my_maxpool
请点击此处查看本环境基本用法.
Please click here for more detailed instructions.