04_DGL_08_批量采样训练.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实际业务中，我们需要处理的图往往很大，可能会有上亿的节点和边，如果把这些数据进行全量训练，GPU显存很难放的下，所以我们需要使用类似于DNN中那样的随机批量学习的方式进行训练，与DNN中的批量学习不同，GNN对单个训练样本的训练还需要利用到它的邻居节点，而且每多增加一层网络，所需的邻居样本还要往外扩展一层，所以对于$k$层的GNN网络，我们需要对训练样本进行$k$阶的子图采样操作（回想一下之前GraphSAGE代码中采样...），借助于DGL的api，我们只需要多添加2行代码就可以了..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using backend: pytorch\n"
     ]
    }
   ],
   "source": [
    "#1.准备数据\n",
    "import numpy as np\n",
    "import torch\n",
    "import dgl\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from dgl.nn.pytorch import HeteroGraphConv, GraphConv\n",
    "\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)\n",
    "\n",
    "user_feats = hetero_graph.nodes['user'].data['feature']\n",
    "item_feats = hetero_graph.nodes['item'].data['feature']\n",
    "labels = hetero_graph.nodes['user'].data['label']\n",
    "train_mask = hetero_graph.nodes['user'].data['train_mask']\n",
    "train_idx = torch.nonzero(train_mask, as_tuple=False).squeeze()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们使用`MultiLayerFullNeighborSampler`进行采样，它会采样当前节点的所有邻居节点，利用`NodeDataLoader`进行数据的批量读取"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2.定义采样器\n",
    "sampler = dgl.dataloading.MultiLayerFullNeighborSampler(2)#采样2阶子图，对应了GNN中2层网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataloader = dgl.dataloading.NodeDataLoader(hetero_graph, {\"user\": train_idx}, sampler, batch_size=128, shuffle=True,num_workers=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过对dataloader迭代，我们每次可以取出input_nodes, output_nodes, blocks这三个变量，其中：     \n",
    "**input_nodes**：包括训练所需的所有节点ID   \n",
    "**output_nodes**：包括训练目标的节点，对应上面128个随机的user节点  \n",
    "**blocks**：是个list,从blocks[0],blocks[1]....分别对应了节点的$k$阶子图，$k-1$阶子图.....直到这128个user节点自身的$0$阶子图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_nodes, output_nodes, blocks = next(iter(dataloader))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于将原始的大图切分为了一个一个的block，所以对于模型定义中的`forward`阶段需要做一点修改，改动也很简单，将原始的全图变量，依层替换为对应的block即可"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3.定义模型\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 = HeteroGraphConv({\n",
    "            rel: GraphConv(in_feats, hid_feats)\n",
    "            for rel in rel_names}, aggregate='sum')\n",
    "        self.conv2 = HeteroGraphConv({\n",
    "            rel: GraphConv(hid_feats, out_feats)\n",
    "            for rel in rel_names}, aggregate='sum')\n",
    "\n",
    "    def forward(self, blocks, inputs):\n",
    "        # 输入是节点的特征字典\n",
    "        h = self.conv1(blocks[0], inputs)#2阶子图\n",
    "        h = {k: F.relu(v) for k, v in h.items()}\n",
    "        h = self.conv2(blocks[1], h)#1阶子图\n",
    "        return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#4.训练模型\n",
    "#训练阶段没太大差异，注意输入、输出的具体格式\n",
    "losses=[]\n",
    "model = RGCN(n_hetero_features, 20, n_user_classes, hetero_graph.etypes)\n",
    "opt = torch.optim.Adam(model.parameters(),lr=1e-2)\n",
    "if __name__ == '__main__':\n",
    "    model.train()\n",
    "    for _ in range(20):\n",
    "        for input_nodes, output_nodes, blocks in dataloader:\n",
    "            # blocks = [b.to(torch.device('cuda')) for b in blocks]\n",
    "            input_features = blocks[0].srcdata['feature']  # returns a dict\n",
    "            output_labels = blocks[-1].dstdata['label']  # returns a dict\n",
    "            output_predictions = model(blocks, input_features)\n",
    "            loss = F.cross_entropy(output_predictions['user'], output_labels['user'])\n",
    "            opt.zero_grad()\n",
    "            loss.backward()\n",
    "            opt.step()\n",
    "            losses.append(loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x281a2e53fd0>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.plot(losses)\n",
    "plt.legend([\"loss\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}