DGL_learning/week6-DGL实现GraphConv,GATConv,SAGEConv.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YqM5Z7qKUgqS"
   },
   "source": [
    "In this week, you are required to implement a toy GATConv and SAGEConv based on document. Also, you need to implement both in PyG and DGL. In this work, you will get a further understanding of tensor-centric in PyG and graph-centric in DGL.\n",
    "\n",
    "</style>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DGL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import dgl\n",
    "import dgl.function as fn\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "os.environ[\"KMP_DUPLICATE_LIB_OK\"] = \"TRUE\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GraphConv\n",
    "Mathematically it is defined as follows:\n",
    "\n",
    "$$\n",
    "  h_i^{(l+1)} = \\sigma(b^{(l)} + \\sum_{j\\in\\mathcal{N}(i)}\\frac{1}{c_{ji}}h_j^{(l)}W^{(l)})\n",
    "$$\n",
    "where $\\mathcal{N}(i)$ is the set of neighbors of node $i$, \n",
    "$c_{ji}$ is the product of the square root of node degrees\n",
    "$(i.e.,  c_{ji} = \\sqrt{|\\mathcal{N}(j)|}\\sqrt{|\\mathcal{N}(i)|})$,\n",
    "and $\\sigma$ is an activation function.\n",
    "\n",
    "If a weight tensor on each edge is provided, the weighted graph convolution is defined as:\n",
    "\n",
    "$$\n",
    "  h_i^{(l+1)} = \\sigma(b^{(l)} + \\sum_{j\\in\\mathcal{N}(i)}\\frac{e_{ji}}{c_{ji}}h_j^{(l)}W^{(l)})\n",
    "$$\n",
    "where $e_{ji}$is the scalar weight on the edge from node $j$ to node $i$.\n",
    "This is NOT equivalent to the weighted graph convolutional network formulation in the paper.\n",
    "\n",
    "To customize the normalization term :$c_{ji}$, one can first set ``norm='none'`` for\n",
    "the model, and send the pre-normalized :$e_{ji}$ to the forward computation. We provide\n",
    ":class:`~dgl.nn.pytorch.EdgeWeightNorm` to normalize scalar edge weight following the GCN paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "src = torch.tensor([0, 1, 1, 2, 2, 4])\n",
    "dst = torch.tensor([2, 0, 2, 3, 4, 3])\n",
    "h = torch.rand((5, 8))\n",
    "\n",
    "g = dgl.graph((src, dst))\n",
    "g.ndata[\"h\"] = h\n",
    "edge_weight = torch.ones(g.num_edges())  # 给各个边赋格权重\n",
    "g.edata[\"edge_weight\"] = edge_weight\n",
    "plt.figure(figsize=(2, 2))\n",
    "nx.draw(dgl.to_networkx(g), with_labels=True)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DGL_GraphConv(nn.Module):\n",
    "    def __init__(self, in_feats, out_feats):\n",
    "        super(DGL_GraphConv, self).__init__()\n",
    "        self.w = nn.Linear(in_feats, out_feats, bias=False)\n",
    "        self.bias = nn.Parameter(\n",
    "            torch.zeros(\n",
    "                out_feats,\n",
    "            )\n",
    "        )\n",
    "        self.activate = nn.ReLU()\n",
    "        self.reset_parameters()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        # nn.init.xavier_uniform_(self.w.weight)\n",
    "        # nn.init.xavier_uniform_(self.bias.data)\n",
    "        nn.init.ones_(self.w.weight)\n",
    "        nn.init.ones_(self.bias.data)\n",
    "\n",
    "    def forward(self, g: dgl.DGLGraph, x):\n",
    "        with g.local_scope():\n",
    "            # 确保自身特征能有迭代\n",
    "            g = dgl.remove_self_loop(g)\n",
    "            g = dgl.add_self_loop(g)\n",
    "\n",
    "            #norm='both'，cij考虑src的出度和dst的入度\n",
    "            out_deg = g.out_degrees().pow(-0.5)\n",
    "            in_deg = g.in_degrees().pow(-0.5)\n",
    "\n",
    "            \n",
    "            g.srcdata[\"out_deg\"] = out_deg\n",
    "            g.srcdata[\"in_deg\"] = in_deg\n",
    "\n",
    "            h = self.w(x)\n",
    "            g.srcdata[\"h\"] = h\n",
    "\n",
    "            g.update_all(message_func=self.message, reduce_func=fn.sum(\"hN\", \"hN\"))\n",
    "            hN = g.dstdata[\"hN\"] + self.bias\n",
    "\n",
    "            return hN\n",
    "\n",
    "    def message(self, edges: dgl.udf.EdgeBatch):\n",
    "        d_j = edges.src[\"out_deg\"].view(-1, 1)\n",
    "        d_i = edges.dst[\"in_deg\"].view(-1, 1)\n",
    "        h_j = edges.src[\"h\"]\n",
    "        \n",
    "        hN = d_i * d_j * h_j\n",
    "        return {\"hN\": hN}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "in_feats = h.shape[1]\n",
    "out_feats = in_feats  # *2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[4.3249, 4.3249, 4.3249, 4.3249, 4.3249, 4.3249, 4.3249, 4.3249],\n",
      "        [3.4165, 3.4165, 3.4165, 3.4165, 3.4165, 3.4165, 3.4165, 3.4165],\n",
      "        [4.9293, 4.9293, 4.9293, 4.9293, 4.9293, 4.9293, 4.9293, 4.9293],\n",
      "        [6.2123, 6.2123, 6.2123, 6.2123, 6.2123, 6.2123, 6.2123, 6.2123],\n",
      "        [5.0695, 5.0695, 5.0695, 5.0695, 5.0695, 5.0695, 5.0695, 5.0695]])\n"
     ]
    }
   ],
   "source": [
    "dgl_graphConv = DGL_GraphConv(in_feats, out_feats)\n",
    "with torch.no_grad():\n",
    "    out=dgl_graphConv(g, h)\n",
    "    print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 与dgl实现对比验证"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dgl.nn import GraphConv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([1., 1., 1., 1., 1., 1., 1., 1.], requires_grad=True)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# torch.manual_seed(42)\n",
    "gcn=GraphConv(in_feats,out_feats,norm='both',activation=F.relu)\n",
    "nn.init.ones_(gcn.weight)\n",
    "nn.init.ones_(gcn.bias)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[4.3249, 4.3249, 4.3249, 4.3249, 4.3249, 4.3249, 4.3249, 4.3249],\n",
      "        [3.4165, 3.4165, 3.4165, 3.4165, 3.4165, 3.4165, 3.4165, 3.4165],\n",
      "        [4.9293, 4.9293, 4.9293, 4.9293, 4.9293, 4.9293, 4.9293, 4.9293],\n",
      "        [6.2123, 6.2123, 6.2123, 6.2123, 6.2123, 6.2123, 6.2123, 6.2123],\n",
      "        [5.0695, 5.0695, 5.0695, 5.0695, 5.0695, 5.0695, 5.0695, 5.0695]])\n"
     ]
    }
   ],
   "source": [
    "g_in=g.add_self_loop()\n",
    "with torch.no_grad():\n",
    "    out=gcn.forward(g_in,h)\n",
    "    print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tensor([[4.3249, 4.3249, 4.3249, 4.3249, 4.3249, 4.3249, 4.3249, 4.3249],\n",
    "#         [3.4165, 3.4165, 3.4165, 3.4165, 3.4165, 3.4165, 3.4165, 3.4165],\n",
    "#         [4.9293, 4.9293, 4.9293, 4.9293, 4.9293, 4.9293, 4.9293, 4.9293],\n",
    "#         [6.2123, 6.2123, 6.2123, 6.2123, 6.2123, 6.2123, 6.2123, 6.2123],\n",
    "#         [5.0695, 5.0695, 5.0695, 5.0695, 5.0695, 5.0695, 5.0695, 5.0695]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GATConv\n",
    "Graph attention layer from Graph Attention Network\n",
    "$$h_i^{(l+1)} = \\sum_{j\\in \\mathcal{N}(i)} \\alpha_{i,j} W^{(l)} h_j^{(l)}$$\n",
    "\n",
    "where $\\alpha_{ij}$ is the attention score bewteen node $i$ and\n",
    "node $j$:\n",
    "\n",
    "$$\n",
    "\\begin{align}\\begin{aligned}\\alpha_{ij}^{l} &= \\mathrm{softmax_i} (e_{ij}^{l})\\\\e_{ij}^{l} &= \n",
    "\\mathrm{LeakyReLU}\\left(\\vec{a}^T [W h_{i} \\| W h_{j}]\\right)\\end{aligned}\\end{align}\n",
    "$$\n",
    "\n",
    "这里的 $softmax_i$ 是对节点$i$的多个边进行归一化，不考虑其他边"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dgl.nn.functional import edge_softmax\n",
    "\n",
    "\n",
    "class DGL_GATConv(nn.Module):\n",
    "    def __init__(self, in_feats, out_feats):\n",
    "        super(DGL_GATConv, self).__init__()\n",
    "        # self.W=nn.Parameter(torch.rand(in_feats,out_feats))\n",
    "        # self.a=nn.Parameter(torch.rand(2*in_feats,1))\n",
    "        self.W = nn.Linear(in_feats, out_feats, bias=False)\n",
    "        self.a_fc = nn.Linear(out_feats * 2, 1, bias=False)\n",
    "        self.leakyrelu = nn.LeakyReLU()\n",
    "\n",
    "    def edge_attention(self, edges):\n",
    "        hiW = self.W(edges.dst[\"h\"])\n",
    "        hjW = self.W(edges.src[\"h\"])\n",
    "        h_cat = torch.cat([hiW, hjW], dim=1)\n",
    "        e = self.leakyrelu(self.a_fc(h_cat))\n",
    "        return {\"e\": e}\n",
    "\n",
    "    def forward(self, g: dgl.graph, h, get_attention=False):\n",
    "        with g.local_scope():\n",
    "            g=g.remove_self_loop().add_self_loop()\n",
    "            g.apply_edges(self.edge_attention)\n",
    "            e = g.edata[\"e\"]\n",
    "            alpha = edge_softmax(g, e)\n",
    "            g.edata[\"alpha\"] = alpha\n",
    "            hW = self.W(h)\n",
    "\n",
    "            g.ndata[\"hW\"] = hW\n",
    "            g.update_all(fn.u_mul_e(\"hW\", \"alpha\", \"m\"), fn.sum(\"m\", \"hN\"))\n",
    "            hN = g.ndata[\"hN\"]\n",
    "\n",
    "            if get_attention:\n",
    "                return hN, alpha\n",
    "            else:\n",
    "                return hN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# src = torch.tensor([0, 1, 1, 2, 2, 4])\n",
    "# dst = torch.tensor([2, 0, 2, 3, 4, 3])\n",
    "# h = torch.ones((5, 8))\n",
    "\n",
    "# g = dgl.graph((src, dst))\n",
    "# g = dgl.add_self_loop(g)\n",
    "# g.ndata[\"h\"] = h\n",
    "# g\n",
    "\n",
    "g = dgl.graph(([0, 0, 1, 2, 4, 4, 4, 5], [1, 2, 2, 3, 0, 2, 3, 1]))\n",
    "g.ndata[\"h\"] = torch.FloatTensor(\n",
    "    [\n",
    "        [0, 0, 0, 0],  # 0\n",
    "        [1, 1, 1, 1],  # 1\n",
    "        [2, 2, 2, 2],  # 2\n",
    "        [3, 3, 3, 3],  # 3\n",
    "        [4, 4, 4, 4],  # 4\n",
    "        [5, 5, 5, 5],  # 5\n",
    "    ]\n",
    ")\n",
    "g.edata[\"edge_attr\"] = torch.ones(g.num_edges())\n",
    "\n",
    "# g=g.remove_self_loop().add_self_loop()\n",
    "\n",
    "plt.figure(figsize=(2,2))\n",
    "nx.draw(dgl.to_networkx(g), with_labels=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameter containing:\n",
      "tensor([[1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1.]], requires_grad=True)\n",
      "Parameter containing:\n",
      "tensor([[1., 1., 1., 1., 1., 1.]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "in_feats=g.ndata['h'].shape[1]\n",
    "out_feats=3\n",
    "\n",
    "myGATConv = DGL_GATConv(in_feats,out_feats)\n",
    "torch.nn.init.ones_(myGATConv.W.weight)\n",
    "torch.nn.init.ones_(myGATConv.a_fc.weight)\n",
    "\n",
    "print(myGATConv.W.weight)\n",
    "print(myGATConv.a_fc.weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[16.0000, 16.0000, 16.0000],\n",
      "        [20.0000, 20.0000, 20.0000],\n",
      "        [16.0000, 16.0000, 16.0000],\n",
      "        [16.0000, 16.0000, 16.0000],\n",
      "        [16.0000, 16.0000, 16.0000],\n",
      "        [20.0000, 20.0000, 20.0000]])\n",
      "tensor([[8.7565e-27],\n",
      "        [1.4252e-21],\n",
      "        [2.3195e-16],\n",
      "        [3.7751e-11],\n",
      "        [1.0000e+00],\n",
      "        [1.0000e+00],\n",
      "        [9.9999e-01],\n",
      "        [1.0000e+00],\n",
      "        [1.4252e-21],\n",
      "        [1.4252e-21],\n",
      "        [3.7751e-11],\n",
      "        [6.1442e-06],\n",
      "        [1.0000e+00],\n",
      "        [1.0000e+00]])\n"
     ]
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    out,attention=myGATConv(g, g.ndata['h'], get_attention=True)\n",
    "    print(out)\n",
    "    print(attention)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 与dgl实现对比验证"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Case 1: Homogeneous graph\n",
    "from dgl.nn import GATConv\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameter containing:\n",
      "tensor([[1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1.]], requires_grad=True)\n",
      "Parameter containing:\n",
      "tensor([[[1., 1., 1.]]], requires_grad=True)\n",
      "Parameter containing:\n",
      "tensor([[[1., 1., 1.]]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "gatconv = GATConv(in_feats,out_feats, num_heads=1)\n",
    "\n",
    "torch.nn.init.ones_(gatconv.fc.weight)\n",
    "torch.nn.init.ones_(gatconv.attn_l)\n",
    "torch.nn.init.ones_(gatconv.attn_r)\n",
    "\n",
    "print(gatconv.fc.weight)\n",
    "print(gatconv.attn_l)\n",
    "print(gatconv.attn_r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[16.0000, 16.0000, 16.0000]],\n",
      "\n",
      "        [[20.0000, 20.0000, 20.0000]],\n",
      "\n",
      "        [[16.0000, 16.0000, 16.0000]],\n",
      "\n",
      "        [[16.0000, 16.0000, 16.0000]],\n",
      "\n",
      "        [[16.0000, 16.0000, 16.0000]],\n",
      "\n",
      "        [[20.0000, 20.0000, 20.0000]]])\n",
      "tensor([[[8.7565e-27]],\n",
      "\n",
      "        [[1.4252e-21]],\n",
      "\n",
      "        [[2.3195e-16]],\n",
      "\n",
      "        [[3.7751e-11]],\n",
      "\n",
      "        [[1.0000e+00]],\n",
      "\n",
      "        [[1.0000e+00]],\n",
      "\n",
      "        [[9.9999e-01]],\n",
      "\n",
      "        [[1.0000e+00]],\n",
      "\n",
      "        [[1.4252e-21]],\n",
      "\n",
      "        [[1.4252e-21]],\n",
      "\n",
      "        [[3.7751e-11]],\n",
      "\n",
      "        [[6.1442e-06]],\n",
      "\n",
      "        [[1.0000e+00]],\n",
      "\n",
      "        [[1.0000e+00]]])\n"
     ]
    }
   ],
   "source": [
    "g_in=g.remove_self_loop().add_self_loop()\n",
    "with torch.no_grad():\n",
    "    out,attention=(gatconv(g_in, g_in.ndata['h'], get_attention=True))\n",
    "    print(out)\n",
    "    print(attention)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 完全相同捏\n",
    "# tensor([[16.0000, 16.0000, 16.0000],\n",
    "#         [20.0000, 20.0000, 20.0000],\n",
    "#         [16.0000, 16.0000, 16.0000],\n",
    "#         [16.0000, 16.0000, 16.0000],\n",
    "#         [16.0000, 16.0000, 16.0000],\n",
    "#         [20.0000, 20.0000, 20.0000]])\n",
    "# tensor([[8.7565e-27],\n",
    "#         [1.4252e-21],\n",
    "#         [2.3195e-16],\n",
    "#         [3.7751e-11],\n",
    "#         [1.0000e+00],\n",
    "#         [1.0000e+00],\n",
    "#         [9.9999e-01],\n",
    "#         [1.0000e+00],\n",
    "#         [1.4252e-21],\n",
    "#         [1.4252e-21],\n",
    "#         [3.7751e-11],\n",
    "#         [6.1442e-06],\n",
    "#         [1.0000e+00],\n",
    "#         [1.0000e+00]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SAGEConv\n",
    "$$\n",
    "\\begin{align}\\begin{aligned}\n",
    "h_{\\mathcal{N}(i)}^{(l+1)} &= \\mathrm{aggregate}\\left(\\{h_{j}^{l}, \\forall j \\in \\mathcal{N}(i) \\}\\right)\\\\\\\\\n",
    "h_{i}^{(l+1)} &= \\sigma \\left(W \\cdot \\mathrm{concat}(h_{i}^{l}, h_{\\mathcal{N}(i)}^{l+1}) \\right)\\\\\\\\\n",
    "h_{i}^{(l+1)} &= \\mathrm{norm}(h_{i}^{(l+1)})\\\\\\\\\n",
    "\\mathrm{norm}(v) &= \\frac{v}{\\max(\\lVert v \\rVert_p,\\epsilon)}\n",
    "\\end{aligned}\\end{align}\n",
    "$$\n",
    "\n",
    "If a weight tensor on each edge is provided, the aggregation becomes:\n",
    "$$\n",
    "h_{\\mathcal{N}(i)}^{(l+1)} = \\mathrm{aggregate}\n",
    "\\left(\\{e_{ji} h_{j}^{l}, \\forall j \\in \\mathcal{N}(i) \\}\\right)\n",
    "$$\n",
    "where $e_{ji}$ is the scalar weight on the edge from node $j$ to node $i$.\n",
    "    Please make sure that $e_{ji}$ is broadcastable with $h_j^{l}$.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "id": "PKgfXLyLVwus"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Graph(num_nodes=5, num_edges=7,\n",
       "      ndata_schemes={'h': Scheme(shape=(5,), dtype=torch.float32)}\n",
       "      edata_schemes={'e': Scheme(shape=(), dtype=torch.float32)})"
      ]
     },
     "execution_count": 300,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "src = torch.tensor([0, 1, 1, 2, 2, 4, 1])\n",
    "dst = torch.tensor([2, 0, 2, 3, 4, 3, 3])\n",
    "h = torch.ones((5, 8))\n",
    "h = torch.FloatTensor(\n",
    "    [\n",
    "        [0, 0, 0, 0, 0],\n",
    "        [1, 1, 1, 1, 1],\n",
    "        [2, 2, 2, 2, 2],\n",
    "        [3, 3, 3, 3, 3],\n",
    "        [4, 4, 4, 4, 4],\n",
    "    ]\n",
    ")\n",
    "\n",
    "g = dgl.graph((src, dst))\n",
    "g.edata[\"e\"] = torch.ones(g.num_edges(), dtype=torch.float)\n",
    "g.ndata[\"h\"] = h\n",
    "# g = g.add_self_loop()\n",
    "\n",
    "in_feats = 5\n",
    "out_feats = 7\n",
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1, 0, 2, 3, 1])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(2, 2))\n",
    "nx.draw(dgl.to_networkx(g), with_labels=True)\n",
    "print(g.in_degrees())"
   ]
  },
  {
   "attachments": {
    "5840edd5-428b-4f21-ac25-c0f984b72662.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于DGL的消息传递机制，在msg_func中传入参数为edges，通过edges.src和.dst来获取边两端的节点。\n",
    "```python\n",
    "def get_neighbour(edges: dgl.udf.EdgeBatch):\n",
    "    hN = edges.src[\"h\"] # 邻居\n",
    "    hi = edges.dst[\"h\"] # 自身\n",
    "    h_cat = torch.cat([hi, hN], dim=1) #拼接\n",
    "    # 然而这么做，当某个节点没有输入边时，自己的特征也会被设置成0\n",
    "    return {\"h_cat\": h_cat}\n",
    "```\n",
    "当某个节点没有输入边时，比如上图的节点1，则在update时，msg_func中无法获取1节点自身的信息，便在reduce_func中自动将传入数据设为0。结果变为\n",
    "![image.png](attachment:5840edd5-428b-4f21-ac25-c0f984b72662.png)\n",
    "\n",
    "解决方式：\n",
    "\n",
    "- 1. 增加self_loop\n",
    "\n",
    "  2. [先汇聚再拼接](#先汇聚再拼接)\n",
    "\n",
    "     ```python\n",
    "       g.update_all(fn.copy_u('h','tmp'),fn.sum('tmp','hN')) # 先聚合邻居\n",
    "       hN=g.dstdata['hN']\n",
    "       h_cat=torch.cat([hi,hN],dim=1) # 再进行拼接\n",
    "       h_cat=relu(W(h_cat))\n",
    "       n=F.normalize(h_cat,dim=1)\n",
    "     ```\n",
    "     <br>\n",
    "     \n",
    "     \n",
    "      \n",
    "\n",
    "  3. [将W拆开](#将W拆开)     拆开成W_self与W_neighbour，shape都是（d,s），分别与hi，hN相乘，得到（n,s）, 之后相加。本质上是分块矩阵计算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 先汇聚再拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
      "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
      "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
      "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
      "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780]],\n",
      "       grad_fn=<DivBackward0>)\n"
     ]
    }
   ],
   "source": [
    "W = nn.Linear(in_feats * 2, out_feats, bias=False)\n",
    "relu = nn.ReLU()\n",
    "nn.init.ones_(W.weight)\n",
    "\n",
    "with g.local_scope():\n",
    "    hi = g.ndata[\"h\"]\n",
    "    # zeros=torch.zeros_like(hi)\n",
    "    # hi=torch.cat([hi,zeros],dim=1)\n",
    "    g.update_all(fn.copy_u(\"h\", \"tmp\"), fn.sum(\"tmp\", \"hN\"))\n",
    "    hN = g.dstdata[\"hN\"]\n",
    "    h_cat = torch.cat([hi, hN], dim=1)\n",
    "    h_cat = relu(W(h_cat))\n",
    "    n = F.normalize(h_cat, dim=1)\n",
    "\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 将W拆开"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DGL_SAGEConv(nn.Module):\n",
    "    def __init__(self, in_feats, out_feats):\n",
    "        super(DGL_SAGEConv, self).__init__()\n",
    "        self.w_neighbour = nn.Linear(in_feats, out_feats, bias=False)\n",
    "        self.w_self = nn.Linear(in_feats, out_feats, bias=False)\n",
    "        torch.nn.init.ones_(self.w_neighbour.weight)\n",
    "        torch.nn.init.ones_(self.w_self.weight)\n",
    "\n",
    "    def forward(self, g: dgl.graph, h):\n",
    "        with g.local_scope():\n",
    "            g.srcdata[\"h\"] = h\n",
    "            g.update_all(fn.copy_u(\"h\", \"tmp\"), fn.sum(\"tmp\", \"hN\"))\n",
    "            h_N = g.dstdata[\"hN\"]\n",
    "            h_self = self.w_self(h)\n",
    "            h_neighbour = self.w_neighbour(h_N)\n",
    "            rst = F.relu(h_self + h_neighbour)\n",
    "\n",
    "            return F.normalize(rst, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [],
   "source": [
    "mySAGEConv = DGL_SAGEConv(in_feats, out_feats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
       "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
       "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
       "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
       "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780]],\n",
       "       grad_fn=<DivBackward0>)"
      ]
     },
     "execution_count": 314,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySAGEConv(g, h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 与dgl实现对比验证"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameter containing:\n",
      "tensor([[1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.]], requires_grad=True)\n",
      "Parameter containing:\n",
      "tensor([[1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "from dgl.nn import SAGEConv\n",
    "\n",
    "sageconv = SAGEConv(\n",
    "    in_feats,\n",
    "    out_feats,\n",
    "    aggregator_type=\"mean\",\n",
    "    bias=False,\n",
    "    activation=relu,\n",
    "    norm=F.normalize,\n",
    ")\n",
    "\n",
    "nn.init.ones_(sageconv.fc_neigh.weight)\n",
    "nn.init.ones_(sageconv.fc_self.weight)\n",
    "print(sageconv.fc_neigh.weight)\n",
    "print(sageconv.fc_self.weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
       "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
       "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
       "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
       "        [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780]],\n",
       "       grad_fn=<DivBackward0>)"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sageconv(g, h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 一样一样\n",
    "# tensor([[0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
    "#         [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
    "#         [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
    "#         [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780],\n",
    "#         [0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780, 0.3780]],\n",
    "#        grad_fn=<DivBackward0>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "GML",
   "language": "python",
   "name": "gml"
  },
  "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.9.19"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}