dgl_cora.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.environ[\"DGLBACKEND\"] = \"pytorch\"  # use PyTorch as backend\n",
    "import dgl\n",
    "import dgl.data\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading C:\\Users\\Atikin\\.dgl\\cora_v2.zip from https://data.dgl.ai/dataset/cora_v2.zip...\n",
      "Extracting file to C:\\Users\\Atikin\\.dgl\\cora_v2_d697a464\n",
      "Finished data loading and preprocessing.\n",
      "  NumNodes: 2708\n",
      "  NumEdges: 10556\n",
      "  NumFeats: 1433\n",
      "  NumClasses: 7\n",
      "  NumTrainingSamples: 140\n",
      "  NumValidationSamples: 500\n",
      "  NumTestSamples: 1000\n",
      "Done saving data into cached files.\n",
      "Number of categories: 7\n"
     ]
    }
   ],
   "source": [
    "dataset = dgl.data.CoraGraphDataset()\n",
    "print(f\"Number of categories: {dataset.num_classes}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2708, 1433])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = dataset[0]\n",
    "g.ndata[\"feat\"].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below are three different models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GCN(\n",
       "  (conv1): GraphConv(in=1433, out=16, normalization=both, activation=None)\n",
       "  (conv2): GraphConv(in=16, out=7, normalization=both, activation=None)\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dgl.nn import GraphConv\n",
    "\n",
    "\n",
    "class GCN(nn.Module):  # nn.Module - PyTorch parent class for registering all layers, parameters, etc. inside the backing\n",
    "    def __init__(self, in_feats, h_feats, num_classes):\n",
    "        super(GCN, self).__init__()\n",
    "        self.conv1 = GraphConv(in_feats, h_feats)  # a graph convolution layer in which we specify the dimension of incoming and outgoing elements. In our case, this is a vector of words\n",
    "        self.conv2 = GraphConv(h_feats, num_classes)  # the last layer, at the output we get dimension = 7 - the number of classes in the graph\n",
    "\n",
    "    def forward(self, g, in_feat):\n",
    "        h = self.conv1(g, in_feat)\n",
    "        h = F.relu(h)\n",
    "        h = self.conv2(g, h)\n",
    "        return h\n",
    "\n",
    "\n",
    "# Create the model with given dimensions\n",
    "# 16 - number of parameters on the middle layer\n",
    "model = GCN(g.ndata[\"feat\"].shape[1], 16, dataset.num_classes)\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "APPNP(\n",
       "  (gc1): GraphConv(in=1433, out=20, normalization=both, activation=None)\n",
       "  (gc_layer): GraphConv(in=20, out=20, normalization=both, activation=None)\n",
       "  (gc2): GraphConv(in=20, out=7, normalization=both, activation=None)\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class APPNP(nn.Module):\n",
    "    def __init__(self, nfeat, nhid, nclass, dropout=0.2, layer=2):\n",
    "        super(APPNP, self).__init__()\n",
    "        self.gc1 = GraphConv(nfeat, nhid) # n_feature: C, n_hidden: H\n",
    "        self.gc_layer = GraphConv(nhid, nhid)  # n_hidden: H, n_hidden: H\n",
    "        self.gc2 = GraphConv(nhid, nclass) # n_hidden: H, n_classes: F\n",
    "        self.dropout = dropout\n",
    "        self.layer = layer\n",
    "\n",
    "    def forward(self, g, in_feat): # X, A\n",
    "        x = self.gc1(g, in_feat)\n",
    "        x = F.relu(x) # for APPNP paper\n",
    "        for i in range(self.layer - 2):\n",
    "            x = self.gc_layer(g, x)\n",
    "            x = F.relu(x)  # middle conv\n",
    "            x = F.dropout(x, self.dropout)\n",
    "        if self.layer > 1:\n",
    "            x = self.gc2(g, x) # 2th conv\n",
    "        return F.log_softmax(x) # N * F\n",
    "\n",
    "model = APPNP(g.ndata[\"feat\"].shape[1], 20, dataset.num_classes)\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CRD_CLS(\n",
       "  (conv1): GraphConv(in=1433, out=20, normalization=both, activation=None)\n",
       "  (conv2): GraphConv(in=20, out=7, normalization=both, activation=None)\n",
       ")"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class CRD_CLS(nn.Module):\n",
    "    def __init__(self, num_features, hidden, num_classes, dropout=0.2):\n",
    "        super(CRD_CLS, self).__init__()\n",
    "        self.conv1 = GraphConv(num_features, hidden)\n",
    "        self.p = dropout\n",
    "        self.conv2 = GraphConv(hidden, num_classes)\n",
    "\n",
    "    def forward(self, g, in_feat):\n",
    "        x = self.conv1(g, in_feat)\n",
    "        x = F.relu(x)\n",
    "        x = F.dropout(x, p=self.p)\n",
    "        x = self.conv2(g, x)\n",
    "        x = F.log_softmax(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "model = CRD_CLS(g.ndata[\"feat\"].shape[1], 20, dataset.num_classes)\n",
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loop for model training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In epoch 0, loss: 1.946, val acc: 0.224 (best 0.224), test acc: 0.210 (best 0.210)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Atikin\\AppData\\Local\\Temp/ipykernel_9164/165596389.py:13: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  x = F.log_softmax(x)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In epoch 5, loss: 1.888, val acc: 0.498 (best 0.498), test acc: 0.546 (best 0.546)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In epoch 10, loss: 1.798, val acc: 0.600 (best 0.626), test acc: 0.648 (best 0.623)\n",
      "In epoch 15, loss: 1.674, val acc: 0.654 (best 0.698), test acc: 0.677 (best 0.679)\n",
      "In epoch 20, loss: 1.529, val acc: 0.676 (best 0.698), test acc: 0.689 (best 0.679)\n",
      "In epoch 25, loss: 1.363, val acc: 0.684 (best 0.712), test acc: 0.721 (best 0.710)\n",
      "In epoch 30, loss: 1.199, val acc: 0.706 (best 0.720), test acc: 0.714 (best 0.712)\n",
      "In epoch 35, loss: 1.014, val acc: 0.692 (best 0.720), test acc: 0.715 (best 0.712)\n",
      "In epoch 40, loss: 0.823, val acc: 0.708 (best 0.730), test acc: 0.723 (best 0.713)\n",
      "In epoch 45, loss: 0.695, val acc: 0.674 (best 0.730), test acc: 0.702 (best 0.713)\n",
      "In epoch 50, loss: 0.598, val acc: 0.742 (best 0.742), test acc: 0.734 (best 0.734)\n",
      "In epoch 55, loss: 0.459, val acc: 0.766 (best 0.766), test acc: 0.740 (best 0.742)\n",
      "In epoch 60, loss: 0.366, val acc: 0.726 (best 0.766), test acc: 0.753 (best 0.742)\n",
      "In epoch 65, loss: 0.312, val acc: 0.766 (best 0.766), test acc: 0.741 (best 0.742)\n",
      "In epoch 70, loss: 0.245, val acc: 0.746 (best 0.766), test acc: 0.747 (best 0.742)\n",
      "In epoch 75, loss: 0.221, val acc: 0.740 (best 0.766), test acc: 0.739 (best 0.742)\n",
      "In epoch 80, loss: 0.183, val acc: 0.752 (best 0.766), test acc: 0.760 (best 0.742)\n",
      "In epoch 85, loss: 0.154, val acc: 0.756 (best 0.766), test acc: 0.763 (best 0.742)\n",
      "In epoch 90, loss: 0.137, val acc: 0.734 (best 0.766), test acc: 0.737 (best 0.742)\n",
      "In epoch 95, loss: 0.118, val acc: 0.774 (best 0.774), test acc: 0.731 (best 0.731)\n"
     ]
    }
   ],
   "source": [
    "def train(g, model):\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
    "    best_val_acc = 0\n",
    "    best_test_acc = 0\n",
    "\n",
    "    features = g.ndata[\"feat\"]\n",
    "    labels = g.ndata[\"label\"]\n",
    "    train_mask = g.ndata[\"train_mask\"]\n",
    "    val_mask = g.ndata[\"val_mask\"]\n",
    "    test_mask = g.ndata[\"test_mask\"]\n",
    "    for e in range(100):\n",
    "        # Forward\n",
    "        logits = model(g, features)\n",
    "\n",
    "        # Compute prediction\n",
    "        pred = logits.argmax(1)\n",
    "\n",
    "        # Compute loss\n",
    "        # Note that you should only compute the losses of the nodes in the training set.\n",
    "        loss = F.cross_entropy(logits[train_mask], labels[train_mask])\n",
    "\n",
    "        # Compute accuracy on training/validation/test\n",
    "        train_acc = (pred[train_mask] == labels[train_mask]).float().mean()\n",
    "        val_acc = (pred[val_mask] == labels[val_mask]).float().mean()\n",
    "        test_acc = (pred[test_mask] == labels[test_mask]).float().mean()\n",
    "\n",
    "        # Save the best validation accuracy and the corresponding test accuracy.\n",
    "        if best_val_acc < val_acc:\n",
    "            best_val_acc = val_acc\n",
    "            best_test_acc = test_acc\n",
    "\n",
    "        # Backward\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if e % 5 == 0:\n",
    "            print(\n",
    "                f\"In epoch {e}, loss: {loss:.3f}, val acc: {val_acc:.3f} (best {best_val_acc:.3f}), test acc: {test_acc:.3f} (best {best_test_acc:.3f})\"\n",
    "            )\n",
    "\n",
    "\n",
    "train(g, model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what accuracy we got in the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([3, 4, 4,  ..., 3, 4, 3])\n",
      "Accuracy: 0.7540\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Atikin\\AppData\\Local\\Temp/ipykernel_9164/165596389.py:13: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  x = F.log_softmax(x)\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "features = g.ndata[\"feat\"]\n",
    "pred = model(g, features).argmax(dim=1)\n",
    "print(pred)\n",
    "correct = (pred[g.ndata['test_mask']] == g.ndata[\"label\"][g.ndata[\"test_mask\"]]).sum()\n",
    "acc = int(correct) / int(g.ndata['test_mask'].sum())\n",
    "print(f'Accuracy: {acc:.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we save the entire model to a file. Since the model uses PyTorch as a back-up, saving occurs through PyTorch functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model, './models/crd_cls_model.pt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now let’s load the model and make an inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CRD_CLS(\n",
       "  (conv1): GraphConv(in=1433, out=20, normalization=both, activation=None)\n",
       "  (conv2): GraphConv(in=20, out=7, normalization=both, activation=None)\n",
       ")"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_inf = torch.load('./models/crd_cls_model.pt')\n",
    "model_inf.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([3, 4, 4,  ..., 3, 3, 3])\n",
      "Accuracy: 0.7420\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Atikin\\AppData\\Local\\Temp/ipykernel_9164/165596389.py:13: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  x = F.log_softmax(x)\n"
     ]
    }
   ],
   "source": [
    "features = g.ndata[\"feat\"]\n",
    "pred = model_inf(g, features).argmax(dim=1)\n",
    "print(pred)\n",
    "correct = (pred[g.ndata['test_mask']] == g.ndata[\"label\"][g.ndata[\"test_mask\"]]).sum()\n",
    "acc = int(correct) / int(g.ndata['test_mask'].sum())\n",
    "print(f'Accuracy: {acc:.4f}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "data_sience",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}