图上 deepwalk 算法理论 与 tensorflow keras 实战，图算法之瑞士军刀篇(二)

图上 deepwalk 算法理论 与 tensorflow keras 实战，图算法之瑞士军刀篇(二)

---

文章源码下载地址：点我下载http://inf.zhihang.info/resources/pay/7692.html

书接上文，在 deepwalk 算法理论与实践，图算法之瑞士军刀篇(一) 中，我们讲了 Graph Embeding 的鼻祖类算法 deepwalk , 知道 deepwalk 算法也遵循了 图游走算法 的 基本架构 Walk + Skip-Gram Loss 架构 ， 并且 deepwalk 算法 其中用的 walk 算法是 随机游走 (random walk) 算法 。

在 深入浅出理解word2vec模型 (理论与源码分析) 文章中我们 再三强调 了 输入word2vec 的序列数据的重要性，并提供了构建序列的多种方法与技巧 。对于 图游走算法 也是如此，我们采用 不同的游走算法久可以得到完全不同的效果 ，例如 node2vec 算法就提出了一种 带倾向游走 (局部探索与全局探索的侧重与融合) 进行 图上节点序列采样 的方法，而 metapath 和 metapath ++ 算法 ，则又提供了 异构图上可以定制路径节点类型 的 元路径(metapath) 的节点采样算法。不同的 游走采样 方法则 构成 了不同的 图游走算法。

游走采样算法、负样本数据归一化 以及 不同采样算法路径融合的不同构成了近些年图上游走算法得到 graph embeding 的主要创新点和优化点 。 基于 “万变不离其宗” 的思想，这里 暂时 我们均 不在展开。

