PYG教程【五】链路预测

链路预测是网络科学里面的一个经典任务，其目的是利用当前已获取的网络数据（包含结构信息和属性信息）来预测网络中会出现哪些新的连边。

本文计划利用networkx包中的网络来进行链路预测，因为目前PyTorch Geometric包中封装的网络还不够多，而很多网络方便用networkx包生成或者处理。

环境配置

首先，安装一个工具包，DeepSNAP。这个包提供了networkx到PyTorch Geometric的接口，可以方便地将networkx中的网络转换成PyTorch Geometric所要求的数据格式。DeepSNAP有两种安装方法：

第一种安装方法:

pip install deepsnap

第二种安装方法：

$ git clone https://github.com/snap-stanford/deepsnap
$ cd deepsnap
$ pip install .

链路预测

使用图神经网络进行链路预测包含以下基本步骤：

1. 导入图数据
2. 分割数据集（划分训练边、测试边）
3. 标注正边、采样负边
4. 训练神经网络
5. 测试模型效果

链路预测最开始是一个无监督学习任务，即根据已经看到的网络结构（或者其他属性信息）来推断未知连边是否存在，但是这样的话就比较难以验证。只有在动态网络（或称时序网络）中才会有这样的数据以供实验验证，可以用前一段时间的网络结构来预测后一段时间的网络结构。然而，很多网络没有时间信息，在这样的网络中如何验证呢？

后来，学者提出了用有监督的方式来进行链路预测，也就是将其视为二分类任务，将网络中存在的边都视为正样本（即正边），不存在的连边都当作负样本（即负边）。然后，将这些边分为两部分，一部分为训练集，一部分为测试集。训练集和测试集中都包含正边和负边，目的是在训练集上训练出一个模型能够准确分类这两种边，然后再在测试集上验证效果。

然而，大多数网络都是稀疏的，也就是说存在边的数量差不多是节点数量的几倍左右，而网络中不存在的边的数量差不多是节点数量的平方（在无向网络中，不存在边的数量等于$(n-1)n/2-m(n-1)n/2-m(n-1)n/2-m$，其中$n$为节点数，$m$ 为边数)。这样不存边的数量就远远大于存在边的数量，在有监督学习中就意味着负样本远大于正样本，类别极其不平衡。怎么解决这个问题呢？大家很自然地想到了负采样，就是每次训练的时候随机抽取与正样本等比例的负样本，这样就避免了类别不平衡。

训练结束后，就可以用测试集中的正边和负边来验证模型的效果了。

代码

import networkx as nx
from deepsnap.graph import Graph
import torch
import torch.nn.functional as F
from sklearn.metrics import roc_auc_score
from torch_geometric.utils import negative_sampling
from torch_geometric.nn import GCNConv
from torch_geometric.utils import train_test_split_edges

G = nx.karate_club_graph()
data = Graph(G)  # 将networkx中的graph对象转化为torch_geometric的Data对象
data.num_features = 3
data.edge_attr = None

# 构造节点特征矩阵（原网络不存在节点特征）
data.x = torch.ones((data.num_nodes, data.num_features), dtype=torch.float32)

# 分割训练边集、验证边集（默认占比0.05）以及测试边集（默认占比0.1）
data = train_test_split_edges(data)

# 构造一个简单的图卷积神经网络（两层），包含编码（节点嵌入）、解码（分数预测）等操作
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = GCNConv(data.num_features, 128)
        self.conv2 = GCNConv(128, 64)

    def encode(self):
        x = self.conv1(data.x, data.train_pos_edge_index)
        x = x.relu()
        return self.conv2(x, data.train_pos_edge_index)

    def decode(self, z, pos_edge_index, neg_edge_index):
        edge_index = torch.cat([pos_edge_index, neg_edge_index], dim=-1)  # 将正样本与负样本拼接 shape:[2,272]
        logits = (z[edge_index[0]] * z[edge_index[1]]).sum(dim=-1)
        return logits

    def decode_all(self, z):
        prob_adj = z @ z.t()
        return (prob_adj > 0).nonzero(as_tuple=False).t()


# 将模型和数据送入设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model, data = Net().to(device), data.to(device)
# 指定优化器
optimizer = torch.optim.Adam(params=model.parameters(), lr=0.01)

# 将训练集中的正边标签设置为1，负边标签设置为0
def get_link_labels(pos_edge_index, neg_edge_index):
    E = pos_edge_index.size(1) + neg_edge_index.size(1)
    link_labels = torch.zeros(E, dtype=torch.float, device=device)
    link_labels[:pos_edge_index.size(1)] = 1.
    return link_labels

