精华内容
下载资源
问答
  • graph2vec:使用word2vec算法的graph2vec算法的简单,简单的实现
  • Graph2Vec ⠀ 抽象 关于图结构化数据的表示学习的最新工作主要集中在学习图子结构(例如节点和子图)的分布式表示。 但是,许多图形分析任务(例如图形分类和聚类)要求将整个图形表示为固定长度的特征向量。 虽然...
  • 嵌入表示学习是当下研究热点,从word2vec,到node2vec, 到graph2vec,出现大量X2vec的算法。但如何构建向量嵌入理论指导算法设计?最近RWTH Aachen大学的计算机科学教授ACM Fellow Martin Grohe教授给了《X2vec: ...
  • graph2vec 通过Theano(如果您的GPU不错,可以使用GPU),minibatch和AdaGrad来学习节点嵌入。 通过运行安装 python setup.py install 或者 pip install graph2vec 数据应该在用空格隔开的描述边缘的文件中,...
  • 论文地址:graph2vec: Learning Distributed Representations of Graphs github代码:https://github.com/benedekrozemberczki/graph2vec 这篇文章对论文做了简单解读:...

    论文地址:graph2vec: Learning Distributed Representations of Graphs

    github代码:https://github.com/benedekrozemberczki/graph2vec

    这篇文章对论文做了简单解读:https://blog.csdn.net/qq_39388410/article/details/103895874

    下面是代码部分,代码的关键部分我做了注释,子图抽取用的是Weisfeiler-Lehman算法

    """Graph2Vec module."""
    
    import json
    import glob
    import hashlib
    import pandas as pd
    import networkx as nx
    from tqdm import tqdm
    from joblib import Parallel, delayed
    #from param_parser import parameter_parser
    from gensim.models.doc2vec import Doc2Vec, TaggedDocument
    
    ### 默认参数 可调
    input_path = "./dataset/"
    output_path = "./features/ret.csv"
    dimensions = 128
    workers =4
    epochs =10
    min_count = 5
    wl_iterations = 2
    learning_rate = 0.025
    down_sampling = 0.0001
    
    
    class WeisfeilerLehmanMachine: ###WeisfeilerLehman 子图抽取
        """
        Weisfeiler Lehman feature extractor class.
        """
        def __init__(self, graph, features, iterations):
            """
            Initialization method which also executes feature extraction.
            :param graph: The Nx graph object.
            :param features: Feature hash table.
            :param iterations: Number of WL iterations.
            """
            self.iterations = iterations
            self.graph = graph
            self.features = features
            self.nodes = self.graph.nodes()
            self.extracted_features = [str(v) for k, v in features.items()]
            self.do_recursions()
    
        def do_a_recursion(self):
            """
            The method does a single WL recursion.
            :return new_features: The hash table with extracted WL features.
            """
            new_features = {}
            for node in self.nodes:
                nebs = self.graph.neighbors(node) ##取邻居节点
                degs = [self.features[neb] for neb in nebs] ## 取邻居节点的label/attribute,这里其实是节点的度
                features = [str(self.features[node])]+sorted([str(deg) for deg in degs]) ## 添加上自己的度 传播模型
                features = "_".join(features) ## 拼接起来 3_2_3_3
                hash_object = hashlib.md5(features.encode())
                hashing = hash_object.hexdigest()  ## Md5 映射节点的label/attribute  aec8787e7f0dd7c71c319a65ba4d670f
                new_features[node] = hashing ## 更新节点
            self.extracted_features = self.extracted_features + list(new_features.values())
            return new_features
    
        def do_recursions(self):
            """
            The method does a series of WL recursions.
            """
            for _ in range(self.iterations):
                self.features = self.do_a_recursion()
    
    def dataset_reader(path): ## 数据读取 返回networkx类型的graph,所有节点的度的字典 图的编号name
        """
        Function to read the graph and features from a json file.
        :param path: The path to the graph json.
        :return graph: The graph object.
        :return features: Features hash table.
        :return name: Name of the graph.
        """
        name = path.strip(".json").split("\\")[-1] ### window下"\\",linux下“/”
        data = json.load(open(path))
        graph = nx.from_edgelist(data["edges"])
    
        if "features" in data.keys():
            features = data["features"]
        else:
            features = nx.degree(graph)
    
        features = {int(k): v for k, v in features.items()}
        return graph, features, name
    
    def feature_extractor(path, rounds):   ### 数据转换成DOC
        """
        Function to extract WL features from a graph.
        :param path: The path to the graph json.
        :param rounds: Number of WL iterations.
        :return doc: Document collection object.
        """
        graph, features, name = dataset_reader(path)
        machine = WeisfeilerLehmanMachine(graph, features, rounds)
        doc = TaggedDocument(words=machine.extracted_features, tags=["g_" + name])
        return doc
    
    def save_embedding(output_path, model, files, dimensions):
        """
        Function to save the embedding.
        :param output_path: Path to the embedding csv.
        :param model: The embedding model object.
        :param files: The list of files.
        :param dimensions: The embedding dimension parameter.
        """
        out = []
        for f in files:
            identifier = f.split("\\")[-1].strip(".json")  ### window下"\\",linux下“/”
            out.append([int(identifier)] + list(model.docvecs["g_"+identifier]))
        column_names = ["type"]+["x_"+str(dim) for dim in range(dimensions)]
        out = pd.DataFrame(out, columns=column_names)
        out = out.sort_values(["type"])
        out.to_csv(output_path, index=None)
    
    def main():
        """
        Main function to read the graph list, extract features.
        Learn the embedding and save it.
        :param args: Object with the arguments.
        """
        graphs = glob.glob(input_path + "*.json")
        print("\nFeature extraction started.\n")
        ### document_collections是一个list,每个ele都是一个TaggedDocument([],tags=[])
        ###每个ele是长这样,有extracted_features 和 tags组成
        '''
        TaggedDocument(words=['1', '1', '1', '1', '1', '2', '2', '2', '2', '2', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
        'aec8787e7f0dd7c71c319a65ba4d670f', 'aec8787e7f0dd7c71c319a65ba4d670f', '711b064fd221cccd34a14f29b696a265',
        '68bea2bc149d4ee3548d35a2e6216542', '711b064fd221cccd34a14f29b696a265', '5c960b2e285107aff4a29ddbc53aa94e', 
        'aec8787e7f0dd7c71c319a65ba4d670f', '711b064fd221cccd34a14f29b696a265', '68bea2bc149d4ee3548d35a2e6216542',
        '2220178a6d449ba0a24980f4dfab8cd8', '3d34cbdc7cb225501d23e26f3d2ed945', 'c1544793797909a2c72ad52bdb0487d2', 
        '25f4b183e297058b59282613e231b5af', '5c960b2e285107aff4a29ddbc53aa94e', '648af13d92bf7d1019e0af47c8e71074',
        '648af13d92bf7d1019e0af47c8e71074', 'f0f421418433ba3cb592238eb7e51441', 'ab35e84a215f0f711ed629c2abb9efa0',
        'ab35e84a215f0f711ed629c2abb9efa0', 'ab35e84a215f0f711ed629c2abb9efa0', 'ab35e84a215f0f711ed629c2abb9efa0',
        '56218143711ad0d943613e81debfcaf6', 'ba32ef1397dd62a5661bff7d0c1bbd75', '8fe9ae5843120923a0dc4469a3089eef', 
        '16f04b8e020bce1ae04100dbd9f1aa88', 'b7a5cac1ba5e57afa69f50128cc2d95b', '8d889315ef6d7e55846fdb69f15fd1b7',
        'd9b9b6f3ee62f5ef7059770fd8903538', 'b7a5cac1ba5e57afa69f50128cc2d95b', '16f04b8e020bce1ae04100dbd9f1aa88',
        '184b020bdf857802edb40b0ebb5bd069', 'eb453d564c2ad11ed23ea2af7a5a4a7a', 'c754cc7c963e0b33df17b62e3c6a2620',
        '8e5f9e44897e7115e6f5c363046cde09', '63067dd99d3136f686fa814590355cf6', 'dcd616306a4cee9df958df008aae4b69',
        '7e4162c3ff0e44efc7826087c413e1b8', '537179ae9dc33f665a2eca172eeba096', 'b4b3107ce9aae441f8fd4a61ed1fecfb',
        'b4b3107ce9aae441f8fd4a61ed1fecfb', 'b4b3107ce9aae441f8fd4a61ed1fecfb', 'b4b3107ce9aae441f8fd4a61ed1fecfb'], tags=['g_0']
        '''
        document_collections = Parallel(n_jobs=workers)(delayed(feature_extractor)(g,wl_iterations) for g in tqdm(graphs))
        
        print("\nOptimization started.\n")
    
        model = Doc2Vec(document_collections,
                        vector_size=dimensions,
                        window=0,
                        min_count=min_count,
                        dm=0,
                        sample=down_sampling,
                        workers=workers,
                        epochs=epochs,
                        alpha=learning_rate)
    
        save_embedding(output_path, model, graphs,dimensions)
    
    if __name__ == '__main__':
        main()

    结果输出对每个graph的一个128维的向量表示,后面会用DGL库提供的不同类别的图做一个简单图聚类的Demo

    展开全文
  • 源码链接:https://github.com/MLDroid/graph2vec_tf TL;DR 目前图表示学习方法主要是学习图中节点或者子图的隐含向量,但现实中很多任务例如图分类或者聚类都需要将整个图编码成固定长度的向量;此外,以前基于图...

    原文链接:https://dreamhomes.github.io/posts/202101181459.html


    文章链接:https://arxiv.org/pdf/1707.05005.pdf

    源码链接:https://github.com/MLDroid/graph2vec_tf

    TL;DR

    目前图表示学习方法主要是学习图中节点或者子图的隐含向量,但现实中很多任务例如图分类或者聚类都需要将整个图编码成固定长度的向量;此外,以前基于图核的方法由于使用自定义特征因此通用性较差。本文中提出的一种无监督学习的图编码框架 graph2vec 可以编码任意大小的图,可以应用在downstream 的图分类或者聚类任务中;

    Problem Statement

    给定图集合 G={G1,G2,}\mathbf{G} = \{G_1, G_2, \cdots \} 和向量编码维度 δ\delta,目标是学习到每个图 GiG_iδ\delta 维表示向量;

    给定一个图 G=(N,E,λ)G=(N, E, \lambda) 和子图 sg=(Nsg,Esg,λsg)sg = (N_{sg}, E_{sg}, \lambda_{sg}),其中 λ\lambda 表示 λ:N\lambda : N \rightarrow \ell 节点对应的标签,sgsgGG 的子图如果存在单射函数 μ:NsgN\mu : N_{sg} \rightarrow N ,满足 (n1,n2)Esg(n_1, n_2) \in E_{sg} 如果(μ(n1),μ(n2))E(\mu(n_1), \mu(n_2)) \in E。论文中用到的是 rooted subgraph : 节点 nn 且深度为 dd 的子图为节点 nn d-hop 之内所有的节点和边。

    Model / Algorithm

    文章的主要思路是受 doc2vec 启发的,因此首先简单介绍下 doc2vec 的思路,再介绍 graph2vec

    doc2vec

    给定文档 D={d1,d2,...,dN}D=\{d_1, d_2, ..., d_N\} 及其对应文档 diDd_i \in D 采样的单词 c(di)={w1,w2,...,wli}c(d_i) = \{w_1, w_2, ..., w_{li}\},doc2vec 优化的目标似然函数为
    j=1lilogPr(wjdi) \sum_{j=1}^{l_{i}} \log \operatorname{Pr}\left(w_{j} \mid d_{i}\right)
    其中Pr(wjdi)\operatorname{Pr}\left(w_{j} \mid d_{i}\right) 定义为
    exp(dwj)wVexp(dw)\frac{\exp \left(\vec{d} \cdot \vec{w}_{j}\right)}{\sum_{w \in \mathcal{V}} \exp (\vec{d} \cdot \vec{w})}
    然后训练过程中使用了负采样方法优化。

    graph2vec

    按照 doc2vec 的思路用到图结构上,论文中提出的模型采样思路为:

    以 graph 代替 document,以 rooted subgraph 代替 work,整体的算法流程如下:

    算法主要包括两部分:生成 rooted subgraphs,图编码训练过程;下面简单说明下 rooted graph 生成过程。

    Extracting Rooted Subgraphs
    生成 rooted subgraph 的主要过程为 WL relabeliing process,详情可参考文章 Weisfeiler-lehman graph kernels,主要思路是把当前节点 nn 及其 dhopd-hop 映射到一个子图节点集合中国;下面👇 直接看看论文中的生成 subgraph 算法流程:

    负采样和优化

    由于训练过程中整个子图词汇表规模较大,因此论文中采用负采样的方法提高效率,即在训练图 G1G_1 时,选择不属于 GiG_i 子图集的 kk 个子图样本 cSGvocab ,k<<SGvocab  , cc={}c^{\prime} \subset S G_{\text {vocab }}, k<<\left|S G_{\text {vocab }}\right| \text { , } c \cap c^{\prime}=\{\}

    最后使用 SGD 优化器来训练模型参数。

    Experiments

    对于图分类和聚类任务算法的实验结果如下所示;

    联系作者

    展开全文
  • Graph2Vec运行

    2021-01-13 11:53:01
    conda create -n graph2vec python==3.5 conda activate graph2vec python src/graph2vec.py 可以根据提示一步步安装上面的包 pip install xxx== 下载慢的话指定阿里云镜像比如 pip install networkx -i ...

    G2V源码

    N2V源码

    G2V

    环境搭建

    环境要求

    The codebase is implemented in Python 3.5.2 | Anaconda 4.2.0 (64-bit). Package versions used for development are just below.
    
    jsonschema        2.6.0
    tqdm              4.28.1
    numpy             1.15.4
    pandas            0.23.4
    texttable         1.5.0
    gensim            3.6.0
    networkx          2.4
    joblib            0.13.0
    logging           0.4.9.6  

    搭建

    根据要求已知是3.5的环境,需要安装的包也在上面

    #以下全是python35的解决方法
    conda create -n graph2vec python==3.5
    conda activate graph2vec
    python src/graph2vec.py
    
    可以根据提示一步步安装上面的包
    pip install xxx==
    下载慢的话指定阿里云镜像比如
    pip install networkx -i https://mirrors.aliyun.com/pypi/simple/
    
    但是在安装gensim 时候出错
    ERROR: Cannot uninstall 'certifi'. It is a distutils installed project and thus we cannot accurately determine which files belong to it which would lead to only a partial uninstall.
    
    解决:降级pip
     pip install pip==9.0.1 -i https://mirrors.aliyun.com/pypi/simple/
    
    
    又出现了一个新的错
    ImportError: cannot import name 'Type'
    
    解决:安装低版本scipy
     pip install scipy==1.2.1
    
    
    

    代码运行

    The following commands learn an embedding of the graphs and writes it to disk. The node representations are ordered by the ID. Creating a graph2vec embedding of the default dataset with the default hyperparameter settings. Saving the embedding at the default path.
    
    $ python src/graph2vec.py
    Creating an embedding of an other dataset. Saving the output in a custom place.
    
    $ python src/graph2vec.py --input-path dataset/ --output-path features/nci2.csv
    Creating an embedding of the default dataset in 32 dimensions.
    
    $ python src/graph2vec.py --dimensions 32

    结果

    N2V

    环境

    conda create -n node2vec python=3.6
    conda activate node2vec
    
    pip install node2vec -i https://mirrors.aliyun.com/pypi/simple/

    代码运行

    python example.py
    cd node2vec
    python node2vec.py #vim将from .parallel import 改成from parallel import 
    

    展开全文
  • 前一篇整理了3种常用的图嵌入方法,DeepWalk,LINE和Node2vec。Structural Deep Network Embeddings(结构深层网络嵌入,SDNE)的不同之处在于,它并不是基于随机游走的思想,在实践中比较稳定。 主要思路如上图,...

    在这里插入图片描述
    SDNE
    前一篇整理了3种常用的图嵌入方法,DeepWalk,LINE和Node2vec。Structural Deep Network Embeddings(结构深层网络嵌入,SDNE)的不同之处在于,它并不是基于随机游走的思想,在实践中比较稳定。

    主要思路如上图,会将节点向量 si 作为模型的输入,通过自编码器对这个向量进行降维压缩 zi,然后再重建特征。其损失函数定义为:
    O2=sisi22O_2=\sum ||s_i'-s_i||^2_2

    因为输入的是邻接矩阵,所以这样的重构能够使得结构相似的顶点具有相似的embedding表示向量。所以实际上通过重建学习到的是二阶相似度。
    在这里插入图片描述
    但是与LINE相似,SDNE也想保留一阶和二阶相似度,而且是想要同时优化,以同时捕获局部成对相似性和节点邻域结构的相似性。对于一阶相似度的计算,将架构变成如上图,由左右两个自编码器组成。一阶相似度的目标是计算节点间的相似性,那么可以利用起中间的嵌入得到的隐层向量z,然后计算左侧嵌入和右侧嵌z入间的距离。并可以用拉普拉斯矩阵优化一下计算:
    O1=z1z222==2tr(ZTLZ)O_1=\sum ||z_1-z_2||^2_2==2tr(Z^TLZ)

    再加上正则项reg,总损失为:L=O2+αO1+vOregL=O_2+\alpha O_1+vO_{reg}论文出自KDD 2016的《Structural Deep network Embedding》,作者的完整代码code开源:https://github.com/suanrong/SDNE

    def __make_loss(self, config):
            def get_1st_loss_link_sample(self, Y1, Y2):
                return tf.reduce_sum(tf.pow(Y1 - Y2, 2))
            def get_1st_loss(H, adj_mini_batch):
                D = tf.diag(tf.reduce_sum(adj_mini_batch,1))
                L = D - adj_mini_batch ## 拉普拉斯矩阵
                return 2*tf.trace(tf.matmul(tf.matmul(tf.transpose(H),L),H))
    
            def get_2nd_loss(X, newX, beta):
                B = X * (beta - 1) + 1
                return tf.reduce_sum(tf.pow((newX - X)* B, 2))
    		#对w和b的正则化项
            def get_reg_loss(weight, biases):
                ret = tf.add_n([tf.nn.l2_loss(w) for w in weight.itervalues()])
                ret = ret + tf.add_n([tf.nn.l2_loss(b) for b in biases.itervalues()])
                return ret
                
            #总损失函数
            self.loss_2nd = get_2nd_loss(self.X, self.X_reconstruct, config.beta)
            self.loss_1st = get_1st_loss(self.H, self.adjacent_matriX)
            self.loss_xxx = tf.reduce_sum(tf.pow(self.X_reconstruct,2)) 
            self.loss_reg = get_reg_loss(self.W, self.b) 
            return config.gamma * self.loss_1st + config.alpha * self.loss_2nd + config.reg * self.loss_reg
    

    其实似乎这个建模的思路和矩阵分解是差不多的,只是在降维时用的不是矩阵分解,而是自编码器,并融入了一阶与二阶的概念。

    在这里插入图片描述
    Graph2vec
    出自MLGWorkshop 2017的《graph2vec: Learning Distributed Representations of Graphs》
    直接对整个图进行嵌入。一般比较容易想到的做法是Graph Pooling,著名的方法有Graph Coarsening,即用其他处理节点Embedding的方法处理后,然后逐渐合并聚类节点比如同一个class就归为一个超节点,最后变成一个向量。还有一类方法是node selection,即选部分的节点来代替。还有更直接的方法是直接max或者mean咯。

    而Graph2Vec原理上和DeepWalk差不多,也是尝试借用word2vec来训练,只是这次为了嵌入整张图,所以尝试利用子图来训练。类似文档嵌入doc2vec,通过最大化作为输入的文档,来预测随机单词的可能性,Graph2vec预测图中子图的概率。

    • 采样子图。为了提高效率,采样只选当前节点周围的邻接节点,构成子图sg。
    • skip-gram。最大化输入图子图的概率J(Φ)=logP(sgn(d)Φ(G))J(\Phi)=-log P(sg_n^{(d)}|\Phi(G)),d为度,sg为子图。
      在这里插入图片描述
    #把图处理成doc2vec问题的形式就可以用gensim了
    from gensim.models.doc2vec import Doc2Vec, TaggedDocument
    
    #得到Wisfeiler-Lehman特征
    def do_a_recursion(self):
            new_features = {}
            for node in self.nodes:
                nebs = self.graph.neighbors(node)
                degs = [self.features[neb] for neb in nebs]
                features = [str(self.features[node])]+sorted([str(deg) for deg in degs])
                features = "_".join(features)
                hash_object = hashlib.md5(features.encode())
                hashing = hash_object.hexdigest()
                new_features[node] = hashing
            self.extracted_features = self.extracted_features + list(new_features.values())
            return new_features
    

    作者开源:https://github.com/benedekrozemberczki/graph2vec

    在这里插入图片描述

    Graph Generative Adversarial Nets(GraphGAN)
    主要是将GAN的思想引入到图领域,简单来说也是和GAN一样,分为生成器和判别器:

    • 生成器:在找网络中一个节点邻居的概率分布,也就是一个节点的连接偏好。G(vvc)=exp(gvTgvc)vvcexp(gvTgvc)G(v|v_c)=\frac{exp(g^T_v g_{v_c})}{\sum_{v \neq v_c}exp(g^T_v g_{v_c}) }即用softmax函数,输出邻居是每个节点的概率
    • 判别器:以网络中的边为出发点,衡量两个节点之间是否有边关系。D(v,vc)=σ(dvTdvc)D(v,v_c)=\sigma(d^T_v d_{v_c})d分别代表两个节点的表示向量,如果v是采样的应该给高分,如果是生成的应该是低分。

    值得注意的是在生成器的G中,如果要对每个节点都算一遍显然不划算,所以作者的解决方案是以某个节点为根节点BFS遍历形成一棵生成树(其实挺像随机游走的),然后计算树中两个节点之间的边对应的概率。


    Graph Neural Network
    图神经网络(Graph Neural Network, GNN)也是很好的图嵌入方法。GNN包括图卷积神经网络(GCN),图注意力网络(GAT),Graph LSTM等等,虽然技术上还是和CV,NLP领域内的方法很像。。。

    图表征学习的局限

    • 参数量大,每个顶点都有唯一的标准向量
    • 不能给未出现的顶点生成表征向量
    • 部分图表征学习不能融合属性特征等信息

    最后献上很全很全的论文集:https://github.com/benedekrozemberczki/awesome-graph-classification

    展开全文
  • (Text2Vec,Image2Vec,Video2Vec,Face2Vec,Bert2Vec,Inception2Vec,Code2Vec,LegalBert2Vec等) 有很多方法可以从数据中提取向量。 该库旨在以简单的方式引入所有最新模型,从而轻松地对数据进行矢量化处理...
  • 2.3 Node2vec 出自2016KDD,《node2vec: Scalable Feature Learning for Networks》 Node2vec 可以看作是对 DeepWalk 的一种更广义的抽象,主要是改进DeepWalk的随机游走策略。由于普通的随机游走无法很好地保留...
  • graph embedding之node2vec

    千次阅读 2019-04-24 23:52:23
    在上一篇文章中介绍了DeepWalk,这是第一次将word2vec的思路引入到graph或network中。这篇文章继续介绍graph embedding之node2vec,附个链接http://snap.stanford.edu/node2vec/,其中有文章也有代码。 一、基本...
  • word2vec图 此可视化通过高维word2vec嵌入构建最邻近的图形。 可用图 用于此可视化的数据集来自 ,具有6B令牌,400K词汇表,300维向量。 在此可视化中,当相应单词的向量之间的,在单词之间形成边缘。 具有非单词...
  • 文章目录[Graph Embedding] node2vecIntroductionnode2vec算法原理1. 目标函数2. 节点序列采样策略3. 参数解析4. 伪代码 [Graph Embedding] node2vec 在前面两篇文章中,我们分别介绍了DeepWalk 和 LINE,其中Deep...
  • Graph探索之word2vec

    2019-11-26 15:23:34
    谷歌无监督神器之word2vec 本文参考:https://blog.csdn.net/peghoty/article/details/37969979   word2vec是用来生成词向量的工具,是一种无监督的学习方法,将词语数字化后就可以做很多处理了。此处的词语向量化...
  • word2vec和由其衍生出的item2vec是embedding技术的基础性方法,但二者都是建立在“序列”样本(比如句子、推荐列表)的基础上的。而在互联网场景下,数据对象之间更多呈现的是图结构。 参考材料,详细解读见链接。 ...
  • Graph Embedding】node2vec:算法原理,实现和应用

    万次阅读 多人点赞 2019-02-12 20:12:13
    node2vec则是一种综合考虑dfs邻域和bfs邻域的graph embedding方法。 DeepWalk:算法原理,实现和应用 LINE:算法原理,实现和应用 简单来说,node2vec是deepwalk的一种扩展,可以看作是结合了dfs和bfs随机游走的...
  • node2vec是一种综合考虑DFS邻域和BFS邻域的graph embedding方法,可以看作是deepwalk的一种扩展,是结合了DFS和BFS随机游走的deepwalk。 node2vec的同质性和同构性 (1)网络的同构性是指距离近的节点的Embedding的...
  • Graph Embedding】: node2vec算法

    千次阅读 2019-03-27 23:33:42
    论文“node2vec: Scalable Feature Learning for Networks”发表在kdd2016,文章提出了一个新的graph embedding 论文地址:https://www.kdd.org/kdd2016/papers/files/rfp0218-groverA.pdf 作者提供的代码地址:...
  • hw2vec-源码

    2021-02-19 03:40:43
    目录结构(临时)图如下所示: 库代码在hw2vec文件夹中: hw2vec / hw2graph.py:用于从硬件设计生成图形对象的代码。 hw2vec / graph2vec:图训练教练和模型的代码。 用例示例存储在examples文件夹中: examples / ...
  • node2vec是一种综合考虑DFS邻域和BFS邻域的graph embedding方法。简单来说,node2vec可以看作是deepwalk的一种扩展,可以看作是结合了DFS和BFS随机游走的deepwalk。Node2vec通过调整随机游走权重的方法使graph ...
  • 原文链接:Stanford Node2Vec 概括:综合使用DFS和BFS的思想进行neighbours的搜索(因为要保证neighbours在embedding后的空间内足够的“近”),保证共现的neighbours(DFS,类比句子中相邻的单词)和结构相似(BFS...
  • node2vec是一种综合考虑DFS邻域和BFS邻域的graph embedding方法。简单来说,可以看作是deepwalk的一种扩展,是结合了DFS和BFS随机游走的deepwalk。node2vec通过调整方向的参数来控制模型更倾向BFS还是DFS。 BFS更能...
  • Graph Embedding】: metapath2vec算法

    千次阅读 2019-03-17 21:54:23
    metapath2vec: Scalable Representation Learning for Heterogeneous Networks发表在kdd2017,用于解决异构网络的embedding表示。个人看完文章的感觉就是将deepwalk的算法思路引入到异构网络当中,并针对异构网络的...
  • 前面介绍过DeepWalk,LINE,Node2Vec,SDNE几个graph embedding方法。这些方法都是基于近邻相似的假设的。其中DeepWalk,Node2Vec通过随机游走在图中采样顶点序列来构造顶点的近邻集合。LINE显式的构造邻接点对和顶点的...
  • 推荐系统(四)Graph Embedding之Node2Vec

    千次阅读 2020-01-30 20:47:25
    本文主要介绍Node2Vec算法如何对RandomWalk算法进行改进,得到更加合理的训练数据,进而通过Word2Vec模型学习的方式得到图中每个节点的Embedding向量。
  • Word2Vec 是 Google 在 2013 年开源的一个词向量(Word Embedding)计算工具,其用来解决单词的分布编码问题,因其简单高效引起了工业界和学术界极大的关注。 我们先尝试着回答几个问题,以检测下自己对 Word2Vec 的...
  • 本文的内容主要是阅读node2vec论文《node2vec: Scalable Feature Learning for Networks》的阅读记录。 近年来,知识表示学习在学习自身知识特征进行自动预测领域取得了重大进步。然而,现在的特征学习方法还不足以...
  • https://zhuanlan.zhihu.com/p/26306795 https://arxiv.org/pdf/1411.2738.pdf ... https://zhuanlan.zhihu.com/p/58805184 embedding入门到精通的paper,包括graph embedding ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,567
精华内容 3,026
关键字:

graph2vec