注意我们这里要说明的一点是: word2vec 算法，可以有无监督的版本，也有有监督的版本。如果单纯以 外界是否显式的输入模型样本标签 的话，在 上一篇文章 中， 样本不显式带有标签，输入模型的只有 正样本 (center,context） pair 对， 可以把归结为 无监督模型 。 而本文要介绍的算法，在使用 tf.keras.preprocessing.sequence.skipgrams 采样的时候带有了 标签，可以把归结为 有监督模型。

这里需要注意： 两篇文章代码里的方法，因为负样本采样均是 全局采样，而不是排除正样本之外的负采样，所以均是有一定概率的可能采样到正样本的，也就是说有得样本明明是正样本，被负样本采样算法采到了标记了label 0。

由于上一篇 deepwalk 算法理论与实践，图算法之瑞士军刀篇(一) 文章中，整个算法流程是基于 tensorflow 1.x 系列开发的，而我一直很为推崇 tensorflow 2.0 系列的keras 接口，所以本文将 主要说明 deepwalk 与 tensorflow 2.0 的 keras 实战 过程，别的没啥不同，关注 tensorflow 2.0 接口的同学，可以继续阅读下去了 ～

---

(1)代码时光

老规矩，为了保持每一篇文章的 完整性和独立性 ，这里和上一篇文章的冗余部分，我们也再次 赘述 一下，异同部分 我会进行文字说明哈～

老规矩， 开篇先吼一嗓子 ， talk is cheap , show me the code !!!

本文的代码讲的是 在图上基于 tensorflow 2.0 的 keras 接口 实现的 deepwalk 算法，整个源码流程是一个小型的 工业可用 的工程，觉得有用赶紧 收藏 转发 吧 ～

(1.1) 导包 (和上文不同)

首先导包，把代码跑起来，仅仅需要这些python 包就可以了。

@ 欢迎关注作者公众号 算法全栈之路

import io
import itertools
import numpy as np
import os
import re
import string
import tensorflow as tf
import tqdm
import random
import pandas as pd
import networkx as nx
from joblib import Parallel, delayed
import tensorflow as tf
from tensorflow.keras.layers import *
from tensorflow.keras.models import Model

这里导入的包和上一篇文章里略有不同，注意复制这里的代码～

---

(1.2) 数据准备 (和上文同)

注意，我们这里的代码适用于同构图，当然你用同构图来处理异构图问题也是可以的，也许效果更好呢 ～

@ 欢迎关注作者公众号 算法全栈之路

graph_df = pd.DataFrame([['Tom', 'pig',], ['Nancy', 'Tom'], ['Jack', 'Nancy']], columns=['src', 'dst'], index=['0', '1', '2'])
graph_df['weight']=1.0
print(graph_df)

这里的节点都是 同一类型 ，基于某一个关系构建的边，这里 pandas 的 dataframe 是保存的边的 src 和 dst ，以及该边对应的权重，weight 我们都把设置为 1.0 即可。

---

（1.3） 同构图节点编码 (和上文同)

老规矩，图节点嘛，进行编码, 数字化 后扔到图框架里去。

@欢迎关注微信公众号：算法全栈之路

#编码方法
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

print(type(graph_df['src'].values))

# 构建 encode/ decode map 
node_encode_map=encode_map(set(np.append(graph_df['src'].values, graph_df['dst'].values, axis=0)))
node_decode_map=decode_map(node_encode_map)

print(len(node_encode_map))

# 应用编码
graph_df['src_node_encoded'] = graph_df['src'].apply(lambda e: node_encode_map.get(str(e),-1))
graph_df['dst_node_encoded'] = graph_df['dst'].apply(lambda e: node_encode_map.get(str(e),-1))

print(graph_df)

这里的代码非常通俗易懂，我就不再赘述了。

---

（1.4） networkx 构图 (和上文同)

@欢迎关注微信公众号：算法全栈之路

G = nx.from_pandas_edgelist(graph_df, 'src_node_encoded', 'dst_node_encoded', ['weight'])
print(G)

这里应用 networkx 进行内存里逻辑图的构建 。 可以从 pandas 以及多种 数据源构建，感兴趣的下去自行百度哈 ～

---

（1.5） random walk 游走算法采样 (和上文同)

这里是算法 非常重要 的一块，使用 随机游走算法 random walk 在图上进行节点采样，看代码 ～

@欢迎关注微信公众号：算法全栈之路

def partition_num(num, workers):
    if num % workers == 0:
        return [num//workers]*workers
    else:
        return [num//workers]*workers + [num % workers]

class RandomWalker:
    def __init__(self, G):
        """
        :param G:
        """
        self.G = G
      
    def deepwalk_walk(self, walk_length, start_node):

        walk = [start_node]
        while len(walk) < walk_length:
            cur = walk[-1]
            cur_nbrs = list(self.G.neighbors(cur))
            if len(cur_nbrs) > 0:
                walk.append(random.choice(cur_nbrs))
            else:
                break
            
        return walk

    def simulate_walks(self, num_walks, walk_length, workers=1, verbose=0):
        """
        :param num_walks: random walks 的次数 (每次都要遍历所有 node )
        :param walk_length: 每次 random walk 最大长度
        :param workers: 进程数
        :param verbose:
        :return:
        """
        G = self.G

        nodes = list(G.nodes())
        # 并行分区数，
        results = Parallel(n_jobs=workers, verbose=verbose, )(
            delayed(self._simulate_walks)(nodes, num, walk_length) for num in
            partition_num(num_walks, workers))
        
        walks = list(itertools.chain(*results))
        
        # 串行采样路径 
        # walks= self._simulate_walks(nodes,num_walks,walk_length)
        print("walks_len:",len(walks))
        return walks
    
    def _simulate_walks(self, nodes, num_walks, walk_length,):
        walks = []
        for index in range(num_walks):
            # 对每一轮
            random.shuffle(nodes)
            for v in nodes:
                walks.append(self.deepwalk_walk(walk_length=walk_length, start_node=v))
                
        return walks
    
# 随机游走算法调用     
walker = RandomWalker(G)
session_reproduce = walker.simulate_walks(num_walks=6, walk_length=3, workers=2,verbose=1)

这里，我们提供了 并行和串行游走 2种方法，注意看上文的代码注释。如果图数据量比较大，建议使用 python多线程 进行路径游走节点采样哈。

注意： 这里的 session_reproduce 本身就是返回的结果，就是一个 二维数组 ，数组里每一个元素就是一次采样返回的节点序列，也就是一个路径。

---

（1.6）skip gram 样本构造 (和上文不同)

无论在何时，样本构造都是非常重要的～

@欢迎关注微信公众号：算法全栈之路

sample_list=[]
vocab_size=len(node_encode_map)
window_size=1
negative_samples=5

for sequence in sequences:
    positive_skip, label = tf.keras.preprocessing.sequence.skipgrams(
                        sequence,
                        vocabulary_size=vocab_size,
                        window_size=window_size,
                        negative_samples=negative_samples)
    
    # 这里 positive_skip 和 label 长度一致 
    for index in range(len(positive_skip)):
        target_word,context_word = positive_skip[index]
        cur_label = label[index]
        sample_list.append([target_word,context_word,cur_label])
       
w2v_sample_df=pd.DataFrame(sample_list, columns=["target", "context","label"])
w2v_sample_df.to_csv("supervised_w2v_sample.csv",sep=',',index=False)

注意，这里的 代码非常重要。
我们这里的 vocab_size=len(node_encode_map) 注意这里，后面导出节点的embeding 的时候要用到 。

对于 sequences 二维数组里的每一个元素也是一个采样序列 ，对这个序列，我们采用了 tf.keras.preprocessing.sequence.skipgrams 这个接口 进行负采样, 注意这里 负采样是 全局负采样，有 可能出现正样本。

这里 negative_samples 我选择了2 。这里推荐在较小的数据集中一般将 num_ns 设置为 [5， 20] 范围内的整数，而在较大的数据集一般设置为 [2， 5] 范围内整数。

---

（1.7） 数据batch处理、模型训练与 节点 embeding 导出

@欢迎关注微信公众号：算法全栈之路

w2v_sample_pdf=pd.read_csv("supervised_w2v_sample.csv",sep=',')
labels = w2v_sample_pdf.pop('label')

batch_size=32
buffer_size=1000
embedding_dim=16

train_dataset = tf.data.Dataset.from_tensor_slices((w2v_sample_pdf.values, labels.values))
train_dataset = train_dataset.shuffle(len(w2v_sample_pdf)).batch(batch_size)
train_dataset = train_dataset.cache().prefetch(buffer_size=buffer_size)


class Word2Vec(object):
    def __init__(self,train_data,inverse_map,epoch=3,embedding_file="./embeding_file.csv",vocab_size=1000):
        self.embedding_dim = embedding_dim
        self.build_model()
        self.train_data=train_data
        self.epochs=epoch
        self.word_embedding_file=embedding_file
        self.vocab_size=vocab_size
        self.inverse_map=inverse_map

    # 构建 word2vec 模型
    def build_model(self):
        inputs = Input(shape=(2,))
        target = inputs[:, 0:1]
        context = inputs[:, 1:2]
        self.words_embedding_in = tf.keras.layers.Embedding(
            vocab_size,
            self.embedding_dim,
            input_length=1,
            name="word_embedding_in"
        )
        self.words_embedding_out = tf.keras.layers.Embedding(
            vocab_size,
            self.embedding_dim,
            input_length=1,
            name="word_embedding_out"
        )
        word_emb = self.words_embedding_in(target)  # batch_size,1,embeing_size
        context_emb = self.words_embedding_out(context)
        dots = tf.keras.layers.Dot(axes=(2, 2))([word_emb, context_emb])
        outputs = tf.keras.layers.Flatten()(dots)
        self.model = Model(inputs, outputs)

        self.model.compile(
            optimizer='adam',
            loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
            metrics=['accuracy'])

    # 模型训练
    def train(self):
        self.model.fit(self.train_data, epochs=self.epochs)

    def save_word_embeddings(self):
        with open(self.word_embedding_file, 'w') as f:
            # f.write('{} {}\n'.format(self.vocab_size, self.embedding_dim))
            weights = self.words_embedding_in.get_weights()[0]
            for i in range(self.vocab_size):
                emb = weights[i, :]
                line = '{} {}\n'.format(self.inverse_map[i],','.join([str(x) for x in emb]))
                f.write(line)


word2vec = Word2Vec(train_dataset,embedding_file="./embeing.csv",vocab_size=vocab_size,inverse_map=node_decode_map)
word2vec.train()
word2vec.save_word_embeddings()

这里因为是 tensorflow 2.0 keras 版本的代码，数据的 batch 化 使用了 tf.data.Dataset 相关的接口，算是非常简洁了。

注意这里的导出 节点embeding 的方法， weights = self.words_embedding_in.get_weights()[0] 这里直接取出了 words_embedding_in 作为 embeding 。

因为 模型里的实现 words_embedding_in 和 words_embedding_out 两个 variable ，可以分别取出这两个embeding 求平均效果更好哦。

剩下的就是模型的训练了，常规代码，我就不在进行赘述了。

最后代码跑起来就是这个样子：

导出的embeding 长这个样子：

到这里，图上deepwalk 算法理论与tensorflow keras实战，图算法之瑞士军刀篇(二) 的全文就写完了。这也是 短时间内图算法系列的最后一篇文章 了，接下来再有一篇文章 总结下图算法就完事了。

上面的代码demo 在环境没问题的情况下，全部 复制到一个python文件 里，就可以完美运行起来。本文的代码是一个 小型的商业可以用的算法工程项目 ，希望可以对你有参考作用 ～

---

码字不易，觉得有收获就动动小手转载一下吧，你的支持是我写下去的最大动力 ～

更多更全更新内容 ： 算法全栈之路