hackathon_basics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "# A bit of setup, just ignore this cell\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# for auto-reloading external modules\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (8.0, 6.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "plt.rcParams['animation.html'] = 'html5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mxnet as mx\n",
    "from mxnet import gluon, nd, autograd\n",
    "from mxnet.gluon import nn\n",
    "\n",
    "import dgl\n",
    "import dgl.function as fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from reddit_gcn import load_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Features...\n",
      "Generating graph\n",
      "#Nodes: 165534\n",
      "#Edges: 2276551\n",
      "Labels...\n",
      "Making training/testing masks\n"
     ]
    }
   ],
   "source": [
    "g, feat, label, train_mask, test_mask = load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "[49.]\n",
       "<NDArray 1 @cpu(0)>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "ctx = mx.cpu(0)\n",
    "feat = nd.array(feat, ctx=ctx)\n",
    "label = nd.array(label, ctx=ctx)\n",
    "train_mask = nd.array(train_mask, ctx=ctx)\n",
    "test_mask = nd.array(test_mask, ctx=ctx)\n",
    "n_train_samples = train_mask.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate normalization\n",
    "degs = g.in_degrees().astype('float32').asnumpy()\n",
    "norm = np.power(degs, -0.5).reshape(-1, 1)\n",
    "norm[np.isinf(norm)] = 0.\n",
    "norm = nd.array(norm, ctx=ctx)\n",
    "g.ndata['norm'] = norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'norm': \n",
       "[[0.2773501 ]\n",
       " [0.13130644]\n",
       " [0.22941573]\n",
       " ...\n",
       " [1.        ]\n",
       " [0.18257418]\n",
       " [0.20851442]]\n",
       "<NDArray 165534x1 @cpu(0)>}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.ndata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "gcn_message = fn.copy_u('h', 'msg')\n",
    "gcn_reduce = fn.sum('msg', 'h')\n",
    "\n",
    "class GCN(gluon.Block):\n",
    "    def __init__(self, out_feats):\n",
    "        super(GCN, self).__init__()\n",
    "        self.dense_1 = nn.Dense(64)\n",
    "        #self.dropout\n",
    "        self.linear = nn.Dense(out_feats)\n",
    "    \n",
    "    def forward(self, g, inputs):\n",
    "        # g is the graph and the inputs is the input node features\n",
    "        # first perform linear transformation\n",
    "        h = self.dense_1(inputs).relu()\n",
    "        h = self.linear(h)\n",
    "        \n",
    "        # set the node features\n",
    "        g.ndata['h'] = h\n",
    "        # trigger message passing, gcn_message and gcn_reduce will be defined later\n",
    "        g.update_all(gcn_message, gcn_reduce)\n",
    "        # get the result node features\n",
    "        h = g.ndata.pop('h')\n",
    "        return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(net, g, X, y, mask):\n",
    "    logits = net(g, X)\n",
    "    logits = logits[mask]\n",
    "    labels = y[mask]\n",
    "    indices = logits.argmax(axis=1)\n",
    "    accuracy = (indices == labels).sum() / labels.shape[0]\n",
    "    return accuracy.asscalar()\n",
    "\n",
    "def train(net, g, X, y, train_mask, test_mask, epochs=1):\n",
    "    trainer = gluon.Trainer(\n",
    "        net.collect_params(), 'adam',\n",
    "        {'learning_rate': 0.01, 'wd': 5e-4}\n",
    "    )\n",
    "    \n",
    "    loss_fcn = gluon.loss.SoftmaxCELoss()\n",
    "\n",
    "    X_ = X.as_in_context(ctx)\n",
    "    y_ = y.as_in_context(ctx)\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        with autograd.record():\n",
    "            logits = net(g, X_)\n",
    "            loss = loss_fcn(logits[train_mask], y_[train_mask]).sum() / train_mask.shape[0]\n",
    "\n",
    "        loss.backward()\n",
    "        trainer.step(batch_size=1)\n",
    "\n",
    "        train_acc = evaluate(net, g, X_, y_, train_mask)\n",
    "        test_acc = evaluate(net, g, X_, y_, test_mask)\n",
    "        print('Epoch %d, Loss %f, Train acc %f, Test acc %f' % (epoch, loss.asscalar(), train_acc, test_acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = GCN(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.initialize(ctx=ctx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0, Loss 3.913624, Train acc 0.132106, Test acc 0.108000\n",
      "Epoch 1, Loss 3.746692, Train acc 0.090555, Test acc 0.085000\n"
     ]
    }
   ],
   "source": [
    "train(net, g, feat, label, train_mask, test_mask, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_python3",
   "language": "python",
   "name": "conda_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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}