deepwalk原理及其应用
DeepWalk详解资料
知乎专栏
https://zhuanlan.zhihu.com/p/56380812
github资料，本文以下述1和3资料为源本完善修改而成
https://github.com/shenweichen/GraphEmbedding
https://github.com/ZhaoLiang-GitHub/GraphEmbedding-Deeplearning
https://github.com/swallown1/GraphEmbedding
论文原文
Paper:Tang J, Qu M, Wang M, et al. Line: Large-scale information network embedding
代码环境配置
networkx==2.2
其余无要求
from __future__ import print_function
import pandas as pd
import random
#networkx用于构建图数据
import networkx as nx
#从gensim.models中导入已经写好的word2vec模型备用
from gensim.models import Word2Vec
## 用于分类问题训练
import numpy
from sklearn.metrics import f1_score, accuracy_score
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import MultiLabelBinarizer
# TSNE用于降维
from sklearn.manifold import TSNE
import numpy as np
# 从sklearn导入线性回归模型
from sklearn.linear_model import LogisticRegression
# 用于画降维后的聚类图
import matplotlib.pyplot as plt
# 创建alias采样表
def create_alias_table(area_ratio):
"""
:param area_ratio: sum(area_ratio)=1
:return: accept,alias
"""
l = len(area_ratio)
accept, alias = [0] * l, [0] * l
small, large = [], []
area_ratio_ = np.array(area_ratio) * l
for i, prob in enumerate(area_ratio_):
if prob < 1.0:
small.append(i)
else:
large.append(i)
while small and large:
small_idx, large_idx = small.pop(), large.pop()
accept[small_idx] = area_ratio_[small_idx]
alias[small_idx] = large_idx
area_ratio_[large_idx] = area_ratio_[large_idx] - \
(1 - area_ratio_[small_idx])
if area_ratio_[large_idx] < 1.0:
small.append(large_idx)
else:
large.append(large_idx)
while large:
large_idx = large.pop()
accept[large_idx] = 1
while small:
small_idx = small.pop()
accept[small_idx] = 1
return accept, alias
## 定义根据alias表的采样算法
def alias_sample(accept, alias):
"""
:param accept:
:param alias:
:return: sample index
"""
N = len(accept)
i = int(np.random.random()*N)
r = np.random.random()
if r < accept[i]:
return i
else:
return alias[i]
# 定义随机游走
class RandomWalker:
def __init__(self, G, p=1, q=1):
"""
:param G:
param p: 返回参数，控制立即重新遍历节点的可能性。.
param q: In-out参数，允许搜索区分“向内”和“向外”节点
"""
self.G = G
self.p = p
self.q = q
# 选取节点的方式采用的是又放回的随机选取
# RandomWalk是一种可重复访问已访问节点的深度优先遍历
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):
# :num_walks 将所有节点随机游走的次数
# :walk_length 每次游走的长度
G = self.G
nodes = list(G.nodes())
walks = self._simulate_walks(nodes, num_walks, walk_length)
# 多线程同时处理
# 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))
return walks
def _simulate_walks(self, nodes, num_walks, walk_length, ):
# :num_walks 将所有节点随机游走的次数
# :walk_length 每次游走的长度
walks = []
for _ in range(num_walks):
random.shuffle(nodes)
for v in nodes:
if self.p == 1 and self.q == 1:
walks.append(self.deepwalk_walk(
walk_length=walk_length, start_node=v))
else:
walks.append(self.node2vec_walk(
walk_length=walk_length, start_node=v))
return walks
def get_alias_edge(self, t, v):
"""
compute unnormalized transition probability between nodes v and its neighbors give the previous visited node t.
:param t:
:param v:
:return:
"""
G = self.G
p = self.p
q = self.q
unnormalized_probs = []
for x in G.neighbors(v):
weight = G[v][x].get('weight', 1.0) # w_vx
if x == t: # d_tx == 0
unnormalized_probs.append(weight / p)
elif G.has_edge(x, t): # d_tx == 1
unnormalized_probs.append(weight)
else: # d_tx > 1
unnormalized_probs.append(weight / q)
norm_const = sum(unnormalized_probs)
normalized_probs = [
float(u_prob) / norm_const for u_prob in unnormalized_probs]
return create_alias_table(normalized_probs)
def preprocess_transition_probs(self):
"""
Preprocessing of transition probabilities for guiding the random walks.
"""
G = self.G
alias_nodes = {}
for node in G.nodes():
unnormalized_probs = [G[node][nbr].get('weight', 1.0)
for nbr in G.neighbors(node)]
norm_const = sum(unnormalized_probs)
normalized_probs = [
float(u_prob) / norm_const for u_prob in unnormalized_probs]
alias_nodes[node] = create_alias_table(normalized_probs)
alias_edges = {}
for edge in G.edges():
alias_edges[edge] = self.get_alias_edge(edge[0], edge[1])
self.alias_nodes = alias_nodes
self.alias_edges = alias_edges
return
class TopKRanker(OneVsRestClassifier):
def predict(self, X, top_k_list):
probs = numpy.asarray(super(TopKRanker, self).predict_proba(X))
all_labels = []
for i, k in enumerate(top_k_list):
probs_ = probs[i, :]
labels = self.classes_[probs_.argsort()[-k:]].tolist() #找出得分最高的分类的下标
probs_[:] = 0 #将所有类的概率设置为0
probs_[labels] = 1 #将分类结果的概率设置为1
all_labels.append(probs_)
return numpy.asarray(all_labels)
# 定义分类训练函数
class Classifier(object):
def __init__(self, embeddings, clf):
self.embeddings = embeddings #给分类方法输入嵌入
self.clf = TopKRanker(clf)
self.binarizer = MultiLabelBinarizer(sparse_output=True) #多标签二进制器
def train(self, X, Y, Y_all):
self.binarizer.fit(Y_all)
X_train = [self.embeddings[x] for x in X]
Y = self.binarizer.transform(Y)
self.clf.fit(X_train, Y)
def evaluate(self, X, Y):
top_k_list = [len(l) for l in Y]
Y_ = self.predict(X, top_k_list)
Y = self.binarizer.transform(Y)
averages = ["micro", "macro", "samples", "weighted"]
results = {}
for average in averages:
results[average] = f1_score(Y, Y_, average=average)
results['acc'] = accuracy_score(Y,Y_)
print('-------------------')
print(results)
return results
print('-------------------')
def predict(self, X, top_k_list):
X_ = numpy.asarray([self.embeddings[x] for x in X])
Y = self.clf.predict(X_, top_k_list=top_k_list)
return Y
def split_train_evaluate(self, X, Y, train_precent, seed=0):
state = numpy.random.get_state()
training_size = int(train_precent * len(X))
numpy.random.seed(seed)
shuffle_indices = numpy.random.permutation(numpy.arange(len(X)))
X_train = [X[shuffle_indices[i]] for i in range(training_size)]
Y_train = [Y[shuffle_indices[i]] for i in range(training_size)]
X_test = [X[shuffle_indices[i]] for i in range(training_size, len(X))]
Y_test = [Y[shuffle_indices[i]] for i in range(training_size, len(X))]
self.train(X_train, Y_train, Y)
numpy.random.set_state(state)
return self.evaluate(X_test, Y_test)
def read_node_label(filename, skip_head=False):
fin = open(filename, 'r')
X = []
Y = []
while 1:
if skip_head:
fin.readline()
l = fin.readline()
if l == '':
break
vec = l.strip().split('\t') # hmdd20数据集
# vec = l.strip().split(' ') # wiki数据集
X.append(vec[0])
Y.append(vec[1:])
fin.close()
return X, Y
def evaluate_embeddings(embeddings):
X, Y = read_node_label('../data/hmdd20/label.txt')
tr_frac = 0.8
print("Training classifier using {:.2f}% nodes...".format(tr_frac * 100))
clf = Classifier(embeddings=embeddings, clf=LogisticRegression())
clf.split_train_evaluate(X, Y, tr_frac)
def plot_embeddings(embeddings,):
X, Y = read_node_label('../data/hmdd20/label.txt')
emb_list = []
for k in X:
emb_list.append(embeddings[k])
emb_list = np.array(emb_list)
model = TSNE(n_components=2)
node_pos = model.fit_transform(emb_list)
color_idx = {}
for i in range(len(X)):
color_idx.setdefault(Y[i][0], [])
color_idx[Y[i][0]].append(i)
for c, idx in color_idx.items():
plt.scatter(node_pos[idx, 0], node_pos[idx, 1], label=c)
plt.legend()
plt.show()
#得到嵌入之后，对这个嵌入向量的效果，以分类问题进行验证验证
def evaluate_embeddings(embeddings):
X, Y = read_node_label('../data/hmdd20/label.txt')
# wiki数据集
tr_frac = 0.8
print("Training classifier using {:.2f}% nodes...".format(tr_frac * 100))
clf = Classifier(embeddings=embeddings, clf=LogisticRegression())
clf.split_train_evaluate(X, Y, tr_frac)
def plot_embeddings(embeddings, ):
X, Y = read_node_label('../data/hmdd20/label.txt')
# #wiki数据集
emb_list = []
for k in X:
emb_list.append(embeddings[k])
emb_list = np.array(emb_list)
model = TSNE(n_components=2)
node_pos = model.fit_transform(emb_list)
color_idx = {}
for i in range(len(X)):
color_idx.setdefault(Y[i][0], [])
color_idx[Y[i][0]].append(i)
for c, idx in color_idx.items():
plt.scatter(node_pos[idx, 0], node_pos[idx, 1], label=c)
plt.legend()
plt.show()
if __name__ == '__main__':
# 读取节点之间的边
# G = nx.read_edgelist('../data/wiki/Wiki_edgelist.txt',
# create_using=nx.DiGraph(), nodetype=None,
# data=[('weight', int)])
G = nx.read_edgelist('../data/hmdd20/onlyknowndiseasemirnainteraction.txt',
create_using=nx.Graph(), nodetype=None)
#随机游走
walker = RandomWalker(G, p=1, q=1)
#获得节点访问序列
num_walks = 1 #每个节点生成几个句子
walk_length = 3 #生成的句子长度
sampling_workers = 1 #线程数
sentences = walker.simulate_walks(
num_walks=num_walks, walk_length=walk_length, workers=sampling_workers, verbose=0)
# 对模型进行训练（根据已有序列，调用gensim中的词向量）
embed_size = 128
window_size = 5
word2vec_workers = 3
iter = 5
kwargs = {}
kwargs["sentences"] = sentences
kwargs["min_count"] = 0
kwargs["vector_size"] = embed_size #要学习到的嵌入纬度
kwargs["sg"] = 1 # skip gram
kwargs["hs"] = 1 # deepwalk use Hierarchical Softmax 层次softmax技术
kwargs["workers"] = word2vec_workers #线程数目
kwargs["window"] = window_size #采样训练集的窗口大小
kwargs["epochs"] = iter #训练多少个epoch
print("Learning embedding vectors...")
model = Word2Vec(**kwargs)
print("Learning embedding vectors done!")
embeddings = {}
for word in G.nodes():
embeddings[word] = model.wv[word]
print(embeddings['362'])
evaluate_embeddings(embeddings)
plot_embeddings(embeddings)