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

本文主要是介绍图上 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)] = indexreturn p_map#解码方法
def decode_map(encode_map):de_map={}for k,v in encode_map.items():# index,ele de_map[v]=kreturn de_mapprint(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]*workerselse:return [num//workers]*workers + [num % workers]class RandomWalker:def __init__(self, G):""":param G:"""self.G = Gdef 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:breakreturn walkdef 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.Gnodes = list(G.nodes())# 并行分区数，results = Parallel(n_jobs=workers, verbose=verbose, )(delayed(self._simulate_walks)(nodes, num, walk_length) for num inpartition_num(num_walks, workers))walks = list(itertools.chain(*results))# 串行采样路径 # walks= self._simulate_walks(nodes,num_walks,walk_length)print("walks_len:",len(walks))return walksdef _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=5for 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=16train_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_dimself.build_model()self.train_data=train_dataself.epochs=epochself.word_embedding_file=embedding_fileself.vocab_size=vocab_sizeself.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_sizecontext_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 求平均效果更好哦。

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

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