“Weisfeiler-Lehman Neural Machine for Link Prediction“文章复现工作

1 复现文章：

• 《Weisfeiler-Lehman Neural Machine for Link Prediction》

2 文章提出的方法思路：

• 笔者希望能够通过提取目标连边的周围连边所构成的子图，并通过一种编码方法，保留住每个节点在子图中扮演的不同角色，即在不同子图当中扮演相同角色的节点能够有相近的编号。如下面两张图所示，在两个不同的子网络当中，扮演角色相同的节点会得到相同的编号。

• 然后笔者要对于网络中的每一条连边生成这样的一张子图，然后将子图都转化为对应的邻接矩阵，输入到一个机器学习分类模型（文章中用到的是单个隐藏层的神经网络）当中进行训练。

3 难点：

• 如何对于不同的子图当中的节点进行编码，并保证其能够保存节点的相对角色？

4 解决：

• 笔者的思路就是，首先将一个连边所对应的两个节点的一阶、二阶…邻居节点提取出来，然后根据一个笔者提出的哈希函数对节点进行排序，大致流程如下：其做法为：首先根据子图中的节点与目标连边所连接的两个节点之间的距离初始化节点的标签，然后开始迭代，每次迭代，计算每个节点的哈希值，然后根据哈希值来更新该节点的标签，其中哈希值最小的编码为1，第二小的为2，若有相同取值的就分配到同样的数字。
  
  哈希函数为：
  
  其中$P(n)$为第n个素数。

5 文章提出方法的流程图：

• 整个算法的基本流程：首先对于每一条连边，提取K个以上邻居节点构成的子图。提取顺序是：先一阶邻居，再二阶邻居…；接着对提取的子图进行图编码，然后选择前K个进行提取。提取完子图之后为每个节点建立一个上三角邻接矩阵，将邻接矩阵输入到神经网络中进行学习。
  

6 代码：

6.1 首先导入所需库

import networkx as nx
import numpy as np
import pandas as pd
import math
import random
import matplotlib.pyplot as plt
import scipy
from scipy.io import loadmat
from functools import partial
from sklearn import svm
from sklearn.linear_model import LogisticRegression
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.utils import shuffle
from sklearn import metrics

6.2 载入数据，构建网络及可视化

data = loadmat('./USAir.mat')
G = nx.from_numpy_matrix(data['net'].todense(),create_using=nx.Graph()) #构建网络
print(nx.info(G))
pos=nx.spring_layout(G)
plt.figure(figsize=(10,8))
nx.draw(G,pos=pos,node_size=50,alpha=0.5,with_labels=False)
plt.title('USAir Network',fontsize=16,fontweight='bold')
plt.show()

• 结果：
  
  

6.3 正采样

G_train = G.copy() 
G_test = nx.empty_graph(G_train.number_of_nodes())
n_links = int(G_train.number_of_edges()) # 获得网络中的连边总数

ratio = 0.1 #取10%的连边作为测试集连边
n_test_link = int(np.ceil(n_links*ratio))
print(n_test_link)
selected_link_id = np.random.choice(np.arange(n_links),size=n_test_link,replace=False)
adj_matrix = nx.adj_matrix(G)
adj_matrix = scipy.sparse.triu(adj_matrix,k=1)
rol,col = adj_matrix.nonzero() #取非零元素
links = [(i,j) for i,j in zip(rol,col)]
selected_links = []
for link_id in selected_link_id:
    selected_links.append(links[link_id]) #根据连边的索引获得连边
G_train.remove_edges_from(selected_links)
G_test.add_edges_from(selected_links)
print(G_train.number_of_edges(),G_test.number_of_edges())

• 结果：213；1913，213

6.4 负采样

• 负采样需要首先建立一个与原图节点数相同的图，然后把原图当中不存在的连边全部加入到该图当中，然后随机抽取。

k = 2
neg_train_link = k*G_train.number_of_edges() # 取正样本数的两倍作为负样本数
neg_test_link = k*G_test.number_of_edges()
G_neg = nx.empty_graph(G.number_of_edges())
neg_links = list(nx.non_edges(G)) # 返回原始网络中不存在的连边
G_neg.add_edges_from(neg_links)
print(G_neg.number_of_edges())

