04_DGL_06_链接预测.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "03c49acd",
   "metadata": {},
   "source": [
    "### 一.原理\n",
    "\n",
    "链接预测是预测边的存在性，注意它与边预测任务很不同，边预测是去预测已存在的边的属性。但通过**负采样**的技巧，我们可以将链接预测的问题转换为边预测的问题，可以看作：   \n",
    "\n",
    "$$\n",
    "链接预测=负采样+边预测\n",
    "$$  \n",
    "\n",
    "我们可以这样理解，如果两节点间存在边，那么我们定义该边上的属性为1，如果不存在边那么我们定义该边上的属性为0，所以我们将链接预测问题就转换为了边上的1/0预测问题，如果俩节点上的预测值靠近1，我们就可以认为它们之间存在一条边，如果预测值靠近0，就认为它们之间不存在边。但是“不存在的边”的量往往很大，这需要考虑任意两两之间的连接，所以我们采用负采样，从所有不存在的边中随机采样部分出来训练，如下示例图：   \n",
    "\n",
    "![avatar](./pic/链接预测.jpg)   \n",
    "\n",
    "对于上面的假设，我们可以类似于logistic任务，使用交叉熵损失函数：   \n",
    "$$\n",
    "L=-log\\sigma(y_{u,v})-\\sum\\{[1-log(y_{u,k})]\\mid k\\in P(u)\\}\n",
    "$$  \n",
    "\n",
    "这里，$u,v$是存在连接的点，$P(u)$是对$u$的负采样点的集合，$y_{u,v}$类似于上一节输入两向量，输出一个标量的函数，比如做内积，而$\\sigma(\\cdot)$是sigmoid函数，将输出约束在(0,1)之间，除了交叉熵，我们还可以选择其他函数，[参考>>](https://docs.dgl.ai/guide_cn/training-link.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77114d3e",
   "metadata": {},
   "source": [
    "### 二.实现\n",
    "\n",
    "这里需要实现的内容其实相比上一节主要多了两部分内容：   \n",
    "（1）第一部分是多了负采样；   \n",
    "（2）另一部分是需要修改损失函数的定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "99993c60",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using backend: pytorch\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import dgl\n",
    "import dgl.nn as dglnn\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import dgl.function as fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "68aa75f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#1.生成异构图\n",
    "n_users = 1000\n",
    "n_items = 500\n",
    "n_follows = 3000\n",
    "n_clicks = 5000\n",
    "n_dislikes = 500\n",
    "n_hetero_features = 10\n",
    "n_user_classes = 5\n",
    "n_max_clicks = 10\n",
    "\n",
    "follow_src = np.random.randint(0, n_users, n_follows)\n",
    "follow_dst = np.random.randint(0, n_users, n_follows)\n",
    "click_src = np.random.randint(0, n_users, n_clicks)\n",
    "click_dst = np.random.randint(0, n_items, n_clicks)\n",
    "dislike_src = np.random.randint(0, n_users, n_dislikes)\n",
    "dislike_dst = np.random.randint(0, n_items, n_dislikes)\n",
    "\n",
    "hetero_graph = dgl.heterograph({\n",
    "    ('user', 'follow', 'user'): (follow_src, follow_dst),\n",
    "    ('user', 'followed-by', 'user'): (follow_dst, follow_src),\n",
    "    ('user', 'click', 'item'): (click_src, click_dst),\n",
    "    ('item', 'clicked-by', 'user'): (click_dst, click_src),\n",
    "    ('user', 'dislike', 'item'): (dislike_src, dislike_dst),\n",
    "    ('item', 'disliked-by', 'user'): (dislike_dst, dislike_src)})\n",
    "\n",
    "hetero_graph.nodes['user'].data['feature'] = torch.randn(n_users, n_hetero_features)\n",
    "hetero_graph.nodes['item'].data['feature'] = torch.randn(n_items, n_hetero_features)\n",
    "hetero_graph.nodes['user'].data['label'] = torch.randint(0, n_user_classes, (n_users,))\n",
    "hetero_graph.edges['click'].data['label'] = torch.randint(1, n_max_clicks, (n_clicks,)).float()\n",
    "# 在user类型的节点和click类型的边上随机生成训练集的掩码\n",
    "hetero_graph.nodes['user'].data['train_mask'] = torch.zeros(n_users, dtype=torch.bool).bernoulli(0.6)\n",
    "hetero_graph.edges['click'].data['train_mask'] = torch.zeros(n_clicks, dtype=torch.bool).bernoulli(0.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "10f61ab8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#2.定义模型\n",
    "class RGCN(nn.Module):\n",
    "    def __init__(self, in_feats, hid_feats, out_feats, rel_names):\n",
    "        super().__init__()\n",
    "        # 实例化HeteroGraphConv，in_feats是输入特征的维度，out_feats是输出特征的维度，aggregate是聚合函数的类型\n",
    "        self.conv1 = dglnn.HeteroGraphConv({\n",
    "            rel: dglnn.GraphConv(in_feats, hid_feats)\n",
    "            for rel in rel_names}, aggregate='sum')\n",
    "        self.conv2 = dglnn.HeteroGraphConv({\n",
    "            rel: dglnn.GraphConv(hid_feats, out_feats)\n",
    "            for rel in rel_names}, aggregate='sum')\n",
    "\n",
    "    def forward(self, graph, inputs):\n",
    "        # 输入是节点的特征字典\n",
    "        h = self.conv1(graph, inputs)\n",
    "        h = {k: F.relu(v) for k, v in h.items()}\n",
    "        h = self.conv2(graph, h)\n",
    "        return h\n",
    "\n",
    "\n",
    "class HeteroDotProductPredictor(nn.Module):\n",
    "    def forward(self, graph, h, etype):\n",
    "        # h是从5.1节中对异构图的每种类型的边所计算的节点表示\n",
    "        with graph.local_scope():\n",
    "            graph.ndata['h'] = h\n",
    "            graph.apply_edges(fn.u_dot_v('h', 'h', 'score'), etype=etype)\n",
    "            return graph.edges[etype].data['score']\n",
    "        \n",
    "class Model(nn.Module):\n",
    "    def __init__(self, in_features, hidden_features, out_features, rel_names):\n",
    "        super().__init__()\n",
    "        self.sage = RGCN(in_features, hidden_features, out_features, rel_names)\n",
    "        self.pred = HeteroDotProductPredictor()\n",
    "\n",
    "    def forward(self, g, neg_g, x, etype):\n",
    "        h = self.sage(g, x)\n",
    "        return self.pred(g, h, etype), self.pred(neg_g, h, etype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7e45b690",
   "metadata": {},
   "outputs": [],
   "source": [
    "#3.定义负采样函数，将负样本采样为另外一张图\n",
    "def construct_negative_graph(graph, k, etype):\n",
    "    utype, _, vtype = etype\n",
    "    src, dst = graph.edges(etype=etype)\n",
    "    neg_src = src.repeat_interleave(k)\n",
    "    neg_dst = torch.randint(0, graph.num_nodes(vtype), (len(src) * k,))\n",
    "    return dgl.heterograph(\n",
    "        {etype: (neg_src, neg_dst)},\n",
    "        num_nodes_dict={ntype: graph.num_nodes(ntype) for ntype in graph.ntypes})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6d388795",
   "metadata": {},
   "outputs": [],
   "source": [
    "#4.定义损失函数\n",
    "def compute_loss(pos_score, neg_score):\n",
    "    # 间隔损失\n",
    "    n_edges = pos_score.shape[0]\n",
    "    return (1 - pos_score.unsqueeze(1) + neg_score.view(n_edges, -1)).clamp(min=0).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6435faed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.327864170074463\n",
      "1.3069148063659668\n",
      "1.277003288269043\n",
      "1.2585861682891846\n",
      "1.246128797531128\n"
     ]
    }
   ],
   "source": [
    "#5.训练模型\n",
    "k = 5\n",
    "model = Model(10, 20, 5, hetero_graph.etypes)\n",
    "user_feats = hetero_graph.nodes['user'].data['feature']\n",
    "item_feats = hetero_graph.nodes['item'].data['feature']\n",
    "node_features = {'user': user_feats, 'item': item_feats}\n",
    "opt = torch.optim.Adam(model.parameters())\n",
    "for epoch in range(5):\n",
    "    negative_graph = construct_negative_graph(hetero_graph, k, ('user', 'click', 'item'))#这里只对\"click\"关系进行预测\n",
    "    pos_score, neg_score = model(hetero_graph, negative_graph, node_features, ('user', 'click', 'item'))\n",
    "    loss = compute_loss(pos_score, neg_score)\n",
    "    opt.zero_grad()\n",
    "    loss.backward()\n",
    "    opt.step()\n",
    "    print(loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88dbd630",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}