# 训练函数，每次训练重新采样负边，计算模型损失，反向传播误差，更新模型参数
def train():
    model.train()
    neg_edge_index = negative_sampling(
        edge_index=data.train_pos_edge_index, num_nodes=data.num_nodes,
        num_neg_samples=data.train_pos_edge_index.size(1),  # 负采样数量根据正样本
        force_undirected=True,
    )  # 得到负采样shape: [2,136]
    neg_edge_index = neg_edge_index.to(device)
    optimizer.zero_grad()
    z = model.encode()  # 利用正样本训练学习得到每个节点的特征 shape:[34, 64]
    link_logits = model.decode(z, data.train_pos_edge_index, neg_edge_index)  # [272] 利用正样本和负样本 按位相乘 求和  (z[edge_index[0]] * z[edge_index[1]]).sum(dim=-1)
    link_labels = get_link_labels(data.train_pos_edge_index, neg_edge_index)  # [272] 前136个是1，后136个是0
    loss = F.binary_cross_entropy_with_logits(link_logits, link_labels)  # binary_cross_entropy_with_logits会自动计算link_logits的sigmoid
    loss.backward()
    optimizer.step()
    return loss

# 测试函数，评估模型在验证集和测试集上的预测准确率
@torch.no_grad()
def test():
    model.eval()
    perfs = []
    for prefix in ["val", "test"]:
        pos_edge_index = data[f'{prefix}_pos_edge_index']
        neg_edge_index = data[f'{prefix}_neg_edge_index']
        z = model.encode()
        link_logits = model.decode(z, pos_edge_index, neg_edge_index)
        link_probs = link_logits.sigmoid()
        link_labels = get_link_labels(pos_edge_index, neg_edge_index)
        perfs.append(roc_auc_score(link_labels.cpu(), link_probs.cpu()))
    return perfs

# 训练模型，每次训练完，输出模型在验证集和测试集上的预测准确率
best_val_perf = test_perf = 0
for epoch in range(1, 11):
    train_loss = train()
    val_perf, tmp_test_perf = test()
    if val_perf > best_val_perf:
        best_val_perf = val_perf
        test_perf = tmp_test_perf
    log = 'Epoch: {:03d}, Loss: {:.4f}, Val: {:.4f}, Test: {:.4f}'
    print(log.format(epoch, train_loss, best_val_perf, test_perf))

# 利用训练好的模型计算网络中剩余所有边的分数
z = model.encode()
final_edge_index = model.decode_all(z)

首先查看原始数据信息：

data:
Graph(
	G=[], 
	club=[34],   # 总共34个节点
	edge_label_index=[2, 156],   # 总共156个边
	name=[], 
	node_label_index=[34], 
	num_features=[1],  
	test_neg_edge_index=[2, 7],   # 测试集 负样本邻接矩阵
	test_pos_edge_index=[2, 7],   # 测试集 正样本邻接矩阵
	train_neg_adj_mask=[34, 34],   # 训练集 负样本邻接矩阵
	train_pos_edge_index=[2, 136],   # 训练集 正样本邻接矩阵
	val_neg_edge_index=[2, 3],   # 验证集 负样本邻接矩阵
	val_pos_edge_index=[2, 3],  # 验证集 正样本邻接矩阵
	x=[34, 3]  # 节点属性 
)

输出情况如下：

Epoch: 001, Loss: 0.8969, Val: 0.3333, Test: 0.9796
Epoch: 002, Loss: 0.6772, Val: 0.3333, Test: 0.9796
Epoch: 003, Loss: 0.6933, Val: 0.3333, Test: 0.9796
Epoch: 004, Loss: 0.7107, Val: 0.3333, Test: 0.9796
Epoch: 005, Loss: 0.6960, Val: 0.3333, Test: 0.9796
Epoch: 006, Loss: 0.6905, Val: 0.3333, Test: 0.9796
Epoch: 007, Loss: 0.6896, Val: 0.3333, Test: 0.9796
Epoch: 008, Loss: 0.6837, Val: 0.3333, Test: 0.9796
Epoch: 009, Loss: 0.6834, Val: 0.3333, Test: 0.9796
Epoch: 010, Loss: 0.6840, Val: 0.3333, Test: 0.9796

训练集中的负样本是每次随机采样得到的（第51-55行），而验证集和测试集中的负样本边则在第14行就已经固定了，所以结果中训练集上的loss一直在变化，而验证集和测试集上的AUC得分没有变化，因为我们的数据量太小导致的。如果换成Cora数据集效果会好点。

更详细的介绍，请看这篇文章。