selected_link_idd = np.random.choice(np.arange(G_neg.number_of_edges()),size=neg_train_link+neg_test_link,replace=False)
G_train_neg = nx.empty_graph(G.number_of_nodes())
G_test_neg = nx.empty_graph(G.number_of_nodes())

selected_links = []
for i in range(neg_train_link):
    inx = selected_link_idd[i]
    selected_links.append(neg_links[inx])
G_train_neg.add_edges_from(selected_links)

selected_links = []
for i in range(neg_test_link):
    inx = selected_link_idd[i]
    selected_links.append(neg_links[inx])
G_test_neg.add_edges_from(selected_links)

• 结果：52820

6.5 将正样本和负样本组合起来

all_train_links = list(G_train.edges) + list(G_train_neg.edges)
label_train = [1]*G_train.number_of_edges()+[0]*neg_train_link

all_test_links = list(G_test.edges) + list(G_test_neg.edges)
label_test = [1]*G_test.number_of_edges()+[0]*neg_test_link

y_train,y_test = np.array(label_train),np.array(label_test)

6.6 提取子图

def enclosing_subgraph(fringe,G,subgraph,distance):
    """构建enclosing subgraph
        Input:
            fringe:用来寻找下一阶邻居的列表
            G：原网络
            subgraph:要提取的子图
            distance:描述连边的距离
        return:
            fringe,subgraph:更新后的内容
    """
    neighbor_link = []
    temp_subgraph = subgraph.copy()
    for link in fringe:
        u = link[0]
        v = link[1]
        neighbor_link += list(G.edges(u))
        neighbor_link += list(G.edges(v))
    temp_subgraph.add_edges_from(neighbor_link)
    # 除去已有的连边
    neighbor_link = [l for l in temp_subgraph.edges() if l not in subgraph.edges()] 
    temp_subgraph.add_edges_from(neighbor_link,distance=distance,inverse_distance=1/distance)
    return neighbor_link,temp_subgraph



def subgraph_extractor(G,link,K):
    """为每一条连边提取一个子图
        Input:
            G:网络
            link:目标连边
            K:子图大小
        return:
            subgraph：连边的子图 
    """
    distance = 0
    subgraph = nx.Graph()
    fringe = [link] #用来存放邻居节点的列表
    subgraph.add_edge(link[0],link[1],distance=distance)
    while subgraph.number_of_nodes()<K and len(fringe)>0:
        distance += 1 
        fringe,subgraph = enclosing_subgraph(fringe,G,subgraph,distance)
    temp_subgraph = G.subgraph(subgraph.nodes)
    additional_edges = [l for l in temp_subgraph.edges() if l not in subgraph.edges]
    subgraph.add_edges_from(additional_edges,distance=distance+1,inverse_distance=1/(distance+1))
        
    return subgraph

if __name__ == '__main__':
    G_512 = subgraph_extractor(G_train,(5,12),10)
    nx.draw(G_512,with_labels=True)
    plt.show()

• 结果：
  

6.7 对节点进行编码排序

def primes(x):
    """判断是否为素数"""
    if x <2:
        return False
    if x ==2 or x == 3:
        return True
    for i in range(2,x):
        if x% i ==0:
            return False
    return True

def cal_mean_geo_distance(G_subgraph,link):
    """计算目标节点到图中其他节点的距离"""
    u = link[0]
    v = link[1]
    G_subgraph.remove_edge(u,v) # 因为不需要计算节点u和节点v之间的距离，所以先去除
    n = G_subgraph.number_of_nodes()
    u_reachable = nx.descendants(G_subgraph,source=u)# 找到节点u可以到达的节点
    v_reachable = nx.descendants(G_subgraph,source=v)
    
    for each in G_subgraph.nodes():
        distance_to_u = 0
        distance_to_v = 0
        if each != u: #计算节点到u的距离，如果节点无法到u就设其为2**n
            distance_to_u = nx.shortest_path_length(G_subgraph,source=each,target=u) if each in u_reachable else 2**n
        if each != v:
            distance_to_v = nx.shortest_path_length(G_subgraph,source=each,target=v) if each in v_reachable else 2**n
        # 将信息存到节点属性当中
        G_subgraph.nodes[each]['ave_d'] = math.sqrt(distance_to_u*distance_to_v) 
    
    G_subgraph.add_edge(u,v,distance=0)
    return G_subgraph


