CS224W_Colab3_2023.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "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.3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pipaber/GNN/blob/main/CS224W_Colab3_2023.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XuXWJLEm2UWS"
      },
      "source": [
        "# **CS224W - Colab 3**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8gzsP50bF6Gb"
      },
      "source": [
        "In Colab 2 we constructed GNN models by using PyTorch Geometric's built in GCN layer, `GCNConv`. In this Colab we will go a step deeper and implement the **GraphSAGE** ([Hamilton et al. (2017)](https://arxiv.org/abs/1706.02216)) layer directly. Then we will run our models on the CORA dataset, which is a standard citation network benchmark dataset.\n",
        "\n",
        "**Note**: Make sure to **sequentially run all the cells in each section** so that the intermediate variables / packages will carry over to the next cell\n",
        "\n",
        "Have fun and good luck on Colab 3 :)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MSaetj53YnT6"
      },
      "source": [
        "# Device\n",
        "We recommend using a GPU for this Colab.\n",
        "\n",
        "Please click `Runtime` and then `Change runtime type`. Then set the `hardware accelerator` to **GPU**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "67gOQITlCNQi"
      },
      "source": [
        "## Installation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J_m9l6OYCQZP"
      },
      "source": [
        "# Install torch geometric\n",
        "import os\n",
        "import torch\n",
        "if 'IS_GRADESCOPE_ENV' not in os.environ:\n",
        "  torch_version = str(torch.__version__)\n",
        "  scatter_src = f\"https://pytorch-geometric.com/whl/torch-{torch_version}.html\"\n",
        "  sparse_src = f\"https://pytorch-geometric.com/whl/torch-{torch_version}.html\"\n",
        "  !pip install torch-scatter -f $scatter_src\n",
        "  !pip install torch-sparse -f $sparse_src\n",
        "  !pip install torch-geometric\n",
        "  !pip install -q git+https://github.com/snap-stanford/deepsnap.git"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PRfgbfTjCRD_"
      },
      "source": [
        "import torch_geometric\n",
        "torch_geometric.__version__"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZoXlf4MtYrbz"
      },
      "source": [
        "# 1) GNN Layers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TQy2RBfgYut4"
      },
      "source": [
        "## Implementing Layer Modules\n",
        "\n",
        "In Colab 2, we implemented a GCN model for node and graph classification tasks. However, for that notebook we took advantage of PyG's built in GCN module. For Colab 3, we provide a build upon a general Graph Neural Network Stack, into which we will be able to plugin our own module implementations: GraphSAGE and GAT.\n",
        "\n",
        "We will then use our layer implemenations to complete node classification on the CORA dataset, a standard citation network benchmark. In this dataset, nodes correspond to documents and edges correspond to undirected citations. Each node or document in the graph is assigned a class label and features based on the documents binarized bag-of-words representation. Specifically, the Cora graph has 2708 nodes, 5429 edges, 7 prediction classes, and 1433 features per node."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H4ne6Gw-CT5G"
      },
      "source": [
        "## GNN Stack Module\n",
        "\n",
        "Below is the implementation of a general GNN stack, where we can plugin any GNN layer, such as **GraphSage**, **GAT**, etc. This module is provided for you. Your implementations of the **GraphSage** and **GAT** (Colab 4) layers will function as components in the GNNStack Module."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ys8vZAFPCWWe"
      },
      "source": [
        "import torch\n",
        "import torch_scatter\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "import torch_geometric.nn as pyg_nn\n",
        "import torch_geometric.utils as pyg_utils\n",
        "\n",
        "from torch import Tensor\n",
        "from typing import Union, Tuple, Optional\n",
        "from torch_geometric.typing import (OptPairTensor, Adj, Size, NoneType,\n",
        "                                    OptTensor)\n",
        "\n",
        "from torch.nn import Parameter, Linear\n",
        "from torch_sparse import SparseTensor, set_diag\n",
        "from torch_geometric.nn.conv import MessagePassing\n",
        "from torch_geometric.utils import remove_self_loops, add_self_loops, softmax\n",
        "\n",
        "class GNNStack(torch.nn.Module):\n",
        "    def __init__(self, input_dim, hidden_dim, output_dim, args, emb=False):\n",
        "        super(GNNStack, self).__init__()\n",
        "        conv_model = self.build_conv_model(args.model_type)\n",
        "        self.convs = nn.ModuleList()\n",
        "        self.convs.append(conv_model(input_dim, hidden_dim))\n",
        "        assert (args.num_layers >= 1), 'Number of layers is not >=1'\n",
        "        for l in range(args.num_layers-1):\n",
        "            self.convs.append(conv_model(args.heads * hidden_dim, hidden_dim))\n",
        "\n",
        "        # post-message-passing\n",
        "        self.post_mp = nn.Sequential(\n",
        "            nn.Linear(args.heads * hidden_dim, hidden_dim), nn.Dropout(args.dropout),\n",
        "            nn.Linear(hidden_dim, output_dim))\n",
        "\n",
        "        self.dropout = args.dropout\n",
        "        self.num_layers = args.num_layers\n",
        "\n",
        "        self.emb = emb\n",
        "\n",
        "    def build_conv_model(self, model_type):\n",
        "        if model_type == 'GraphSage':\n",
        "            return GraphSage\n",
        "        elif model_type == 'GAT':\n",
        "            # When applying GAT with num heads > 1, you need to modify the\n",
        "            # input and output dimension of the conv layers (self.convs),\n",
        "            # to ensure that the input dim of the next layer is num heads\n",
        "            # multiplied by the output dim of the previous layer.\n",
        "            # HINT: In case you want to play with multiheads, you need to change the for-loop that builds up self.convs to be\n",
        "            # self.convs.append(conv_model(hidden_dim * num_heads, hidden_dim)),\n",
        "            # and also the first nn.Linear(hidden_dim * num_heads, hidden_dim) in post-message-passing.\n",
        "            return GAT\n",
        "\n",
        "    def forward(self, data):\n",
        "        x, edge_index, batch = data.x, data.edge_index, data.batch\n",
        "\n",
        "        for i in range(self.num_layers):\n",
        "            x = self.convs[i](x, edge_index)\n",
        "            x = F.relu(x)\n",
        "            x = F.dropout(x, p=self.dropout,training=self.training)\n",
        "\n",
        "        x = self.post_mp(x)\n",
        "\n",
        "        if self.emb == True:\n",
        "            return x\n",
        "\n",
        "        return F.log_softmax(x, dim=1)\n",
        "\n",
        "    def loss(self, pred, label):\n",
        "        return F.nll_loss(pred, label)"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5nW_XpEwASNZ"
      },
      "source": [
        "## Creating Our Own Message Passing Layer\n",
        "\n",
        "Now let's start implementing our own message passing layers! Working through this part will help us become acutely familiar with the behind the scenes work of implementing Pytorch Message Passing Layers, allowing us to build our own GNN models. To do so, we will work with and implement 3 critcal functions needed to define a PyG Message Passing Layer: `forward`, `message`, and `aggregate`.\n",
        "\n",
        "Before diving head first into the coding details, let us quickly review the key components of the message passing process. To do so, we will focus on a single round of messsage passing with respect to a single central node $x$. Before message passing, $x$ is associated with a feature vector $x^{l-1}$, and the goal of message passing is to update this feature vector as $x^l$. To do so, we implement the following steps: 1) each neighboring node $v$ passes its current message $v^{l-1}$ across the edge $(x, v)$ - 2) for the node $x$, we aggregate all of the messages of the neighboring nodes (for example through a sum or mean) - and 3) we transform the aggregated information by for example applying linear and non-linear transformations. Altogether, the message passing process is applied such that every node $u$ in our graph updates its embedding by acting as the central node $x$ in step 1-3 described above.\n",
        "\n",
        "\n",
        "Now, we extending this process to that of a single message passing layer, the job of a message passing layer is to update the current feature representation or embedding of each node in a graph by propagating and transforming information within the graph. Overall, the general paradigm of a message passing layers is: 1) pre-processing -> 2) **message passing** / propagation -> 3) post-processing.\n",
        "\n",
        "The `forward` fuction that we will implement for our message passing layer captures this execution logic. Namely, the `forward` function handles the pre and post-processing of node features / embeddings, as well as initiates message passing by calling the `propagate` function.\n",
        "\n",
        "\n",
        "The `propagate` function encapsulates the message passing process! It does so by calling three important functions: 1) `message`, 2) `aggregate`, and 3) `update`. Our implementation will vary slightly from this, as we will not explicitly implement `update`, but instead place the logic for updating node embeddings after message passing and within the `forward` function. To be more specific, after information is propagated (message passing), we can further transform the node embeddings outputed by `propagate`. Therefore, the output of `forward` is exactly the node embeddings after one GNN layer.\n",
        "\n",
        "Lastly, before starting to implement our own layer, let us dig a bit deeper into each of the functions described above:\n",
        "\n",
        "1.\n",
        "\n",
        "```\n",
        "def propagate(edge_index, x=(x_i, x_j), extra=(extra_i, extra_j), size=size):\n",
        "```\n",
        "Calling `propagate` initiates the message passing process. Looking at the function parameters, we highlight a couple of key parameters.\n",
        "\n",
        "  - `edge_index` is passed to the forward function and captures the edge structure of the graph.\n",
        "  - `x=(x_i, x_j)` represents the node features that will be used in message passing. In order to explain why we pass the tuple `(x_i, x_j)`, we first look at how our edges are represented. For every edge $(i, j) \\in {E}$, we can differentiate $i$ as the source or central node ($x_{central}$) and j as the neighboring node ($x_{neighbor}$).\n",
        "  \n",
        "    Taking the example of message passing above, for a central node $u$ we will aggregate and transform all of the messages associated with the nodes $v$ s.t. $(u, v) \\in {E}$ (i.e. $v \\in \\mathscr{N}_{u}$). Thus we see, the subscripts `_i` and `_j` allow us to specifcally differenciate features associated with central nodes (i.e. nodes  recieving message information) and neighboring nodes (i.e. nodes passing messages).\n",
        "\n",
        "    This is definitely a somewhat confusing concept; however, one key thing to remember / wrap your head around is that depending on the perspective, a node $x$ acts as a central node or a neighboring node. In fact, in undirected graphs we store both edge directions (i.e. $(i, j)$ and $(j, i)$). From the central node perspective, `x_i`, x is collecting neighboring information to update its embedding. From a neighboring node perspective, `x_j`, x is passing its message information along the edge connecting it to a different central node.\n",
        "\n",
        "  - `extra=(extra_i, extra_j)` represents additional information that we can associate with each node beyond its current feature embedding. In fact, we can include as many additional parameters of the form `param=(param_i, param_j)` as we would like. Again, we highlight that indexing with `_i` and `_j` allows us to differentiate central and neighboring nodes.\n",
        "\n",
        "  The output of the `propagate` function is a matrix of node embeddings after the message passing process and has shape $[N, d]$.\n",
        "\n",
        "2.\n",
        "```\n",
        "def message(x_j, ...):\n",
        "```\n",
        "The `message` function is called by propagate and constructs the messages from\n",
        "neighboring nodes $j$ to central nodes $i$ for each edge $(i, j)$ in *edge_index*. This function can take any argument that was initially passed to `propagate`. Furthermore, we can again differentiate central nodes and neighboring nodes by appending `_i` or `_j` to the variable name, .e.g. `x_i` and `x_j`. Looking more specifically at the variables, we have:\n",
        "\n",
        "  - `x_j` represents a matrix of feature embeddings for all neighboring nodes passing their messages along their respective edge (i.e. all nodes $j$ for edges $(i, j) \\in {E}$). Thus, its shape is $[|{E}|, d]$!\n",
        "  - In implementing GAT we will see how to access additional variables passed to propagate\n",
        "\n",
        "  Critically, we see that the output of the `message` function is a matrix of neighboring node embeddings ready to be aggregated, having shape $[|{E}|, d]$.\n",
        "\n",
        "3.\n",
        "```\n",
        "def aggregate(self, inputs, index, dim_size = None):\n",
        "```\n",
        "Lastly, the `aggregate` function is used to aggregate the messages from neighboring nodes. Looking at the parameters we highlight:\n",
        "\n",
        "  - `inputs` represents a matrix of the messages passed from neighboring nodes (i.e. the output of the `message` function).\n",
        "  - `index` has the same shape as `inputs` and tells us the central node that corresponding to each of the rows / messages $j$ in the `inputs` matrix. Thus, `index` tells us which rows / messages to aggregate for each central node.\n",
        "\n",
        "  The output of `aggregate` is of shape $[N, d]$.\n",
        "\n",
        "\n",
        "For additional resources refer to the PyG documentation for implementing custom message passing layers: https://pytorch-geometric.readthedocs.io/en/latest/notes/create_gnn.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "syDtxjxoCZgq"
      },
      "source": [
        "## GraphSage Implementation\n",
        "\n",
        "For our first GNN layer, we will implement the well known GraphSage ([Hamilton et al. (2017)](https://arxiv.org/abs/1706.02216)) layer!\n",
        "\n",
        "For a given *central* node $v$ with current embedding $h_v^{l-1}$, the message passing update rule to tranform $h_v^{l-1} \\rightarrow h_v^l$ is as follows:\n",
        "\n",
        "\\begin{equation}\n",
        "h_v^{(l)} = W_l\\cdot h_v^{(l-1)} + W_r \\cdot AGG(\\{h_u^{(l-1)}, \\forall u \\in N(v) \\})\n",
        "\\end{equation}\n",
        "\n",
        "where $W_1$ and $W_2$ are learanble weight matrices and the nodes $u$ are *neighboring* nodes. Additionally, we use mean aggregation for simplicity:\n",
        "\n",
        "\\begin{equation}\n",
        "AGG(\\{h_u^{(l-1)}, \\forall u \\in N(v) \\}) = \\frac{1}{|N(v)|} \\sum_{u\\in N(v)} h_u^{(l-1)}\n",
        "\\end{equation}\n",
        "\n",
        "One thing to note is that we're adding a **skip connection** to our GraphSage implementation through the term $W_l\\cdot h_v^{(l-1)}$.\n",
        "\n",
        "Before implementing this update rule, we encourage you to think about how different parts of the formulas above correspond with the functions outlined earlier: 1) `forward`, 2) `message`, and 3) `aggregate`. As a hint, we are given what the aggregation function is (i.e. mean aggregation)! Now the question remains, what are the messages passed by each neighbor nodes and when do we call the `propagate` function?\n",
        "\n",
        "Note: in this case the message function or messages are actually quite simple. Additionally, remember that the `propagate` function encapsulates the operations of / the outputs of the combined `message` and `aggregate` functions.\n",
        "\n",
        "\n",
        "Lastly, $\\ell$-2 normalization of the node embeddings is applied after each iteration.\n",
        "\n",
        "\n",
        "<font color='red'>For the following questions, DON'T refer to any existing implementations online.</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RwG4HqCFCaOD"
      },
      "source": [
        "class GraphSage(MessagePassing):\n",
        "\n",
        "    def __init__(self, in_channels, out_channels, normalize = True,\n",
        "                 bias = False, **kwargs):\n",
        "        super(GraphSage, self).__init__(**kwargs)\n",
        "\n",
        "        self.in_channels = in_channels\n",
        "        self.out_channels = out_channels\n",
        "        self.normalize = normalize\n",
        "\n",
        "\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here!\n",
        "        # Define the (PyTorch) layers needed for the message and update functions below.\n",
        "        # self.lin_l is the linear transformation that you apply to embedding\n",
        "        #            for central node.\n",
        "        # self.lin_r is the linear transformation that you apply to aggregated\n",
        "        #            message from neighbors.\n",
        "        # Don't forget the bias as part of the linear layers!\n",
        "        # Our implementation is ~2 lines, but don't worry if you deviate from this.\n",
        "\n",
        "        self.lin_l = nn.Linear(self.in_channels, self.out_channels, bias)\n",
        "        self.lin_r = nn.Linear(self.in_channels, self.out_channels, bias)\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        self.reset_parameters()\n",
        "\n",
        "    def reset_parameters(self):\n",
        "        self.lin_l.reset_parameters()\n",
        "        self.lin_r.reset_parameters()\n",
        "\n",
        "    def forward(self, x, edge_index, size = None):\n",
        "        \"\"\"\"\"\"\n",
        "\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here!\n",
        "        # Implement message passing, as well as any post-processing (our update rule).\n",
        "        # 1. Call the propagate function to conduct the message passing.\n",
        "        #    1.1 See the description of propagate above or the following link for more information:\n",
        "        #        https://pytorch-geometric.readthedocs.io/en/latest/notes/create_gnn.html\n",
        "        #    1.2 We will only use the representation for neighbor nodes (x_j), so by default\n",
        "        #        we pass the same representation for central and neighbor nodes as x=(x, x).\n",
        "        # 2. Update our node embedding with skip connection from the previous layer.\n",
        "        # 3. If normalize is set, do L-2 normalization (defined in\n",
        "        #    torch.nn.functional)\n",
        "        #\n",
        "        # Our implementation is ~5 lines, but don't worry if you deviate from this.\n",
        "\n",
        "        out = self.propagate(edge_index=edge_index, x=(x,x), size=size)\n",
        "\n",
        "        out = self.lin_l(x) + self.lin_r(out)\n",
        "\n",
        "        if self.normalize:\n",
        "          out = torch.nn.functional.normalize(out, p=2)\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        return out\n",
        "\n",
        "    def message(self, x_j):\n",
        "\n",
        "\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here!\n",
        "        # Implement your message function here.\n",
        "        # Hint: Look at the formulation of the mean aggregation function, focusing on\n",
        "        # what message each neighboring node passes.\n",
        "        #\n",
        "        # Our implementation is ~1 lines, but don't worry if you deviate from this.\n",
        "\n",
        "        out = x_j\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        return out\n",
        "\n",
        "    def aggregate(self, inputs, index, dim_size = None):\n",
        "\n",
        "\n",
        "        # The axis along which to index number of nodes.\n",
        "        node_dim = self.node_dim\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here!\n",
        "        # Implement your aggregate function here.\n",
        "        # See here as how to use torch_scatter.scatter:\n",
        "        # https://pytorch-scatter.readthedocs.io/en/latest/functions/scatter.html#torch_scatter.scatter\n",
        "        #\n",
        "        # Our implementation is ~1 lines, but don't worry if you deviate from this.\n",
        "\n",
        "        out = torch_scatter.scatter(inputs,index,dim=node_dim, reduce=\"mean\")\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        return out\n"
      ],
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V2dkgSuWCheU"
      },
      "source": [
        "## Building Optimizers\n",
        "\n",
        "This function has been implemented for you. **For grading purposes please use the default Adam optimizer**, but feel free to play with other types of optimizers on your own."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f_TIQ8NPCjBP"
      },
      "source": [
        "import torch.optim as optim\n",
        "\n",
        "def build_optimizer(args, params):\n",
        "    weight_decay = args.weight_decay\n",
        "    filter_fn = filter(lambda p : p.requires_grad, params)\n",
        "    if args.opt == 'adam':\n",
        "        optimizer = optim.Adam(filter_fn, lr=args.lr, weight_decay=weight_decay)\n",
        "    elif args.opt == 'sgd':\n",
        "        optimizer = optim.SGD(filter_fn, lr=args.lr, momentum=0.95, weight_decay=weight_decay)\n",
        "    elif args.opt == 'rmsprop':\n",
        "        optimizer = optim.RMSprop(filter_fn, lr=args.lr, weight_decay=weight_decay)\n",
        "    elif args.opt == 'adagrad':\n",
        "        optimizer = optim.Adagrad(filter_fn, lr=args.lr, weight_decay=weight_decay)\n",
        "    if args.opt_scheduler == 'none':\n",
        "        return None, optimizer\n",
        "    elif args.opt_scheduler == 'step':\n",
        "        scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.opt_decay_step, gamma=args.opt_decay_rate)\n",
        "    elif args.opt_scheduler == 'cos':\n",
        "        scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.opt_restart)\n",
        "    return scheduler, optimizer"
      ],
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hBYdWFwYCkwY"
      },
      "source": [
        "## Training and Testing\n",
        "\n",
        "Here we provide you with the functions to train and test. **Please do not modify this part for grading purposes.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_tZMWRc8CmGg"
      },
      "source": [
        "import time\n",
        "\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.optim as optim\n",
        "from tqdm import trange\n",
        "import pandas as pd\n",
        "import copy\n",
        "\n",
        "from torch_geometric.datasets import TUDataset\n",
        "from torch_geometric.datasets import Planetoid\n",
        "from torch_geometric.data import DataLoader\n",
        "\n",
        "import torch_geometric.nn as pyg_nn\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "def train(dataset, args):\n",
        "\n",
        "    print(\"Node task. test set size:\", np.sum(dataset[0]['test_mask'].numpy()))\n",
        "    print()\n",
        "    test_loader = loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False)\n",
        "\n",
        "    # build model\n",
        "    model = GNNStack(dataset.num_node_features, args.hidden_dim, dataset.num_classes,\n",
        "                            args)\n",
        "    scheduler, opt = build_optimizer(args, model.parameters())\n",
        "\n",
        "    # train\n",
        "    losses = []\n",
        "    test_accs = []\n",
        "    best_acc = 0\n",
        "    best_model = None\n",
        "    for epoch in trange(args.epochs, desc=\"Training\", unit=\"Epochs\"):\n",
        "        total_loss = 0\n",
        "        model.train()\n",
        "        for batch in loader:\n",
        "            opt.zero_grad()\n",
        "            pred = model(batch)\n",
        "            label = batch.y\n",
        "            pred = pred[batch.train_mask]\n",
        "            label = label[batch.train_mask]\n",
        "            loss = model.loss(pred, label)\n",
        "            loss.backward()\n",
        "            opt.step()\n",
        "            total_loss += loss.item() * batch.num_graphs\n",
        "        total_loss /= len(loader.dataset)\n",
        "        losses.append(total_loss)\n",
        "\n",
        "        if epoch % 10 == 0:\n",
        "          test_acc = test(test_loader, model)\n",
        "          test_accs.append(test_acc)\n",
        "          if test_acc > best_acc:\n",
        "            best_acc = test_acc\n",
        "            best_model = copy.deepcopy(model)\n",
        "        else:\n",
        "          test_accs.append(test_accs[-1])\n",
        "\n",
        "    return test_accs, losses, best_model, best_acc, test_loader\n",
        "\n",
        "def test(loader, test_model, is_validation=False, save_model_preds=False, model_type=None):\n",
        "    test_model.eval()\n",
        "\n",
        "    correct = 0\n",
        "    # Note that Cora is only one graph!\n",
        "    for data in loader:\n",
        "        with torch.no_grad():\n",
        "            # max(dim=1) returns values, indices tuple; only need indices\n",
        "            pred = test_model(data).max(dim=1)[1]\n",
        "            label = data.y\n",
        "\n",
        "        mask = data.val_mask if is_validation else data.test_mask\n",
        "        # node classification: only evaluate on nodes in test set\n",
        "        pred = pred[mask]\n",
        "        label = label[mask]\n",
        "\n",
        "        if save_model_preds:\n",
        "          print (\"Saving Model Predictions for Model Type\", model_type)\n",
        "\n",
        "          data = {}\n",
        "          data['pred'] = pred.view(-1).cpu().detach().numpy()\n",
        "          data['label'] = label.view(-1).cpu().detach().numpy()\n",
        "\n",
        "          df = pd.DataFrame(data=data)\n",
        "          # Save locally as csv\n",
        "          df.to_csv('CORA-Node-' + model_type + '.csv', sep=',', index=False)\n",
        "\n",
        "        correct += pred.eq(label).sum().item()\n",
        "\n",
        "    total = 0\n",
        "    for data in loader.dataset:\n",
        "        total += torch.sum(data.val_mask if is_validation else data.test_mask).item()\n",
        "\n",
        "    return correct / total\n",
        "\n",
        "class objectview(object):\n",
        "    def __init__(self, d):\n",
        "        self.__dict__ = d\n"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L7-h7jIsCns4"
      },
      "source": [
        "## Let's Start the Training!\n",
        "\n",
        "We will be working on the CORA dataset on node-level classification.\n",
        "\n",
        "This part is implemented for you. **For grading purposes, please do not modify the default parameters.** However, feel free to play with different configurations just for fun!\n",
        "\n",
        "**Submit your best accuracy and loss on Gradescope.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qe9B45l9Cpz2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 608
        },
        "outputId": "54673c6e-a8e2-4ea0-83e3-04565a561075"
      },
      "source": [
        "if 'IS_GRADESCOPE_ENV' not in os.environ:\n",
        "    for args in [\n",
        "        {'model_type': 'GraphSage', 'dataset': 'cora', 'num_layers': 2, 'heads': 1, 'batch_size': 32, 'hidden_dim': 32, 'dropout': 0.5, 'epochs': 500, 'opt': 'adam', 'opt_scheduler': 'none', 'opt_restart': 0, 'weight_decay': 5e-3, 'lr': 0.01},\n",
        "    ]:\n",
        "        args = objectview(args)\n",
        "        for model in ['GraphSage']:\n",
        "            args.model_type = model\n",
        "\n",
        "            # Match the dimension.\n",
        "            if model == 'GAT':\n",
        "              args.heads = 2\n",
        "            else:\n",
        "              args.heads = 1\n",
        "\n",
        "            if args.dataset == 'cora':\n",
        "                dataset = Planetoid(root='/tmp/cora', name='Cora')\n",
        "            else:\n",
        "                raise NotImplementedError(\"Unknown dataset\")\n",
        "            test_accs, losses, best_model, best_acc, test_loader = train(dataset, args)\n",
        "\n",
        "            print(\"Maximum test set accuracy: {0}\".format(max(test_accs)))\n",
        "            print(\"Minimum loss: {0}\".format(min(losses)))\n",
        "\n",
        "            # Run test for our best model to save the predictions!\n",
        "            test(test_loader, best_model, is_validation=False, save_model_preds=True, model_type=model)\n",
        "            print()\n",
        "\n",
        "            plt.title(dataset.name)\n",
        "            plt.plot(losses, label=\"training loss\" + \" - \" + args.model_type)\n",
        "            plt.plot(test_accs, label=\"test accuracy\" + \" - \" + args.model_type)\n",
        "        plt.legend()\n",
        "        plt.show()\n"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torch_geometric/deprecation.py:26: UserWarning: 'data.DataLoader' is deprecated, use 'loader.DataLoader' instead\n",
            "  warnings.warn(out)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Node task. test set size: 1000\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Training: 100%|██████████| 500/500 [01:48<00:00,  4.60Epochs/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Maximum test set accuracy: 0.809\n",
            "Minimum loss: 0.10542138665914536\n",
            "Saving Model Predictions for Model Type GraphSage\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gHELqjARZ1W5"
      },
      "source": [
        "## Question 1.1: What is the maximum accuracy obtained on the test set for GraphSage? (10 points)\n",
        "\n",
        "Running the cell above will show the results of your best model and save your best model's predictions to a file named *CORA-Node-GraphSage.csv*.  \n",
        "\n",
        "As we have seen before you can view this file by clicking on the *Folder* icon on the left side pannel. When you sumbit your assignment, you will have to download this file and attatch it to your submission."
      ]
    }
  ]
}