精华内容
下载资源
问答
  • GraphSage采样函数实现 GraphSage的作者提出了采样算法来使得模型能够以Mini-batch的方式进行训练,算法伪代码见论文附录A。 假设我们要利用中心节点的k阶邻居信息,则在聚合的时候,需要从第k阶邻居传递信息到k-1...

     

    1分析

    GraphSage采样函数实现

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

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

    论文伪代码

    展开全文
  • 图神经网络-图采样Graphsage代码实现

    千次阅读 2021-02-15 00:00:00
    一:为什么要图采样?二Graphsage 采样代码实践GraphSage的PGL完整代码实现位于https://github.com/PaddlePaddle/PGL/tree/main...

    一:为什么要图采样?

    二 Graphsage 采样代码实践

    GraphSage的PGL完整代码实现位于https://github.com/PaddlePaddle/PGL/tree/main/examples/graphsage,本文实现一个简单的graphsage 采样代码 。

    安装依赖

    # !pip install paddlepaddle==1.8.4
    !pip install pgl -q
    

    1. 构建graph

    图网络的构建使用Graph类,Graph类的具体实现可以参考https://github.com/PaddlePaddle/PGL/blob/main/pgl/graph.py

    import random
    import numpy as np
    import pgl
    import display
    
    
    def build_graph():
        # 定义节点的个数;每个节点用一个数字表示,即从0~9
        num_node = 16
        # 添加节点之间的边,每条边用一个tuple表示为: (src, dst)
        edge_list = [(2, 0), (1, 0), (3, 0),(4, 0), (5, 0), 
                 (6, 1), (7, 1), (8, 2), (9, 2), (8, 7),
                 (10, 3), (4, 3), (11, 10), (11, 4), (12, 4),
                 (13, 5), (14, 5), (15, 5)]
    
    
        g = pgl.graph.Graph(num_nodes = num_node, edges = edge_list)
    
    
        return g
    
    
    # 创建一个图对象,用于保存图网络的各种数据。
    g = build_graph()
    display.display_graph(g)
    

    运行结果:


    2. GraphSage采样函数实现

    GraphSage的作者提出采样算法来使得模型能够以Mini-batch的方式进行训练,算法代码见论文附录A https://cs.stanford.edu/people/jure/pubs/graphsage-nips17.pdf。

    • 假设要利用中心节点的k阶邻居信息,则在聚合的时候,需要从第k阶邻居传递信息到k-1阶邻居,并依次传递到中心节点。

    • 采样的过程与此相反,在构造第t轮训练的Mini-batch时,从中心节点出发,在前序节点集合中采样Nt个邻居节点加入采样集合。

    • 将邻居节点作为新的中心节点继续进行第t-1轮训练的节点采样,以此类推。

    • 将采样到的节点和边一起构造得到子图。

    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):
        """这个函数的目的是为了将 list of numpy array 扁平化成一个list
        例如:[array([7, 8, 9]), array([11, 12]), array([13, 15])] --> [7, 8, 9, 11, 12, 13, 15]
        """
        nodes = list(set(traverse(nodes)))
        return nodes
    
    
    def graphsage_sample(graph, start_nodes, sample_num):
        subgraph_edges = []
        # pre_nodes: a list of numpy array, 
        pre_nodes = graph.sample_predecessor(start_nodes, sample_num)
    
    
        # 根据采样的子节点, 恢复边
        for dst_node, src_nodes in zip(start_nodes, pre_nodes):
            for node in src_nodes:
                subgraph_edges.append((node, dst_node))
    
    
    
    
        subgraph_nodes = flat_node_and_edge(pre_nodes)
    
    
        return subgraph_nodes, subgraph_edges
    
    
    

    随机获取一阶邻居信息

    seed = 458
    np.random.seed(seed)
    random.seed(seed)
    
    
    start_nodes = [0]
    
    
    layer1_nodes, layer1_edges = graphsage_sample(g, start_nodes, sample_num=3)
    print('layer1_nodes: ', layer1_nodes)
    print('layer1_edges: ', layer1_edges)
    display.display_subgraph(g, {'orange': layer1_nodes}, {'orange': layer1_edges})
    

    运行结果

    layer1_nodes:  [2, 4, 5]
    layer1_edges:  [(4, 0), (2, 0), (5, 0)]
    

    继续获取二阶邻居节点信息

    layer2_nodes, layer2_edges = graphsage_sample(g, layer1_nodes, sample_num=2)
    print('layer2_nodes: ', layer2_nodes)
    print('layer2_edges: ', layer2_edges)
    display.display_subgraph(g, {'orange': layer1_nodes, 'Thistle': layer2_nodes}, {'orange': layer1_edges, 'Thistle': layer2_edges})
    

    运行结果

    layer2_nodes:  [8, 9, 11, 12, 14, 15]
    layer2_edges:  [(8, 2), (9, 2), (11, 4), (12, 4), (14, 5), (15, 5)]
    

    图节点可视化代码

    #%matplotlib inline
    import matplotlib.pyplot as plt
    import numpy as np
    import networkx as nx # networkx是一个常用的绘制复杂图形的Python包。
    
    
    def display_graph(g):
        nx_G = nx.Graph()
        nx_G.add_nodes_from(range(g.num_nodes))
        nx_G.add_edges_from(g.edges)
    
    
        pos = {0: [0.5, 0.5], 1:[0.6, 0.4], 2:[0.47, 0.67], 3: [0.35, 0.55], 4:[0.4, 0.4], 5:[0.5, 0.3],
               6: [0.8, 0.4], 7:[0.65, 0.65], 8:[0.6, 0.8], 9:[0.45, 0.85], 10:[0.15, 0.7], 11: [0.1, 0.4],
               12:[0.2, 0.2], 13:[0.3, 0.1], 14:[0.55, 0.15], 15:[0.7, 0.22]}
        nx.draw(nx_G, 
                pos,
                with_labels=True,
                node_color='green', 
                edge_color='green',
                node_size=1000)
    
    
        plt.show()
    
    
    #display_graph(g)# 创建一个GraphWrapper作为图数据的容器,用于构建图神经网络。
    
    
    def display_subgraph(g, sub_nodes, sub_edges):
        nx_G = nx.Graph()
        nx_G.add_nodes_from(range(g.num_nodes))
        nx_G.add_edges_from(g.edges)
    
    
        pos = {0: [0.5, 0.5], 1:[0.6, 0.4], 2:[0.47, 0.67], 3: [0.35, 0.55], 4:[0.4, 0.4], 5:[0.5, 0.3],
               6: [0.8, 0.4], 7:[0.65, 0.65], 8:[0.6, 0.8], 9:[0.45, 0.85], 10:[0.15, 0.7], 11: [0.1, 0.4],
               12:[0.2, 0.2], 13:[0.3, 0.1], 14:[0.55, 0.15], 15:[0.7, 0.22]}
        nx.draw(nx_G, 
                pos,
                with_labels=True,
                node_color='green',
                edge_color='green',
                node_size=1000,
                width=1)
    
    
        nx.draw_networkx_nodes(nx_G, pos, nodelist=[0], node_color='red', node_size=1000)
    
    
        for color, nodes in sub_nodes.items():
            nx.draw_networkx_nodes(nx_G, pos, nodelist=nodes, node_color=color, node_size=1000)
    
    
        for color, edges in sub_edges.items():
            nx.draw_networkx_edges(nx_G, pos, edgelist=edges, edge_color=color, width=5)
    
    
        plt.show()
    

    注:本文图文资料来源于 AIStudio-人工智能学习与实训社区

    展开全文
  • 3.2 采样 (SAmple) 算法 3.3 聚合器 (Aggregator) 架构 3.4 参数学习 四、后话 Reference 动机 本文为GNN教程的第三篇文章 【GraghSAGE算法】,在GCN的博文中我们重点讨论了图神经网络的逐层传播公式是如何...

    转载

    目录

    动机

    大纲

    一、Inductive learning v.s. Transductive learning

    二、概述

    三、算法细节

    3.1 节点 Embedding 生成(即:前向传播)算法

    3.2 采样 (SAmple) 算法

    3.3 聚合器 (Aggregator) 架构

    3.4 参数学习

    四、后话

    Reference


    动机

    本文为GNN教程的第三篇文章 【GraghSAGE算法】,在GCN的博文中我们重点讨论了图神经网络的逐层传播公式是如何推导的,然而,GCN的训练方式需要将邻接矩阵和特征矩阵一起放到内存或者显存里,在大规模图数据上是不可取的。

    其次,GCN在训练时需要知道整个图的结构信息(包括待预测的节点), 这在现实某些任务中也不能实现(比如用今天训练的图模型预测明天的数据,那么明天的节点是拿不到的)。GraphSAGE的出现就是为了解决这样的问题,这篇博文中我们将会详细得讨论它。

    大纲

     

    图片

    一、Inductive learning v.s. Transductive learning

    首先我们介绍一下什么是inductive learning。与其他类型的数据不同,图数据中的每一个节点可以通过边的关系利用其他节点的信息,这样就产生了一个问题,如果训练集上的节点通过边关联到了预测集或者验证集的节点,那么在训练的时候能否用它们的信息呢? 如果训练时用到了测试集或验证集样本的信息(或者说,测试集和验证集在训练的时候是可见的), 我们把这种学习方式叫做transductive learning, 反之,称为inductive learning。

    显然,我们所处理的大多数机器学习问题都是inductive learning, 因为我们刻意的将样本集分为训练/验证/测试,并且训练的时候只用训练样本然而,在GCN中,训练节点收集邻居信息的时候,用到了测试或者验证样本,所以它是transductive的

    二、概述

    GraphSAGE是一个inductive框架,在具体实现中,训练时它仅仅保留训练样本到训练样本的边。inductive learning 的优点是可以利用已知节点的信息为未知节点生成Embedding. GraphSAGE 取自 Graph SAmple and aggreGatE, SAmple指如何对邻居个数进行采样。aggreGatE指拿到邻居的embedding之后如何汇聚这些embedding以更新自己的embedding信息。下图展示了GraphSAGE学习的一个过程:

    图片

    1. 对邻居采样

    2. 采样后的邻居embedding传到节点上来,并使用一个聚合函数聚合这些邻居信息以更新节点的embedding

    3. 根据更新后的embedding预测节点的标签

    三、算法细节

    3.1 节点 Embedding 生成(即:前向传播)算法

    下面的算法描述了我们是怎么做前向传播的:

    图片

    算法的主要部分为:

    算法里的K这个比较难理解,下面单独来说他,之前提到过,它既是聚合器的数量,也是权重矩阵的数量,还是网络的层数,这是因为每一层网络中聚合器和权重矩阵是共享的。

    网络的层数可以理解为需要最大访问到的邻居的跳数(hops),比如在figure 1中,红色节点的更新拿到了它一、二跳邻居的信息,那么网络层数就是2。

    为了更新红色节点首先在第一层(K=1)我们会将蓝色节点的信息聚合到红色节点上,将绿色节点的信息聚合到蓝色节点上。在第二层(K=2)红色节点的embedding被再次更新,不过这次用的是更新后的蓝色节点embedding,这样就保证了红色节点更新后的embedding包括蓝色和绿色节点的信息。

    3.2 采样 (SAmple) 算法

    GraphSAGE采用了定长抽样的方法,具体来说,定义需要的邻居个数S, 然后采用有放回的重采样/负采样方法达到S,。保证每个节点(采样后的)邻居个数一致是为了多个节点以及他们的邻居拼成Tensor送到GPU中进行批训练。

    3.3 聚合器 (Aggregator) 架构

    GraphSAGE 提供了多种聚合器,实验中效果最好的平均聚合器(mean aggregator),平均聚合器的思虑很简单,每个维度取对邻居embedding相应维度的均值,这个和GCN的做法基本一致(GCN实际上用的是求和):

    举个简单例子,比如一个节点的3个邻居的embedding分别为  ,按照每一维分别求均值就得到了聚合后的邻居embedding为 .

    论文中还阐述了另外两种aggregator: LSTM aggregator 和 Pooling aggregator, 有兴趣的可以去论文中看下。

    3.4 参数学习

    到此为止,整个模型的架构就讲完了,那么GraphSAGE是如何学习聚合器的参数以及权重变量的呢? 在有监督的情况下,可以使用每个节点的预测label和真实label的交叉熵作为损失函数。在无监督的情况下,可以假设相邻的节点的输出embeding应当尽可能相近,因此可以设计出如下的损失函数:

    那么上面这个式子的意思是邻节点的embedding的相似度尽量大的情况下保证不相邻节点的embedding的期望相似度尽可能小。

    四、后话

    GraphSAGE采用了采样的机制,克服了GCN训练时内存和显存上的限制,使得图模型可以应用到大规模的图结构数据中,是目前几乎所有工业上图模型的雏形。然而,每个节点这么多邻居,采样能否考虑到邻居的相对重要性呢,或者我们在聚合计算中能否考虑到邻居的相对重要性? 这个问题在我们的下一篇博文Graph Attentioin Networks中做了详细的讨论。

    Reference

    [1] Inductive Representation Learning on Large Graphs(http://arxiv.org/abs/1706.02216)

    展开全文
  • 转载 目录 大纲 GCN中暴露的问题 DGL ...之前介绍了DGL这个框架,以及如何使用DGL编写一个GCN模型,用在学术数据集上,这样的模型是workable的。...DGL采用了和GraphSAGE类似的邻居采样策略,通过构

    转载

    目录

    大纲

    GCN中暴露的问题

    DGL

    NodeFlow

    Neighbor Sampling

    具体实现

    Control Variate

    后话

    Reference


    大纲

    本文为GNN教程的系列干货。之前介绍了DGL这个框架,以及如何使用DGL编写一个GCN模型,用在学术数据集上,这样的模型是workable的。然而,现实生活中会遇到非常庞大的图数据,庞大到邻接矩阵和特征矩阵不能同时塞进内存中,这时如何解决这样的问题呢?

    DGL采用了和GraphSAGE类似的邻居采样策略,通过构建计算子图缩小了每次计算的图规模,这篇博文将会介绍DGL提供的采样模型。

    图片

    GCN中暴露的问题

    解决这个问题的方式,正如我们在GraphSAGE的博文中提到的那样,通过mini-batch训练的方式,每次只构建该batch内节点的一个子图进行更新。DGL这个框架自version 0.3之后正式支持这种mini-batch的训练方式,下面我们重点介绍一下它的编程框架。

    DGL

    和GraphSAGE中一致,DGL将mini-batch 训练的前期准备工作分为两个层面首先建立为了更新一个batch内节点embedding而需要的所有邻居节点信息的子图,其次为了保证子图的大小不会受到”超级节点“影响,通过采样的技术将每个节点的邻居个数保持一致,使得这一批节点和相关邻居的embedding能够构成一个Tensor放入显卡中计算。

    这两个模块分别叫NodeFlowNeighbor Sampling,下面来详细得介绍它们。

    NodeFlow

    记一个batch内需要更新embedding的节点集合为,从这个节点集合出发,我们可以根据边信息查找计算所要用到的所有邻居节点,比如在下图的例子中,

    • 图结构如a)所示,假设我们使用的是2层GCN模型(每个节点的更新考虑其2度以内的邻居embedding),某个batch内我们需要更新节点D的embedding
    • 根据更新规则,为了更新,我们需要其一度节点的embedding信息,即需要节点ABEG,而这些节点的更新又需要节点CDF的embedding
    • 因此我们的计算图如图b)所示,先由CDF(Layer 0)更新的embedding,再由ABEG的embedding更新D的embedding。这样的计算图在DGL中叫做NodeFlow

    NodeFlow是一种层次结构的图,节点被组织在层之内(比如上面例子中2层的GCN节点分布在Layer0, Layer1 和 Layer2中),只有在相邻的层之间才存在边,两个相邻的层称为块(block)NodeFlow是反向建立(从内到外建立,图b的从上到下)的,首先确立一个batch内需要更新的节点集合(即Layer2中的节点),然后这个节点的1阶邻居构成了NodeFlow的下一层(即Layer1中的节点),再将下一层的节点当做是需要更新的节点集合,重复该操作,直到建立好所有层节点信息。

    通过这种方式,在每个batch的训练中,我们实际上将原图a)转化成了一个子图b),因此当原图很大无法塞进内存的时候,我们可以通过调小batch_size解决这样的问题。

    根据逐层更新公式可知,每一个block之间的计算是完全独立的,因此NodeFlow提供了函数block_compute以提供底层embedding向高层的传递和计算工作

    图片

    Neighbor Sampling

    现实生活中的图的节点分布常常是长尾的,这意味着有一些“超级节点”的度非常高,而还有一大部分节点的度很小。如果我们在NodeFlow的建立过程中关联到“超级节点“的话,”超级节点“就会为NodeFlow的下一层带来很多节点,使得整个NodeFlow非常庞大违背了设计小的计算子图的初衷。为了解决这样的问题,GraphSAGE提出了邻居采样的策略,通过为每个节点采样一定数量的邻居来近似,加上采样策略之后,节点embedding的更新公式变为(相比GCN,也就是对A进行限定多个采样)

    如假设每次规定采样2个节点,那么上面的图b最后变成图c,因为对中心节点D采样的时候,采样2个,本例子中选择的是 EG这两个邻居,再次分别对EG采样他们的2个邻居,本例子是DF和CF但同时又和D相连。

    具体实现

    在具体实现中,采样和计算是两个独立的模型,也就是说,我们通过采样获得子图,再将这个子图输入到标准的GCN模型中训练,这种解耦合的方式使模型变得非常灵活,因为我们可以对采样的方式进行定制,比如Stochastic Training of Graph Convolutional Networks with Variance Reduction选择特定的邻居以将方差控制在一定的范围内。这种模型与采样分离的方式也是大部分支持超大规模图计算框架的方式(包括这里介绍的DGL,之后我们要介绍的Euler)。

    DGL提供NeighborSampler类来构建采样后的NodeFlowNeighborSampler返回的是一个迭代器,生成NodeFlow实例,们来看看DGL提供的一个结合采样策略的GCN实例代码:

    note:因为nodeflow是从采样获取到的实例,因此只有拓扑结构,没有节点其他的数据信息,想要获取(如节点表示)的话,使用copy_from_parent

    # dropout probability
    dropout = 0.2
    # batch size
    batch_size = 1000
    # number of neighbors to sample
    num_neighbors = 4
    # number of epochs
    num_epochs = 1
    
    # initialize the model and cross entropy loss
    model = GCNSampling(in_feats, n_hidden, n_classes, L,
                        mx.nd.relu, dropout, prefix='GCN')
    model.initialize()
    loss_fcn = gluon.loss.SoftmaxCELoss()
    
    # use adam optimizer
    trainer = gluon.Trainer(model.collect_params(), 'adam',
                            {'learning_rate': 0.03, 'wd': 0})
    
    for epoch in range(num_epochs):
        i = 0
        for nf in dgl.contrib.sampling.NeighborSampler(g, batch_size,
                                                       num_neighbors,
                                                       neighbor_type='in',
                                                       shuffle=True,
                                                       num_hops=L,
                                                       seed_nodes=train_nid):
            # When `NodeFlow` is generated from `NeighborSampler`, it only contains
            # the topology structure, on which there is no data attached.
            # Users need to call `copy_from_parent` to copy specific data,
            # such as input node features, from the original graph.
            nf.copy_from_parent()
            with mx.autograd.record():
                # forward
                pred = model(nf)
                batch_nids = nf.layer_parent_nid(-1).astype('int64')
                batch_labels = labels[batch_nids]
                # cross entropy loss
                loss = loss_fcn(pred, batch_labels)
                loss = loss.sum() / len(batch_nids)
            # backward
            loss.backward()
            # optimization
            trainer.step(batch_size=1)
            print("Epoch[{}]: loss {}".format(epoch, loss.asscalar()))
            i += 1
            # We only train the model with 32 mini-batches just for demonstration.
            if i >= 32:
                break
    

    上面的代码中,model由GCNsampling定义,虽然它的名字里有sampling,但这只是一个标准的GCN模型,其中没有任何和采样相关的内容,和采样相关代码的定义在dgl.contrib.sampling.Neighborsampler中,使用图结构g初始化这个类,并且定义采样的邻居个数num_neighbors,它返回nf即是NodeFlow实例,采样后的子图。因为nf只会返回子图的拓扑结构,不会附带节点Embedding,所以需要调用copy_from_parent()方法来获取Embedding,layer_parent_nid返回该nodeflow中每一层的节点id,根据上面的图示,当前batch内的节点(称为种子节点)位于最高层,所以layer_parent_nid(-1)返回当前batch内的节点id。剩下的步骤就是一个标准的模型训练代码,包括前向传播,计算loss,反向传播在此不再赘述。

    Control Variate

    具体到我们的场景上,X是某次采样节点邻居的聚合,Y是该节点所有邻居的聚合。基于control variate的方法训练GCN的过程为(相比如基于采样的方法,对中间h的计算进行了调整-减去一值)

    那么上面的代码可以按照这种思路改写为:

    g.ndata['h_0'] = features
    for i in range(L):
      g.ndata['h_{}'.format(i+1)] = mx.nd.zeros((features.shape[0], n_hidden))
      # With control-variate sampling, we only need to sample 2 neighbors to train GCN.
      for nf in dgl.contrib.sampling.NeighborSampler(g, batch_size, expand_factor=2,
                                                     neighbor_type='in', num_hops=L,
                                                     seed_nodes=train_nid):
        for i in range(nf.num_blocks):
          # aggregate history on the original graph
          g.pull(nf.layer_parent_nid(i+1),
                 fn.copy_src(src='h_{}'.format(i), out='m'),
                 lambda node: {'agg_h_{}'.format(i): node.mailbox['m'].mean(axis=1)})
          nf.copy_from_parent()
          h = nf.layers[0].data['features']
          for i in range(nf.num_blocks):
            prev_h = nf.layers[i].data['h_{}'.format(i)]
            # compute delta_h, the difference of the current activation and the history
            nf.layers[i].data['delta_h'] = h - prev_h
            # refresh the old history
            nf.layers[i].data['h_{}'.format(i)] = h.detach()
            # aggregate the delta_h
            nf.block_compute(i,
                             fn.copy_src(src='delta_h', out='m'),
                             lambda node: {'delta_h': node.data['m'].mean(axis=1)})
            delta_h = nf.layers[i + 1].data['delta_h']
            agg_h = nf.layers[i + 1].data['agg_h_{}'.format(i)]
            # control variate estimator
            nf.layers[i + 1].data['h'] = delta_h + agg_h
            nf.apply_layer(i + 1, lambda node : {'h' : layer(node.data['h'])})
            h = nf.layers[i + 1].data['h']
            # update history
            nf.copy_to_parent()
    

    上文代码中,nfNeighborSampler返回的对象,在nf的对象的每一个block内,首先调用pull函数获取(即代码中的agg_h_{}),然后计算和(即代码中的delta_hagg_h),最后将更新后的结果拷贝回原大图中。

    后话

    这一篇博文介绍了DGL这个框架怎么对大图进行计算的,总结起来,它吸取了GraphSAGE的思路,通过为每个mini-batch构建子图并采样邻居的方式将图规模控制在可计算的范围内。这种采样-计算分离的模型基本是目前所有图神经网络计算大图时所采用的策略。

    有两个细节没有介绍,第一、具体的采样方法,对于邻居的采样方法有很多种,除了最容易想到的重采样/负采样策略很多学者还提出了一些更加优秀的策略,之后我们会在"加速计算、近似方法"模块中详细讨论这些方法的原理;第二、对于超大规模的图,很多框架采用的是分布式的方式,典型的如Euler,这一系列我们还将写一篇关于Euler的博文,介绍它与DGL的异同,它的分布式架构和在超大规模图计算上做的创新。

    Reference

    DGL Tutorial on NodeFlow and Neighbor Sampling

    展开全文
  • 通过数据驱动的节点采样提高GraphSAGE 作者: ( , ), ( ), ( ) 发表在2019 ICLR研讨会表示学习上图和流形。 概述 作为一种高效且可扩展的图神经网络,GraphSAGE通过归纳二次采样的局部邻域并以小批量梯度...
  • GraphSAGE采样可能意味着邻居信息的丢失,这在小图中可能影响很大,因此,效果可能并不如GCN等模型。 关于数据集的划分,总感觉怪怪的,下面(参考引用)也列了一篇吐槽的文章,后面有时间去看一下那篇paper,看看...
  • GraphSAGE: 算法原理,实现和应用

    千次阅读 2020-04-20 16:21:01
    最后经过一次非线性变换得到output,即所有顶点的第 层的表示向量 GraphSAGE 下面是完整的GraphSAGE方法的代码 def GraphSAGE(feature_dim, neighbor_num, n_hidden, n_classes, use_bias=True, activation=tf.nn....
  • GraphSAGE学习心得

    2020-11-28 10:43:35
    最近在参加百度的图神经网络七日打卡营,然后就记录一下最近...虽然说一直做基于GCN的Skeleton-Based Action Recognition但是其实对于经典的GNN的方法我并没有太多的了解,只是单纯的知道有哪些比如说GraphSAGE,GAT,
  • 【深度学习实战】GraphSAGE(pytorch)

    千次阅读 2020-09-02 18:48:57
    书的配套代码:Chapter7:GraphSage示例(使用Cora数据集...GraphSAGE包括两个方面,一是对邻居的采样,二是对邻居的聚合操作。 为了实现更高效的采样,可以将节点及其邻居节点存放在一起,即维护一个节点与其邻居对应.
  • 3.2 采样 (SAmple) 算法 GraphSAGE采用了定长抽样的方法,具体来说,定义需要的邻居个数 , 然后采用有放回的重采样/负采样方法达到 ,。保证每个节点(采样后的)邻居个数一致是为了把多个节点以及他们的邻居拼成...
  • 图神经网络 | (5) GraphSAGE实战

    千次阅读 2020-02-02 21:31:29
    本节我们通过代码来介绍GraphSAGE以加深读者对相关知识的理解,如书中介绍的那样,GraphSAGE包括两方面,一是对邻居的采样;二是对邻居的聚合操作。 目录 1. 对邻居采样 2. 对邻居聚合 3. 定义SageG...
  • 目录 ...最近学习回顾各种代码,学习到了graphsage,发现这个代码首先提出来batch采样训练以计算每个批的最终表示,但是由于节点间互有关系,加上图太大,又提出了逐层计算节点的表示,具体代码体现在
  • GraphSage笔记

    2020-08-26 18:21:53
    GraphSAGE 前向传播算法步骤 hvk\mathbf{h}_{v}^{k}hvk​:节点v通过聚合k层邻居节点后得到的embedding表示。 当k=1时,算法第3~7行,更新所有节点vvv的hv1\mathbf{h}_{v}^{1}hv1​, 当k=2时,算法第3~7行,对于...
  • 采样技术-GraphSage采样+泛化) 采样过程(内-外) 聚合过程(外-内) 优点【泛化+计算量小】 QA 图采样技术-PinSage(快速多阶信息) 计算(假设模型只有1层) 优点 邻居聚合技术(采样之后的操作) ...
  • GraphSAGE节点分类

    2020-11-11 15:39:54
    本文简单介绍图网络中极具代表性的GraphSAGE并以Pytorch进行实现,在Cora上进行训练演示。
  • GraphSAGE-master.zip

    2020-03-08 23:39:08
    GraphSage训练所有节点的每个embedding,还训练一个聚合函数,通过从节点的相邻节点采样和收集特征来产生embedding。本文训练一组aggregator函数来从一个节点的邻节点aggregate特征信息,每个aggregator函数从不同...
  • GCN等方法要求图中的所有的顶点在训练过程 GraphSAGE(Graph SAmple and aggreGatE)框架,通过训练聚合节点邻居的函数(卷积层),使GCN扩展成归纳学习任务,对未知节点起到泛化作用。 ...
  • GraphSAGE论文总结及源码解读

    千次阅读 2020-02-11 20:15:04
    首先构造一个邻居采样器sampler(只是定义了,并没开始采样),layer_infos是一个列表包含每一层的信息,列表中每个位置是一个自定义的元组,元组包含四个信息,每一层的名字、采样器、邻居采样个数(第一层是25,第二...
  • GraphSAGE详解

    千次阅读 2020-12-10 16:54:32
    文章目录算法思想嵌入生成算法采样算法(minibatch)邻居聚合函数适用场景不足和改进 算法思想 作者提出一种信息传递框架:节点的(结构和特征)信息在点与点之间传递。通过聚合函数,一个节点能够聚合邻居的信息,...
  • GraphSAGE精读

    2021-05-11 22:13:05
    创新点:提出GraphSAGE 提出原因:GCN属于直推式(transductive learning)学习,而很多现实中的应用需要很快的对未见过的顶点或是全新的图(子图)生成embedding。这种归纳推断(inductive learning)的能力对于高吞吐...
  • GraphSAGE采样可能意味着邻居信息的丢失,这在小图中可能影响很大,因此,效果可能并不如GCN等模型。 关于Citeseer数据集的问题。应该是有15个孤立节点,导致了程序出现问题以及训练精度都不好。 有2种思路来解决这...
  • GraphSAGE 图神经网络算法详解

    千次阅读 2020-09-09 08:30:00
    GraphSAGE 是 17 年的文章了,但是一直在工业界受到重视,最主要的就是它论文名字中的两个关键词:inductive 和 large graph。今天我们就梳理一下这篇文章的核心...
  • 3. 图采样算法详解(GraphSAGE、PinSAGE)GraphSAGE (SAmple & aggreGatE)邻居采样算法邻居采样算法的优点:PinSAGE:根据邻居节点重要性进行聚合的算法。 图采样 1. 为什么要图采样? 图采样的原因: 如果图很...
  • GraphSAGE学习笔记

    2020-12-13 22:38:06
    GraphSAGE作为GCN的一个变种,其核心思想是,从邻居节点聚合(平均,池化,拼接)信息,然后更新自身节点的信息; 核心步骤: init h0 ∈ V #初始化节点特征 for i in K: #K为聚合邻居节点的跳数   for v ...
  • GraphSAGE例子讲解

    2021-06-09 15:45:12
    图中代码第2行:遍历K层graphsage 第3行:遍历每层的所有节点v 第4行:聚合v节点所有邻居节点的信息,得到v节点在第i层的邻居向量 第5行:拼接v在上一层的特征向量和v节点在第i层的邻居向量 例子: 部分采样...
  • 本文为图神经网络学习笔记,讲解学习聚合函数 GraphSAGE
  • 采样算法matlab实现代码欺诈检测的归纳图表示学习 该存储库包含在我们的论文“用于欺诈检测的归纳图表示学习”的实验设置中使用的代码。 笔记本“实验流水线”包含了我们实验中使用的确切代码,而演示笔记本则演示...
  • 上一篇文章,我们讲了图神经网络:图...本文提到的 GraphSAGE 属于归纳学习(Inductive Learning),核心是学习聚合邻居节点信息的函数(聚合函数),然后利用聚合函数来得到一个节点的表示。即使图中加入了新的节点,建
  • GraphSAGE代码详解-pytorch版本1. GraphSAGE导入2. 代码解析2.1 加载数据2.2 Unsupervised Loss2.3 Models2.4 评估与模型使用2.5 Main参考资料 1. GraphSAGE导入 论文标题:Inductive Representation Learning on ...
  • 首先要理解的是,采样的过程和特征聚合的过程是相反的,采样的过程,比如,如下图所示,先采样A节点的一阶邻域节点,再根据一阶采样得到的节点进行二阶采样,是一个从左到右的采样过程,而在特征聚合消息传递的时候...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 932
精华内容 372
关键字:

graphsage采样