def PWL(G_sub,link,prime_list):
    """对子图中的节点上色
        Input:
            G_sub:目标子图
            link:确定该子图的连边
            prime_list:素数列表
        return:
            nodelist :编码后的节点列表
    """
    tem_subgraph = G_sub.copy()
    if tem_subgraph.has_edge(link[0],link[1]):
        tem_subgraph.remove_edge(link[0],link[1])
    ave_d = nx.get_node_attributes(tem_subgraph,'ave_d') # 获取初始化所需要的数据
    df = pd.DataFrame.from_dict(ave_d,orient='index',columns=['hash_value']) #转化为一个DataFrame
    df = df.sort_index() #按照index进行排序
    df['order'] = df['hash_value'].rank(axis=0,method='min').astype(np.int) # 按照hash_value来获得每个节点的排序编号
    df['previous_order'] = np.zeros(len(ave_d)) #用来存放前一轮的编号
    adj_matrix = nx.adj_matrix(tem_subgraph,nodelist=sorted(tem_subgraph.nodes)).todense()
    while any(df['order']!= df['previous_order']): #只要排序还在变，就执行下面的代码
        df['log_priem'] = np.log(prime_list[df['order'].values])
        total_log = np.ceil(np.sum(df['log_priem'].values))
        df['hash_value'] = adj_matrix*df['log_priem'].values.reshape(-1,1)/total_log + df['order'].values.reshape(-1,1)
        df['previous_order'] = df['order']
        df['order'] = df['hash_value'].rank(axis=0,method='min').astype(np.int)
    nodelist = df['order'].sort_values().index.values #根据排序输出子图中的节点集
    return nodelist

if __name__ == '__main__':
    e_subgraph = cal_mean_geo_distance(G_01,(5,12))
    prime_list = np.array([i for i in range(10000) if primes(i)],dtype=np.int)
    nodelist = PWL(e_subgraph,(5,12),prime_list)
    print(nodelist)

• 结果：
  

6.8 用邻居矩阵来embedding每个子图

def sample(subgraph,nodelist,weight='weight',size=10):
    adj_mat = nx.adj_matrix(subgraph,weight=weight,nodelist=nodelist).todense()
    vector = np.asarray(adj_mat)[np.triu_indices(len(adj_mat),k=1)] # np.triu_indices:获取矩阵上三角元素，k=1就是不需要对角线元素
    d = size*(size-1)//2
    if len(vector) <d:
        vector = np.append(vector,np.zeros(d-len(vector)))
    return vector[1:]

if __name__ == '__main__':
	s = sample(e_subgraph_, nodelist, size=10)
	print(s)

• 结果：
  

6.9 对每条连边进行embedding

def encode_link(link,G,prime_list,weight='weight',K=10):
    e_subgraph = subgraph_extractor(G_train,link,K) #首先提取子图
    e_subgraph = cal_mean_geo_distance(e_subgraph,link) # 然后获得距离属性
    nodelist = PWL(e_subgraph,link,prime_list) # 排序
    if len(nodelist)>K: # 返回固定大小的节点集
        nodelist = nodelist[:K]
        e_subgraph = e_subgraph.subgraph(nodelist)
    embedd = sample(e_subgraph,nodelist,weight='weight',size=K)#进行embedding
    return embedd

if __name__ == '__main__':
	X_train = np.array(list(map(partial(encode_link,G=G_train,prime_list=prime_list,weight='weight',K=10),all_train_links)))
	X_test = np.array(list(map(partial(encode_link,G=G_test,prime_list=prime_list,weight='weight',K=10),all_test_links)))

6.10 训练模型

X_train_shuffle, y_train_shuffle = shuffle(X_train, y_train)
model1 = MLPClassifier(hidden_layer_sizes=(32, 32, 16),
                      alpha=1e-3,
                      batch_size=128,
                      learning_rate_init=0.001,
                      max_iter=100,
                      verbose=True,
                      early_stopping=False,
                      tol=-10000)
model1.fit(X_train_shuffle,y_train_shuffle)
predictions = model1.predict(X_test)
fpr, tpr, thresholds = metrics.roc_curve(label_test,predictions,pos_label=1)
auc = metrics.auc(fpr, tpr)
print(auc)

• 结果：