精华内容
下载资源
问答
  • GraphSAGE

    2019-11-19 11:32:57
    https://zhuanlan.zhihu.com/p/74242097 https://zhuanlan.zhihu.com/p/62750137 https://zhuanlan.zhihu.com/p/77317842
    展开全文
  • GraphSage: Representation Learning on Large Graphs Authors: William L. Hamilton (wleif@stanford.edu), Rex Ying (rexying@stanford.edu) Project Website Alternative reference PyTorch implementation ...
  • GraphSAGE节点分类

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

    GraphSAGE 节点分类

    简介

    GCN(Graph Convolutional Network)的出现带动了将神经网络技术用于图数据的学习任务中去,并产生了大量的方法,这类方法我们统称为图神经网络(Graph Neural Networks,GNN)。我们知道,图卷积可以从谱域和空域两个角度看待(尽管后来逐渐深入的研究表明,所谓的谱域图卷积其实就是特殊的空域图卷积而已),从空域来看,GCN 的本质就是一个迭代式地聚合邻居的过程,这个思路启发了一大类模型对于这种聚合操作的重新设计,比如比较有名的 GraphSAGE、GAT、R-GCN,这些以空域视角出发的图网络算法,通常被叫做空域图卷积。本文在本系列上一篇文章GCN 节点分类的基础上,使用 Pytorch 实现 GraphSAGE 对 Cora 数据集进行节点分类。

    GraphSAGE 算法简述

    GraphSAGE 其实在两个方面对 GCN 做了改动,一方面是通过采样邻居的策略将 GCN 由全图(full batch)的训练方式改造成以节点为中心的小批量(mini batch)的训练方式,这使得大规模图数据的分布式训练成为了可能;另一方面,GraphSAGE 对聚合邻居的操作进行了拓展,提出了替换 GCN 操作的新的方式。

    采样邻居

    GCN 的训练是全图形式的,就是说一轮迭代,所有节点的样本的损失只会贡献一次梯度,无法做到深度神经网络中常用的小批量更新,从梯度更新的次数来看这是很低效的。这还不是重点,事实上,实际业务中,图的规模是巨大的,显存或者内存很难容纳下模型和整个图,因此采用小批量的训练方法是必要的。GraphSAGE 从聚合邻居的操作出发,对邻居进行随机采样来控制实际运算时节点 k k k阶子图的数据规模,在此基础上对采样的子图进行随机组合来完成小批量训练。

    GCN 中,节点在第 k + 1 k+1 k+1层的特征只与其邻居在 k k k层的特征有关,这种局部性质导致节点在第 k k k层的特征只与自己的 k k k阶子图有关。虽然这样说只需要考虑节点的 k k k阶子图就可以完成对节点高层特征的计算,但是对于一个大规模图数据而言,直接迁移此思路仍然存在一些问题:

    1. 子图的节点数呈指数级增长。若图中的节点度均值为 d ‾ \overline{d} d,执行 k k k层 GCN,则 k k k阶子图平均出现 1 + d ‾ + d ‾ 2 + ⋯ + d ‾ k 1 + \overline{d} + \overline{d}^2 + \cdots + \overline{d}^k 1+d+d2++dk,当 d ‾ = 10 , k = 4 \overline{d}=10,k=4 d=10k=4的时候,就有 11111 11111 11111个节点参与计算,这会导致很高的计算复杂度。
    2. 真实的图数据节点往往呈现幂律分布,一些节点的度很大,这些节点成为超级节点,在很多图计算的问题中,超级节点都是比较难处理的对象。由于超级节点邻居数目庞大,子图节点数又呈指数级增长,计算代价会更高。

    上述的情况下,遍历子图的时间代价、模型训练的计算和存储代价都会难以把控。因此,GraphSAGE 使用了采样邻居的操作来控制子图发散时的增长率。它的具体操作为:设每个节点在第 k k k层的邻居采样倍率为 S k S_k Sk(这是一个超参数),即每个节点采样的一阶邻居不超过 S k S_k Sk,那么对于任意一个中心节点的表达计算,所设计的总节点数将在 O ( ∏ k = 1 K s k ) O\left(\prod_{k=1}^{K} s_{k}\right) O(k=1Ksk)这个级别。举个例子,对一个两层模型来说,如果 S 1 = 3 S_1=3 S1=3 S 2 = 2 S_2=2 S2=2则总节点数不会超过 1 + 3 + 3 × 2 = 10 1+3+3\times2=10 1+3+3×2=10个。这里对节点采样,GraphSAGE 选择了均匀分布,其实工程上会采用其他形式的分布。

    通过采样邻居的策略,GraphSAGE 控制子图节点的规模始终维持在阶乘级别以下,这也给模型层数的增加提供了可能性。

    聚合邻居

    GraphSAGE 研究了聚合邻居操作所需的性质,提出了几种新的聚合操作算子(aggregator),需满足如下条件:

    1. 聚合操作必须对聚合节点的数量做到自适应。不管节点的邻居数量如何变化,进行聚合操作后输出的维度必须一致,为一个统一维度的向量。
    2. 聚合操作对聚合节点具有排列不变性。图数据本身是一种无序对的数据结构,对于聚合操作而言,这就要求不管邻居节点的排列顺序如何,输出的结果总是给一样的。如 A g g ( v 1 , v 2 ) = A g g ( v 2 , v 1 ) Agg(v_1, v_2)=Agg(v_2, v_1) Agg(v1,v2)=Agg(v2,v1)

    当然,从模型优化的角度看,这种聚合操作还必须可导。只要满足上述性质,聚合操作就能对任意输入的节点集合做到自适应。比较简单的算子有平均/加和聚合算子、LSTM 聚合算子、池化聚合算子等,这里就不展开了,详细可以参考原论文3.3 节。

    GraphSAGE 算法过程

    在上面两个机制的基础上,最后来看看 GraphSAGE 如何实现训练的。

    输入:图 G ( V , E ) \mathcal{G}(\mathcal{V}, \mathcal{E}) G(V,E);输入特征 { x v , ∀ v ∈ B } \left\{\mathbf{x}_{v}, \forall v \in \mathcal{B}\right\} {xv,vB};层数 K K K;权重矩阵 W k , ∀ k ∈ { 1 , … , K } \mathbf{W}^{k}, \forall k \in\{1, \ldots, K\} Wk,k{1,,K};非线性函数 σ \sigma σ;聚合操作 AGGREGATE k , ∀ k ∈ { 1 , … , K } _{k}, \forall k \in\{1, \ldots, K\} k,k{1,,K};邻居采样函数 N k : v → 2 V , ∀ k ∈ { 1 , … , K } \mathcal{N}_{k}: v \rightarrow 2^{\mathcal{V}}, \forall k \in\{1, \ldots, K\} Nk:v2V,k{1,,K}

    输出:所有节点的向量表示 z v \mathbf{z}_{v} zv v ∈ B v \in \mathcal{B} vB

    小批量训练过程如下:

    在这里插入图片描述

    上述算法的基本思路为先将小批集合 B \mathcal{B} B内的中心节点聚合操作要涉及到的 k k k阶子图一次性遍历出来,然后在这些节点上进行 K K K次聚合操作的迭代式计算。上述图中的 1-7 行就是描述遍历操作,可以简单理解这个过程:要想得到某个中心节点第 k k k层的特征,就需要采样其在第 k − 1 k-1 k1层的邻居,然后对 k − 1 k-1 k1层每个节点采样其第 k − 2 k-2 k2层的邻居,以此类推,直到采样完第一层所有的邻居为止。注意,每层的采样函数可以单独设置。

    上述算法图的 9-15 行是第二步,聚合操作,其核心为 11-13 行的三个公式。第 11 行的式子是调用聚合操作完成对每个节点邻居特征的整合输出,第 12 行是将聚合后的邻居特征与中心节点上一层的特征进行拼接,然后送到一个单层网络里得到中心节点的特征向量,第 13 行对节点的特征向量进行归一化。对这三行操作迭代 K K K次就完成了对 B \mathcal{B} B内所有中心节点特征向量的提取。

    GraphSAGE 的算法过程完全没有拉普拉斯矩阵的参与,每个节点的特征学习过程仅仅只与其 k k k阶邻居相关,而不需要全图对的结构西南西,这样的方法适合做归纳学习(Inductive Learning),这也就是 GraphSAGE 论文题目 Inductive Representation Learning on Large Graphs 的由来。这里我就不多阐述归纳学习和转导学习(Transductive Learning)的理论,需要知道的是,对 GraphSAGE 而言,新出现的节点数据,只需要遍历得到 k k k阶子图,就可以代入模型进行预测,这种特性使得 GraphSAGE 潜力巨大。

    总的来说,GraphSAEG 对空域视角下的 GCN 作了一次解构,提出几种邻居聚合算子,同时通过采样邻居,大大改进了算法的性能,关于其更详细的内容推荐阅读原论文

    GraphSAGE 节点分类

    本节使用 Pytorch 实现 GraphSAGE 对 Cora 数据集进行节点分类,通过代码进一步理解 GraphSAGE。GraphSAGE 包括邻居采样和邻居聚合两个方面。

    首先来看邻居采样,通过下面的两个函数实现了一阶和多阶采样,为了高效,节点和邻居的关系维护一个表即可。

    import numpy as np
    
    
    def sampling(src_nodes, sample_num, neighbor_table):
        """
        根据源节点一阶采样指定数量的邻居,有放回
        :param src_nodes:
        :param sample_num:
        :param neighbor_table:
        :return:
        """
        results = []
        for sid in src_nodes:
            # 从节点的邻居中进行有放回地进行采样
            neighbor_nodes = neighbor_table.getrow(sid).nonzero()
            res = np.random.choice(np.array(neighbor_nodes).flatten(), size=sample_num)
            results.append(res)
        return np.asarray(results).flatten()
    
    
    def multihop_sampling(src_nodes, sample_nums, neighbor_table):
        """
        根据源节点进行多阶采样
        :param src_nodes:
        :param sample_nums:
        :param neighbor_table:
        :return:
        """
        sampling_result = [src_nodes]
        for k, hopk_num in enumerate(sample_nums):
            hopk_result = sampling(sampling_result[k], hopk_num, neighbor_table)
            sampling_result.append(hopk_result)
        return sampling_result
    

    这样的阿斗的结果是节点的 ID,还需要根据 ID 查询节点的特征以进行聚合操作更新特征。

    接着我们来看邻居聚合,定义一个 Pytorch module 来完成聚合过程,输入特征先是经过一个线性变换得到隐层特征,从而可以在第一个维度进行聚合操作,预定义了求和、均值、最大值等算子。

    class NeighborAggregator(nn.Module):
        def __init__(self, input_dim, output_dim,
                     use_bias=False, aggr_method="mean"):
            """
            聚合节点邻居
            :param input_dim: 输入特征的维度
            :param output_dim: 输出特征的维度
            :param use_bias: 是否使用偏置
            :param aggr_method: 邻居聚合算子形式
            """
            super(NeighborAggregator, self).__init__()
            self.input_dim = input_dim
            self.output_dim = output_dim
            self.use_bias = use_bias
            self.aggr_method = aggr_method
            self.weight = nn.Parameter(torch.Tensor(input_dim, output_dim))
            if self.use_bias:
                self.bias = nn.Parameter(torch.Tensor(self.output_dim))
            self.reset_parameters()
    
        def reset_parameters(self):
            init.kaiming_uniform_(self.weight)
            if self.use_bias:
                init.zeros_(self.bias)
    
        def forward(self, neighbor_feature):
            if self.aggr_method == "mean":
                aggr_neighbor = neighbor_feature.mean(dim=1)
            elif self.aggr_method == "sum":
                aggr_neighbor = neighbor_feature.sum(dim=1)
            elif self.aggr_method == "max":
                aggr_neighbor = neighbor_feature.max(dim=1)
            else:
                raise ValueError("Unknown aggr type, expected sum, max, or mean, but got {}"
                                 .format(self.aggr_method))
    
            neighbor_hidden = torch.matmul(aggr_neighbor, self.weight)
            if self.use_bias:
                neighbor_hidden += self.bias
    
            return neighbor_hidden
    
        def extra_repr(self):
            return 'in_features={}, out_features={}, aggr_method={}'.format(
                self.input_dim, self.output_dim, self.aggr_method)
    

    基于邻居聚合的结果对中心节点的特征进行更新。更新的方式是将邻居节点聚合的特征与经过线性变换的中心特征加和或者级联,再经过一个激活函数得到更新后的特征,依次我们就可以实现新的 GCN 层。继而,可以堆叠 SAGEGCN 来构建模型,实现训练。

    class GraphSAGE(nn.Module):
        def __init__(self, input_dim, hidden_dim,
                     num_neighbors_list):
            super(GraphSAGE, self).__init__()
            self.input_dim = input_dim
            self.hidden_dim = hidden_dim
            self.num_neighbors_list = num_neighbors_list
            self.num_layers = len(num_neighbors_list)
            self.gcn = nn.ModuleList()
            self.gcn.append(SAGEGCN(input_dim, hidden_dim[0]))
            for index in range(0, len(hidden_dim) - 2):
                self.gcn.append(SAGEGCN(hidden_dim[index], hidden_dim[index + 1]))
            self.gcn.append(SAGEGCN(hidden_dim[-2], hidden_dim[-1], activation=None))
    
        def forward(self, node_features_list):
            hidden = node_features_list
            for l in range(self.num_layers):
                next_hidden = []
                gcn = self.gcn[l]
                for hop in range(self.num_layers - l):
                    src_node_features = hidden[hop]
                    src_node_num = len(src_node_features)
                    neighbor_node_features = hidden[hop + 1] \
                        .view((src_node_num, self.num_neighbors_list[hop], -1))
                    h = gcn(src_node_features, neighbor_node_features)
                    next_hidden.append(h)
                hidden = next_hidden
            return hidden[0]
    
        def extra_repr(self):
            return 'in_features={}, num_neighbors_list={}'.format(
                self.input_dim, self.num_neighbors_list
            )
    

    下图是训练过程可视化的结果,可以看到,GraphSAGE以mini batch的方式训练,并在很少的轮次后获得了和GCN相当的精度。

    在这里插入图片描述

    补充说明

    本文关于 GraphSAGE 的理论以及代码部分参考《深入浅出图神经网络》以及 GraphSAGE 论文原文。本文涉及到的代码开源于Github,欢迎 star和fork。

    展开全文
  • GraphSAGE的PyTorch实现 此包包含一个PyTorch实施 。 该代码包的作者: ( ),( ),( )。 环境设定 python == 3.6.8 pytorch == 1.0.0 基本用法 主要参数: --dataSet The input graph dataset. (default: ...
  • 通过数据驱动的节点采样提高GraphSAGE 作者: ( , ), ( ), ( ) 发表在2019 ICLR研讨会表示学习上图和流形。 概述 作为一种高效且可扩展的图神经网络,GraphSAGE通过归纳二次采样的局部邻域并以小批量梯度...
  • 带有用户项目设置的GraphSAGE实现 概述 作者:张佑英基本算法:GraphSAGE 基础Github: 原始纸: 韩文撰写的论文评论文章: 该算法基于GraphSAGE算法。 最初,GraphSAGE用于仅具有一个类型节点的同质图。 在建立推荐...
  • GraphSAGE精读

    2021-05-11 22:13:05
    创新点:提出GraphSAGE 提出原因:GCN属于直推式(transductive learning)学习,而很多现实中的应用需要很快的对未见过的顶点或是全新的图(子图)生成embedding。这种归纳推断(inductive learning)的能力对于高吞吐...

    一、Deep Neural Networks for YouTube Recommendations
    引自博客:https://blog.csdn.net/yyl424525/article/details/100532849

    • 创新点:提出GraphSAGE
    • 提出原因:GCN属于直推式(transductive learning )学习,而很多现实中的应用需要很快的对未见过的顶点或是全新的图(子图)生成embedding。这种归纳推断(inductive learning)的能力对于高吞吐的机器学习系统来说很重要,这些系统都运作在不断演化的图上,而且时刻都会遇到未见过的顶点。既然新增的节点,一定会改变原有节点的表示,那么为什么一定要得到每个节点的一个固定的表示呢?何不直接学习一种节点的表示方法。去学习一个节点的信息是怎么通过其邻居节点的特征聚合而来的。 学习到了这样的“聚合函数”,而我们本身就已知各个节点的特征和邻居关系,我们就可以很方便地得到一个新节点的表示了。GCN等transductive的方法,学到的是每个节点的一个唯一确定的embedding; 而GraphSAGE方法学到的node embedding,是根据node的邻居关系的变化而变化的,也就是说,即使是旧的node,如果建立了一些新的link,那么其对应的embedding也会变化,而且也很方便地学到。
    • 方法核心:GraphSAGE不是试图学习一个图上所有node的embedding,而是学习一个为每个node产生embedding的映射关系(文中称为aggregator functions 聚合函数)。(embedding可以理解为高维度空间特征映射到低维度流形特征的过程)

      其运行流程如上图所示,可以分为三个步骤:
      1)对图中每个顶点邻居顶点进行采样,因为每个节点的度是不一致的,为了计算高效, 为每个节点采样固定数量的邻居
      2)根据聚合函数聚合邻居顶点蕴含的信息
      3)得到图中各顶点的向量表示供下游任务使用
      1. Embedding generation (i.e., forward propagation) algorithm        生成节点embedding的前向传播算法
      前向传播描述了如何使用聚合函数对节点的邻居信息进行聚合,从而生成节点embedding:

      在每次迭代k(或搜索深度),顶点从它们的局部邻居聚合信息,并且随着这个过程的迭代,顶点会从越来越远的地方获得信息。
      算法1描述了在整个图上生成embedding的过程,其中

      实验发现,K不必取很大的值,当K=2时,效果就很好了。至于邻居的个数,大约每次只需要扩展20来个邻居时获得较高的性能。
      2. 聚合函数的选取

      在图中顶点的邻居是无序的,所以希望构造出的聚合函数是对称的(即也就是对它输入的各种排列,函数的输出结果不变),同时具有较高的表达能力。 聚合函数的对称性(symmetry property)确保了神经网络模型可以被训练且可以应用于任意顺序的顶点邻居特征集合上。

      Mean aggregator
      mean aggregator将目标顶点和邻居顶点的第 k − 1层向量拼接起来,然后对向量的每个维度进行求均值的操作,将得到的结果做一次非线性变换产生目标顶点的第 k 层表示向量。文中用下面的式子替换算法1中的4行和5行得到GCN的inductive变形:



      3.Learning the parameters of GraphSAGE (有监督和无监督)参数学习
      在定义好聚合函数之后,接下来就是对函数中的参数进行学习。文章分别介绍了无监督学习和监督学习两种方式

       

    展开全文
  • GraphSAGE-master.zip

    2020-03-08 23:39:08
    GraphSAGE源代码,供参考学习。目前大多数图嵌入方法在训练过程中需要图中所有节点参与,属于直推学习(transductive),无法直接泛化到之前未见的节点。本文提出一种适用于大规模网络的归纳式(inductive)模型-...
  • 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 前向传播算法步骤
    在这里插入图片描述

    h v k \mathbf{h}_{v}^{k} hvk:节点v通过聚合k层邻居节点后得到的embedding表示。
    当k=1时,算法第3~7行,用所有节点的“深度+1”层邻居的 h v 0 \mathbf{h}_{v}^{0} hv0去更新所有节点 v v v h v 1 \mathbf{h}_{v}^{1} hv1,
    当k=2时,算法第3~7行,对于所有节点 v v v,用节点 v v v深度+1邻居 u u u h u 1 \mathbf{h}_{u}^{1} hu1聚合去更新所有节点v的 h v 2 \mathbf{h}_{v}^{2} hv2

    个人感觉论文里 h u k − 1 \mathbf{h}_{u}^{k-1} huk1这个公式有问题,按论文中图1,如果把当前节点v看做第0层,那么应该是用其第1层,以及第2层的节点特征去聚合,但是他这里写每次都是用k-1层去聚合,很迷。

    GraphSAGE mini-batch 前向传播
    在这里插入图片描述
    采样过程
    假设有batch集合 { x v , ∀ v ∈ B } \left\{\mathbf{x}_{v}, \forall v \in \mathcal{B}\right\} {xv,vB},设定聚合深度 K K K,并认为集合 B \mathcal{B} B的节点位于深度 K K K处。
    当k=K时,算法3~6行,将集合 B \mathcal{B} B和他随机采样的第K层的邻居相或 | 加入集合 B k − 1 \mathcal{B}^{k-1} Bk1
    当k=K-1时,算法3~6行,将集合 B k − 1 \mathcal{B}^{k-1} Bk1和他随机采样的第K-1层的邻居相或加入集合 B k − 2 \mathcal{B}^{k-2} Bk2
    这样集合 B 0 \mathcal{B}^{0} B0包含 B K . . . 1 \mathcal{B}^{K...1} BK...1的所有节点,也是后面聚合操作会用到的所有节点。

    聚合过程
    h u k \mathbf{h}_{u}^{k} huk:节点u通过聚合k层邻居节点后得到的embedding表示
    当k=1时,算法第10~14行,用 B 1 \mathcal{B}^{1} B1里所有节点的"当前深度-1"层邻居节点(同时也在 B 1 \mathcal{B}^{1} B1里的)去更新 h u 1 \mathbf{h}_{u}^{1} hu1,此时第0层没有"深度-1"层邻居故不参与更新 h u 1 \mathbf{h}_{u}^{1} hu1
    当k=2时,算法第10~14行,用 B 2 \mathcal{B}^{2} B2里所有节点"当前深度-1"层邻居节点(同时也在 B 2 \mathcal{B}^{2} B2里的)的 h u 1 \mathbf{h}_{u}^{1} hu1去更新 B 2 \mathcal{B}^{2} B2里所有节点的 h u 2 \mathbf{h}_{u}^{2} hu2此时第0层节点没有 h u 1 \mathbf{h}_{u}^{1} hu1,故第1层节点不会产生 h u 2 \mathbf{h}_{u}^{2} hu2聚合。

    当k=K时,算法第10~14行,对于 B K \mathcal{B}^{K} BK里的所有节点"当前深度-1"层邻居的 h u K − 1 \mathbf{h}_{u}^{K-1} huK1去更新 B K \mathcal{B}^{K} BK里所有节点的 h u K \mathbf{h}_{u}^{K} huK

    聚合过程直接上图:

    聚合过程图示

    无监督损失函数
    J ( z u ) = − log ⁡ ( σ ( z u T z v ) ) − Q ⋅ E v n ∼ P n ( v ) log ⁡ ( σ ( − z u T z v n ) ) J\left(z_{u}\right)=-\log \left(\sigma\left(z_{u}^{T} z_{v}\right)\right)-Q \cdot E_{v_{n} \sim P_{n}(v)} \log \left(\sigma\left(-z_{u}^{T} z_{v_{n}}\right)\right) J(zu)=log(σ(zuTzv))QEvnPn(v)log(σ(zuTzvn))
    z v z_{v} zv:节点u定长的邻居节点
    P n P_{n} Pn:负采样分布
    Q Q Q:负采样个数
    z v n \boldsymbol{z}_{v_{n}} zvn:负采样节点

    什么是负采样?
    在这里插入图片描述
    采样里目标节点 z v z_{v} zv较远的点就叫做负采样。
    无监督损失函数的意思就是希望节点与较近的节点的向量相似,而与较远的节点不相似。

    展开全文
  • GraphSage 图向量

    2021-01-27 16:36:43
    目录1 目的和思想2 模型原理2.1 Aggregator Architectures 聚集器架构2.1.1 Mean aggregator2.1.2 LSTM aggregator2.1.3 Pooling aggregator2.2 loss 函数3 GraphSage 总结 1 目的和思想 GraphSage 模型的目的:将图...
  • GraphSage vs GCN

    2020-11-20 14:36:11
    https://towardsdatascience.com/an-intuitive-explanation-of-graphsage-6df9437ee64f https://towardsdatascience.com/using-graphsage-to-learn-paper-embeddings-in-cora-a94bb1e9dc9d ... ...
  • GraphSAGE例子讲解

    2021-06-09 15:45:12
    图中代码第2行:遍历K层graphsage 第3行:遍历每层的所有节点v 第4行:聚合v节点所有邻居节点的信息,得到v节点在第i层的邻居向量 第5行:拼接v在上一层的特征向量和v节点在第i层的邻居向量 例子: 部分采样...
  • GraphSAGE学习心得

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

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

    2020-03-27 12:30:35
    参考论文:Inductive Representation Learning on Large Graphs ...What is GraphSAGE? MotIvation: 先前的工作如GCN等,需要把所有节点输入网络进行训练才能得到结点的embedding,对于新加入...
  • <div><p>This may be one of a number of PRs to come around reproducibility - this adds a bit of setup for testing for reproducibility, and updates various classes involved in unsupervised GraphSAGE. ...
  • GraphSAGE_biji

    2019-09-08 23:26:16
    Graph SAGE:工业应用,是目前所有工业上...GraphSAGE(Graph SAmple and aggreGatE)框架,工业应用,附带python 开源实现。归纳式学习,可以泛化到没有未参与训练的节点上。卷积部分可以有很多种,比如平均,pooling...
  • 论文笔记之GraphSAGE

    2020-10-12 16:15:06
    论文笔记之GraphSAGE 一、本文贡献 提出了一个inductive归纳式GraphSAGE方法,能够利用节点特征高效地为未出现过的节点生成节点嵌入embedding. (Embedding:从原始数据中通过一系列神经网络映射操作后提取出来...
  • 发表会议:NeurIPS2017 文章目录1. GraphSAGE和GCN2. GraphSAGE如何进行Inductive Learning ...GCN和GraphSAGE几乎同时出现,GraphSAGE是GCN在空间域上的实现,似乎两者并没有太大区别。实际上,GraphSAGE解决了GC..
  • GNN之GraphSAGE学习

    千次阅读 2019-05-28 14:31:42
    斯坦福工程:http://snap.stanford.edu/graphsage/ 文末有paper和code:https://blog.csdn.net/imark11/article/details/78698844 代码解析:https://www.cnblogs.com/shiyublog/p/9819086.html ...
  • QA派|初识GraphSAGE

    2020-08-15 19:53:09
    QA派|初识GraphSAGE 图网络中节点的低维embedding,对于各类预测、图分析任务都非常有用;相对于要求一整张图作为输入的GCN,能分批训练的GraphSAGE在工业界似乎更加常用。本文通过问答的形式,来对GraphSAGE有个...
  • GraphSAGE源码分析报告

    2021-01-31 18:22:12
    GraphSAGE源码分析报告 一、 Graphsage简介 0. 什么是深度学习? 深度学习是一类机器学习算法,它使用多层渐进地从原始输入中提取高级特征。例如,在图像处理中,较低的层可能识别边缘,而较高的层可能识别与人类...
  • GraphSAGE代码详解-pytorch版本1. GraphSAGE导入2. 代码解析2.1 加载数据2.2 Unsupervised Loss2.3 Models2.4 评估与模型使用2.5 Main参考资料 1. GraphSAGE导入 论文标题:Inductive Representation Learning on ...
  • 阅读笔记--GraphSAGE

    2020-08-28 19:52:15
    目录一、简介二、GraphSAGE2.1 概览GraphSAGE:Graph Sample and aggreGatE三个步骤:2.2 Embedding的生成Forward propagation:Neighborhood definition2.3 Learning the parameters of GraphSAGE基于图的无监督...
  • 文章目录Abstract1 IntroductionPresent work2 Related workFactorization-based embedding approachesSupervised learning over graphsGraph convolutional networks3 Proposed method: GraphSAGE3.1 Embedding ...
  • GraphSAGE论文阅读笔记

    千次阅读 2019-07-31 14:52:26
    论文: Inductive Representation Learning on Large Graphs Motivation 大多数graph embedding框架是transductive(直推式的), 只能对一个固定的图生成embedding...相对的,GraphSAGE是一个inductive(归纳式)框架,...
  • GraphSAGE模型 paper:《Inductive Representation Learning on Large Graphs》。 两个比较重要的概念: 1. transductive:直推式学习,训练时所有节点(数据)均可见 2. inductive:归纳学习,用于测试的节点...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,745
精华内容 698
关键字:

graphsage