CS224W_Colab_3.ipynb

{
  "cells": [
    {
      "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 built in GCN layer, the `GCNConv`. In this Colab we will implement the **GraphSAGE** ([Hamilton et al. (2017)](https://arxiv.org/abs/1706.02216)) and **GAT** ([Veličković et al. (2018)](https://arxiv.org/abs/1710.10903)) layers directly. Then we will run our models on the CORA dataset, which is a standard citation network benchmark dataset.\n",
        "\n",
        "We will then use [DeepSNAP](https://snap.stanford.edu/deepsnap/), a Python library assisting efficient deep learning on graphs, to split the graphs in different settings and apply dataset transformations.\n",
        "\n",
        "At last, using DeepSNAP transductive link prediction split functionality, we will construct a simple GNN model on the edge property predition (link prediction) task.\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 on Colab 3 :)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MSaetj53YnT6"
      },
      "source": [
        "# Device\n",
        "You might need to use 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",
      "execution_count": 1,
      "metadata": {
        "id": "J_m9l6OYCQZP"
      },
      "outputs": [],
      "source": [
        "!pip install -q torch-scatter -f https://pytorch-geometric.com/whl/torch-1.7.0+cu101.html\n",
        "!pip install -q torch-sparse -f https://pytorch-geometric.com/whl/torch-1.7.0+cu101.html\n",
        "!pip install -q torch-geometric\n",
        "!pip install -q git+https://github.com/snap-stanford/deepsnap.git"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "PRfgbfTjCRD_",
        "outputId": "1afc845c-2db5-40fb-c8a9-0cfeba97a920"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.0.4'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "import torch_geometric\n",
        "torch_geometric.__version__"
      ]
    },
    {
      "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 network using GCN in node and graph classification tasks. However, the GCN module we used in colab 2 is from the official library. For this problem, we will provide you with a general Graph Neural Network Stack, where you'll be able to plugin your own modules of GraphSAGE and GATs. We will use our implementations to complete node classification on CORA, which is a standard citation network benchmark dataset. In this dataset, nodes correspond to documents and edges correspond to undirected citations. Each node has a class label. The node features are elements of a bag-or-words representation of a document. For the Cora dataset, there are 2708 nodes, 5429 edges, 7 prediction classes for nodes, and 1433 features per node. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H4ne6Gw-CT5G"
      },
      "source": [
        "## GNN Stack Module\n",
        "\n",
        "Below is the implementation for a general GNN Module that could plugin any layers, including **GraphSage**, **GAT**, etc. This module is provided for you, and you own **GraphSage** and **GAT** layers will function as components in the GNNStack Module."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "Ys8vZAFPCWWe"
      },
      "outputs": [],
      "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, one needs 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 when 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)\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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "syDtxjxoCZgq"
      },
      "source": [
        "## GraphSage Implementation\n",
        "\n",
        "Now let's start working on our own implementation of layers! This part is to get you familiar with how to implement Pytorch layer based on Message Passing. You will be implementing the **forward**, **message** and **aggregate** functions.\n",
        "\n",
        "Generally, the **forward** function is where the actual message passing is conducted. All logic in each iteration happens in **forward**, where we'll call **propagate** function to propagate information from neighbor nodes to central nodes.  So the general paradigm will be pre-processing -> propagate -> post-processing.\n",
        "\n",
        "Recall the process of message passing we introduced in homework 1. **propagate** further calls **message** which transforms information of neighbor nodes into messages, **aggregate** which aggregates all messages from neighbor nodes into one, and **update** which further generates the embedding for nodes in the next iteration.\n",
        "\n",
        "Our implementation is slightly variant from this, where we'll not explicitly implement **update**, but put the logic for updating nodes in **forward** function. To be more specific, after information is propagated, we can further conduct some operations on the output of **propagate**. The output of **forward** is exactly the embeddings after the current iteration.\n",
        "\n",
        "In addition, tensors passed to **propagate()** can be mapped to the respective nodes $i$ and $j$ by appending _i or _j to the variable name, .e.g. x_i and x_j. Note that we generally refer to $i$ as the central nodes that aggregates information, and refer to $j$ as the neighboring nodes, since this is the most common notation.\n",
        "\n",
        "Please find more details in the comments. One thing to note is that we're adding **skip connections** to our GraphSage. Formally, the update rule for our model is described as below:\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",
        "For simplicity, we use mean aggregations where:\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",
        "Additionally, $\\ell$-2 normalization is applied after each iteration.\n",
        "\n",
        "In order to complete the work correctly, we have to understand how the different functions interact with each other. In **propagate** we can pass in any parameters we want. For example, we pass in $x$ as an parameter:\n",
        "\n",
        "... = propagate(..., $x$=($x_{central}$, $x_{neighbor}$), ...)\n",
        "\n",
        "Here $x_{central}$ and $x_{neighbor}$ represent the features from **central** nodes and from **neighbor** nodes. If we're using the same representations from central and neighbor, then $x_{central}$ and $x_{neighbor}$ could be identical.\n",
        "\n",
        "Suppose $x_{central}$ and $x_{neighbor}$ are both of shape N * d, where N is number of nodes, and d is dimension of features.\n",
        "\n",
        "Then in message function, we can take parameters called $x\\_i$ and $x\\_j$. Usually $x\\_i$ represents \"central nodes\", and $x\\_j$ represents \"neighbor nodes\". Pay attention to the shape here: $x\\_i$ and $x\\_j$ are both of shape E * d (**not N!**). $x\\_i$ is obtained by concatenating the embeddings of central nodes of all edges through lookups from $x_{central}$ we passed in propagate. Similarly, $x\\_j$ is obtained by concatenating the embeddings of neighbor nodes of all edges through lookups from $x_{neighbor}$ we passed in propagate.\n",
        "\n",
        "Let's look at an example. Suppose we have 4 nodes, so $x_{central}$ and $x_{neighbor}$ are of shape 4 * d. We have two edges (1, 2) and (3, 0). Thus, $x\\_i$ is obtained by $[x_{central}[1]^T; x_{central}[3]^T]^T$, and $x\\_j$ is obtained by $[x_{neighbor}[2]^T; x_{neighbor}[0]^T]^T$\n",
        "\n",
        "<font color='red'>For the following questions, DON'T refer to any existing implementations online.</font>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "RwG4HqCFCaOD"
      },
      "outputs": [],
      "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",
        "        self.lin_l = None\n",
        "        self.lin_r = None\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here! \n",
        "        # Define the 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",
        "        # Our implementation is ~2 lines, but don't worry if you deviate from this.\n",
        "\n",
        "        self.lin_l = nn.Linear(in_features=in_channels, out_features=out_channels)\n",
        "        self.lin_r = nn.Linear(in_features=in_channels, out_features=out_channels)\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",
        "        out = None\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here! \n",
        "        # Implement message passing, as well as any post-processing (our update rule).\n",
        "        # 1. First call propagate function to conduct the message passing.\n",
        "        #    1.1 See there for more information: \n",
        "        #        https://pytorch-geometric.readthedocs.io/en/latest/notes/create_gnn.html\n",
        "        #    1.2 We use the same representations for central (x_central) and \n",
        "        #        neighbor (x_neighbor) nodes, which means you'll pass x=(x, x) \n",
        "        #        to propagate.\n",
        "        # 2. Update our node embedding with skip connection.\n",
        "        # 3. If normalize is set, do L-2 normalization (defined in \n",
        "        #    torch.nn.functional)\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",
        "        out = self.lin_l(x) + self.lin_r(out)\n",
        "        if self.normalize:\n",
        "            out = F.normalize(out, p=2)\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        return out\n",
        "\n",
        "    def message(self, x_j):\n",
        "\n",
        "        out = None\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here! \n",
        "        # Implement your message function here.\n",
        "        # Our implementation is ~1 lines, but don't worry if you deviate from this.\n",
        "\n",
        "\n",
        "        # x_j.shape == [num_edges, num_node_features]\n",
        "        #  Basically, for every edge on the graph there is a message that will be\n",
        "        #  transferred by it. This message has some representation (hidden state).\n",
        "        out = x_j\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        return out\n",
        "\n",
        "    def aggregate(self, inputs, index, dim_size = None):\n",
        "\n",
        "        out = None\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",
        "        # Our implementation is ~1 lines, but don't worry if you deviate from this.\n",
        "\n",
        "\n",
        "        # 1. input.shape == [num_edges, num_node_features]\n",
        "        #       (basically the output of self.message)\n",
        "\n",
        "        # 2. index.shape == [num_edges]\n",
        "        #       (destination node of each edge, basically takes values between [0, ..., num_nodes - 1])\n",
        "\n",
        "        # 3. self.node_dim == -2\n",
        "        #       (the dimension of the nodes in the `inputs` tensor. It's -2 by default in the constructor\n",
        "        #       of MessagePassing (https://pytorch-geometric.readthedocs.io/en/latest/_modules/torch_geometric/nn/conv/message_passing.html#MessagePassing)\n",
        "\n",
        "        # 4. dim_size == index.max() + 1,\n",
        "        #       it will be the size of the output, which will be the number of nodes as we want\n",
        "        #       to compute the aggregated message for every node\n",
        "\n",
        "        # aggregate the message for every node\n",
        "        #  The shape of the output will be: [num_nodes, num_features]\n",
        "        #  (i.e. the aggregated message of every node)\n",
        "        out = torch_scatter.scatter(inputs, index=index, dim=node_dim, dim_size=dim_size, reduce='mean')\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        return out\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qjcfF3RACdLD"
      },
      "source": [
        "## GAT Implementation\n",
        "\n",
        "Attention mechanisms have become the state-of-the-art in many sequence-based tasks such as machine translation and learning sentence representations. One of the major benefits of attention-based mechanisms is their ability to focus on the most relevant parts of the input to make decisions. In this problem, we will see how attention mechanisms can be used to perform node classification of graph-structured data through the usage of Graph Attention Networks (GATs).\n",
        "\n",
        "The building block of the Graph Attention Network is the graph attention layer, which is a variant of the aggregation function . Let $N$ be the number of nodes and $F$ be the dimension of the feature vector for each node. The input to each graph attentional layer is a set of node features: $\\mathbf{h} = \\{\\overrightarrow{h_1}, \\overrightarrow{h_2}, \\dots, \\overrightarrow{h_N}$\\}, $\\overrightarrow{h_i} \\in R^F$. The output of each graph attentional layer is a new set of node features, which may have a new dimension $F'$: $\\mathbf{h'} = \\{\\overrightarrow{h_1'}, \\overrightarrow{h_2'}, \\dots, \\overrightarrow{h_N'}\\}$, with $\\overrightarrow{h_i'} \\in \\mathbb{R}^{F'}$.\n",
        "\n",
        "We will now describe this transformation of the input features into higher-level features performed by each graph attention layer. First, a shared linear transformation parametrized by the weight matrix $\\mathbf{W} \\in \\mathbb{R}^{F' \\times F}$ is applied to every node. Next, we perform self-attention on the nodes. We use a shared attentional mechanism:\n",
        "\\begin{equation} \n",
        "a : \\mathbb{R}^{F'} \\times \\mathbb{R}^{F'} \\rightarrow \\mathbb{R}.\n",
        "\\end{equation}\n",
        "\n",
        "This mechanism computes the attention coefficients that capture the importance of node $j$'s features to node $i$:\n",
        "\\begin{equation}\n",
        "e_{ij} = a(\\mathbf{W_l}\\overrightarrow{h_i}, \\mathbf{W_r} \\overrightarrow{h_j})\n",
        "\\end{equation}\n",
        "The most general formulation of self-attention allows every node to attend to all other nodes which drops all structural information. To utilize graph structure in the attention mechanisms, we can use masked attention. In masked attention, we only compute $e_{ij}$ for nodes $j \\in \\mathcal{N}_i$ where $\\mathcal{N}_i$ is some neighborhood of node $i$ in the graph.\n",
        "\n",
        "To easily compare coefficients across different nodes, we normalize the coefficients across $j$ using a softmax function:\n",
        "\\begin{equation}\n",
        "\\alpha_{ij} = \\text{softmax}_j(e_{ij}) = \\frac{\\exp(e_{ij})}{\\sum_{k \\in \\mathcal{N}_i} \\exp(e_{ik})}\n",
        "\\end{equation}\n",
        "\n",
        "For this problem, our attention mechanism $a$ will be a single-layer feedforward neural network parametrized by a weight vector $\\overrightarrow{a} \\in \\mathbb{R}^{F'}$, followed by a LeakyReLU nonlinearity (with negative input slope 0.2). Let $\\cdot^T$ represent transposition and $||$ represent concatenation. The coefficients computed by our attention mechanism may be expressed as:\n",
        "\n",
        "\\begin{equation}\n",
        "\\alpha_{ij} = \\frac{\\exp\\Big(\\text{LeakyReLU}\\Big(\\overrightarrow{a_l}^T \\mathbf{W_l} \\overrightarrow{h_i} + \\overrightarrow{a_r}^T\\mathbf{W_r}\\overrightarrow{h_j}\\Big)\\Big)}{\\sum_{k\\in \\mathcal{N}_i} \\exp\\Big(\\text{LeakyReLU}\\Big(\\overrightarrow{a_l}^T \\mathbf{W_l} \\overrightarrow{h_i} + \\overrightarrow{a_r}^T\\mathbf{W_r}\\overrightarrow{h_k}\\Big)\\Big)}\n",
        "\\end{equation}\n",
        "\n",
        "For the following questions, we denote $\\alpha_l = [...,\\overrightarrow{a_l}^T \\mathbf{W_l} \\overrightarrow{h_i},...]$ and $\\alpha_r = [..., \\overrightarrow{a_r}^T \\mathbf{W_r} \\overrightarrow{h_j}, ...]$.\n",
        "\n",
        "\n",
        "At every layer of GAT, after the attention coefficients are computed for that layer, the aggregation function can be computed by a weighted sum of neighborhood messages, where weights are specified by $\\alpha_{ij}$.\n",
        "\n",
        "Now, we use the normalized attention coefficients to compute a linear combination of the features corresponding to them. These aggregated features will serve as the final output features for every node.\n",
        "\n",
        "\\begin{equation}\n",
        "h_i' = \\sum_{j \\in \\mathcal{N}_i} \\alpha_{ij} \\mathbf{W_r} \\overrightarrow{h_j}.\n",
        "\\end{equation}\n",
        "\n",
        "To stabilize the learning process of self-attention, we use multi-head attention. To do this we use $K$ independent attention mechanisms, or ``heads'' compute output features as in the above equations. Then, we concatenate these output feature representations:\n",
        "\n",
        "\\begin{equation}\n",
        "    \\overrightarrow{h_i}' = ||_{k=1}^K \\Big(\\sum_{j \\in \\mathcal{N}_i} \\alpha_{ij}^{(k)} \\mathbf{W_r}^{(k)} \\overrightarrow{h_j}\\Big)\n",
        "\\end{equation}\n",
        "\n",
        "where $||$ is concentation, $\\alpha_{ij}^{(k)}$ are the normalized attention coefficients computed by the $k$-th attention mechanism $(a^k)$, and $\\mathbf{W}^{(k)}$ is the corresponding input linear transformation's weight matrix. Note that for this setting, $\\mathbf{h'} \\in \\mathbb{R}^{KF'}$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "w4j45gTpCeXO"
      },
      "outputs": [],
      "source": [
        "class GAT(MessagePassing):\n",
        "\n",
        "    def __init__(self, in_channels, out_channels, heads = 2,\n",
        "                 negative_slope = 0.2, dropout = 0., **kwargs):\n",
        "        super(GAT, self).__init__(node_dim=0, **kwargs)\n",
        "\n",
        "        self.in_channels = in_channels\n",
        "        self.out_channels = out_channels\n",
        "        self.heads = heads\n",
        "        self.negative_slope = negative_slope\n",
        "        self.dropout = dropout\n",
        "\n",
        "        self.lin_l = None\n",
        "        self.lin_r = None\n",
        "        self.att_l = None\n",
        "        self.att_r = None\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here! \n",
        "        # Define the layers needed for the message functions below.\n",
        "        # self.lin_l is the linear transformation that you apply to embeddings \n",
        "        # BEFORE message passing.\n",
        "        # Pay attention to dimensions of the linear layers, since we're using \n",
        "        # multi-head attention.\n",
        "        # Our implementation is ~1 lines, but don't worry if you deviate from this.\n",
        "\n",
        "        self.lin_l = nn.Linear(in_features=in_channels, out_features=out_channels * heads)\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        self.lin_r = self.lin_l\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here! \n",
        "        # Define the attention parameters \\overrightarrow{a_l/r}^T in the above intro.\n",
        "        # You have to deal with multi-head scenarios.\n",
        "        # Use nn.Parameter instead of nn.Linear\n",
        "        # Our implementation is ~2 lines, but don't worry if you deviate from this.\n",
        "\n",
        "        self.att_l = nn.Parameter(data=torch.zeros(heads, out_channels))\n",
        "        self.att_r = nn.Parameter(data=torch.zeros(heads, out_channels))\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        self.reset_parameters()\n",
        "\n",
        "    def reset_parameters(self):\n",
        "        nn.init.xavier_uniform_(self.lin_l.weight)\n",
        "        nn.init.xavier_uniform_(self.lin_r.weight)\n",
        "        nn.init.xavier_uniform_(self.att_l)\n",
        "        nn.init.xavier_uniform_(self.att_r)\n",
        "\n",
        "    def forward(self, x, edge_index, size = None):\n",
        "        \n",
        "        H, C = self.heads, self.out_channels\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here! \n",
        "        # Implement message passing, as well as any pre- and post-processing (our update rule).\n",
        "        # 1. First apply linear transformation to node embeddings, and split that \n",
        "        #    into multiple heads. We use the same representations for source and\n",
        "        #    target nodes, but apply different linear weights (W_l and W_r)\n",
        "        # 2. Calculate alpha vectors for central nodes (alpha_l) and neighbor nodes (alpha_r).\n",
        "        # 3. Call propagate function to conduct the message passing. \n",
        "        #    3.1 Remember to pass alpha = (alpha_l, alpha_r) as a parameter.\n",
        "        #    3.2 See there for more information: https://pytorch-geometric.readthedocs.io/en/latest/notes/create_gnn.html\n",
        "        # 4. Transform the output back to the shape of N * d.\n",
        "        # Our implementation is ~5 lines, but don't worry if you deviate from this.\n",
        "\n",
        "\n",
        "        # x.shape == [num_nodes, num_node_features]       (feature representation of every node)\n",
        "        # edge_index.shape == [2, num_edges]              (indices of nodes for every edge)\n",
        "\n",
        "        # reshape to [num_nodes, num_heads, hidden_size]\n",
        "        x_l = self.lin_l(x).reshape(-1, H, C)\n",
        "        x_r = self.lin_r(x).reshape(-1, H, C)\n",
        "        # alpha vectors\n",
        "        alpha_l = self.att_l * x_l\n",
        "        alpha_r = self.att_r * x_r\n",
        "\n",
        "        out = self.propagate(edge_index=edge_index, x=(x_l, x_r), alpha=(alpha_l, alpha_r), size=size).reshape(-1, H * C)\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        return out\n",
        "\n",
        "\n",
        "    def message(self, x_j, alpha_j, alpha_i, index, ptr, size_i):\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here! \n",
        "        # Implement your message function. Putting the attention in message \n",
        "        # instead of in update is a little tricky.\n",
        "        # 1. Calculate the final attention weights using alpha_i and alpha_j,\n",
        "        #    and apply leaky Relu.\n",
        "        # 2. Calculate softmax over the neighbor nodes for all the nodes. Use \n",
        "        #    torch_geometric.utils.softmax instead of the one in Pytorch.\n",
        "        # 3. Apply dropout to attention weights (alpha).\n",
        "        # 4. Multiply embeddings and attention weights. As a sanity check, the output\n",
        "        #    should be of shape E * H * d.\n",
        "        # 5. ptr (LongTensor, optional): If given, computes the softmax based on\n",
        "        #    sorted inputs in CSR representation. You can simply pass it to softmax.\n",
        "        # Our implementation is ~5 lines, but don't worry if you deviate from this.\n",
        "\n",
        "\n",
        "        # the message is computed differently for GATs (slides 24 - 30: http://snap.stanford.edu/class/cs224w-2020/slides/07-GNN2.pdf)\n",
        "        # we need to compute the attention factor for every edge (i.e. for every hidden state)\n",
        "        # the equations above explain it neatly\n",
        "\n",
        "        # x_j.shape == [num_edges, num_heads, hidden_size]\n",
        "        #       (message being transferred through every edge)\n",
        "\n",
        "        # alpha_i.shape == [num_edges, num_heads, hidden_size]\n",
        "        #       (alpha vector for central nodes)\n",
        "\n",
        "        # alpha_j.shape == [num_edges, num_heads, hidden_size]\n",
        "        #       (alpha vector for neighbor nodes)\n",
        "\n",
        "        # index.shape == [num_edges]\n",
        "        #       (destination node of each edge, basically takes values between [0, ..., num_nodes - 1])\n",
        "\n",
        "        alpha = F.leaky_relu(alpha_i + alpha_j, negative_slope=self.negative_slope)\n",
        "\n",
        "        # compute the attention weights by applying softmax to every group of nodes,\n",
        "        #  using one of the (index, ptr) parameters\n",
        "        if ptr:\n",
        "            att_weight = softmax(alpha, ptr)\n",
        "        else:\n",
        "            att_weight = softmax(alpha, index)\n",
        "        att_weight = F.dropout(att_weight, p=self.dropout)\n",
        "\n",
        "        # out.shape == [num_edges, num_heads, hidden_size]\n",
        "        out = att_weight * x_j\n",
        "\n",
        "        ############################################################################\n",
        "\n",
        "        return out\n",
        "\n",
        "\n",
        "    def aggregate(self, inputs, index, dim_size = None):\n",
        "\n",
        "        ############################################################################\n",
        "        # TODO: Your code here! \n",
        "        # Implement your aggregate function here.\n",
        "        # See here as how to use torch_scatter.scatter: https://pytorch-scatter.readthedocs.io/en/latest/_modules/torch_scatter/scatter.html\n",
        "        # Pay attention to \"reduce\" parameter is different from that in GraphSage.\n",
        "        # Our implementation is ~1 lines, but don't worry if you deviate from this.\n",
        "\n",
        "\n",
        "        # same as in GraphSage, but this time we use the `sum` option for the `reduce` argument and\n",
        "        #   the node dimension (self.node_dim) is 0\n",
        "        out = torch_scatter.scatter(inputs, index=index, dim=self.node_dim, dim_size=dim_size, reduce='sum')\n",
        "\n",
        "        ############################################################################\n",
        "    \n",
        "        return out"
      ]
    },
    {
      "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",
      "execution_count": 6,
      "metadata": {
        "id": "f_TIQ8NPCjBP"
      },
      "outputs": [],
      "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"
      ]
    },
    {
      "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",
      "execution_count": 7,
      "metadata": {
        "id": "_tZMWRc8CmGg"
      },
      "outputs": [],
      "source": [
        "import time\n",
        "\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.optim as optim\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]['train_mask'].numpy()))\n",
        "    test_loader = loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)\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",
        "    for epoch in range(args.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",
        "        else:\n",
        "          test_accs.append(test_accs[-1])\n",
        "    return test_accs, losses\n",
        "\n",
        "def test(loader, model, is_validation=True):\n",
        "    model.eval()\n",
        "\n",
        "    correct = 0\n",
        "    for data in loader:\n",
        "        with torch.no_grad():\n",
        "            # max(dim=1) returns values, indices tuple; only need indices\n",
        "            pred = 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 = data.y[mask]\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",
        "    return correct / total\n",
        "  \n",
        "class objectview(object):\n",
        "    def __init__(self, d):\n",
        "        self.__dict__ = d\n"
      ]
    },
    {
      "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",
      "execution_count": 8,
      "metadata": {
        "id": "qe9B45l9Cpz2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 594
        },
        "outputId": "30fb1e33-6e96-4dcd-9bbb-a785f7510251"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.x\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.tx\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.allx\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.y\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.ty\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.ally\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.graph\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.test.index\n",
            "Processing...\n",
            "Done!\n",
            "/usr/local/lib/python3.7/dist-packages/torch_geometric/deprecation.py:12: 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: 140\n",
            "Maximum accuracy: 0.75\n",
            "Minimum loss: 0.10954304784536362\n",
            "Node task. test set size: 140\n",
            "Maximum accuracy: 0.748\n",
            "Minimum loss: 0.030439648777246475\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "def main():\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', 'GAT']:\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 = train(dataset, args) \n",
        "\n",
        "            print(\"Maximum accuracy: {0}\".format(max(test_accs)))\n",
        "            print(\"Minimum loss: {0}\".format(min(losses)))\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",
        "\n",
        "if __name__ == '__main__':\n",
        "    main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gHELqjARZ1W5"
      },
      "source": [
        "## Question 1.1: What is the maximum accuracy you could get on test set for GraphSage? (10 points)\n",
        "\n",
        "Submit your answers on Gradescope."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PlCtBEBLMBkR"
      },
      "source": [
        "## Question 1.2: What is the maximum accuracy you could get on test set for GAT? (10 points)\n",
        "\n",
        "Submit your answers on Gradescope."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nwwq0nSdmsOL"
      },
      "source": [
        "# 2 DeepSNAP Basics\n",
        "\n",
        "In previous Colabs we used both of graph class (NetworkX) and tensor (PyG) representations of graphs separately. The graph class `nx.Graph` provides rich analysis and manipulation functionalities, such as the clustering coefficient and PageRank. To feed the graph into the model, we need to transform the graph into tensor representations including edge tensor `edge_index` and node attributes tensors `x` and `y`. But only using tensors (as the graphs formatted in PyG `datasets` and `data`) will make many graph manipulations and analysis less efficient and harder. So, in this Colab we will use DeepSNAP which combines both representations and offers a full pipeline for GNN training / validation / testing.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sf7vUmdNKCjA"
      },
      "source": [
        "In general, [DeepSNAP](https://github.com/snap-stanford/deepsnap) is a Python library to assist efficient deep learning on graphs. DeepSNAP features in its support for flexible graph manipulation, standard pipeline, heterogeneous graphs and simple API.\n",
        "\n",
        "1. DeepSNAP is easy to be used for the sophisticated graph manipulations, such as feature computation, pretraining, subgraph extraction etc. during/before the training.\n",
        "2. In most frameworks, standard pipelines for node, edge, link, graph-level tasks under inductive or transductive settings are left to the user to code. In practice, there are additional design choices involved (such as how to split dataset for link prediction). DeepSNAP provides such a standard pipeline that greatly saves repetitive coding efforts, and enables fair comparision for models.\n",
        "3. Many real-world graphs are heterogeneous graphs. But packages support for heterogeneous graphs, including data storage and flexible message passing, is lacking. DeepSNAP provides an efficient and flexible heterogeneous graph that supports both the node and edge heterogeneity.\n",
        "\n",
        "[DeepSNAP](https://github.com/snap-stanford/deepsnap) is a newly released project and it is still under development. If you find any bugs or have any improvement ideas, feel free to raise issues or create pull requests on the GitHub directly :)\n",
        "\n",
        "In this Colab, we will focus on DeepSNAP graph manipulations and splitting settings."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "20SvvngpQmmQ"
      },
      "source": [
        "## Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "zfbBVFmAQlwz"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import networkx as nx\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from deepsnap.graph import Graph\n",
        "from deepsnap.batch import Batch\n",
        "from deepsnap.dataset import GraphDataset\n",
        "from torch_geometric.datasets import Planetoid, TUDataset\n",
        "\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "def visualize(G, color_map=None, seed=123):\n",
        "  if color_map is None:\n",
        "    color_map = '#c92506'\n",
        "  plt.figure(figsize=(8, 8))\n",
        "  nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G, seed=seed), \\\n",
        "                                 label=None, node_color=color_map, node_shape='o', node_size=150)\n",
        "  edges = nx.draw_networkx_edges(G, pos=nx.spring_layout(G, seed=seed), alpha=0.5)\n",
        "  if color_map is not None:\n",
        "    plt.scatter([],[], c='#c92506', label='Nodes with label 0', edgecolors=\"black\", s=140)\n",
        "    plt.scatter([],[], c='#fcec00', label='Nodes with label 1', edgecolors=\"black\", s=140)\n",
        "    plt.legend(prop={'size': 13}, handletextpad=0)\n",
        "  nodes.set_edgecolor('black')\n",
        "  plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ic-o1P3r6hr2"
      },
      "source": [
        "## DeepSNAP Graph\n",
        "\n",
        "The `deepsnap.graph.Graph` class is the core class of DeepSNAP. It not only represents a graph in tensor format but also references to a graph object from graph manipulation package.\n",
        "\n",
        "Currently DeepSNAP supports [NetworkX](https://networkx.org/) and [Snap.py](https://snap.stanford.edu/snappy/doc/index.html) as the back end graph manipulation package.\n",
        "\n",
        "In this Colab, we will use the NetworkX as the back end graph manipulation package."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ispq_lIoJl_z"
      },
      "source": [
        "Lets first try to convert a simple random NetworkX graph to a DeepSNAP graph."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "zT5qca3x6XpG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 570
        },
        "outputId": "9c85c09c-4fb0-4d84-f8f0-2519cf0b48aa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0, {'node_feature': tensor([0.3348, 0.2303, 0.3823, 0.2579, 0.9198]), 'node_label': tensor(0)})\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Graph(G=[], edge_index=[2, 524], edge_label_index=[2, 524], node_feature=[100, 5], node_label=[100], node_label_index=[100])\n",
            "Node feature (node_feature) has shape torch.Size([100, 5]) and type torch.float32\n",
            "Node label (node_label) has shape torch.Size([100]) and type torch.int64\n",
            "Edge index (edge_index) has shape torch.Size([2, 524]) and type torch.int64\n",
            "The DeepSNAP graph has <class 'networkx.classes.graph.Graph'> as the internal manupulation graph\n"
          ]
        }
      ],
      "source": [
        "num_nodes = 100\n",
        "p = 0.05\n",
        "seed = 100\n",
        "\n",
        "# Generate a networkx random graph\n",
        "G = nx.gnp_random_graph(num_nodes, p, seed=seed)\n",
        "\n",
        "# Generate some random node features and labels\n",
        "node_feature = {node : torch.rand([5, ]) for node in G.nodes()}\n",
        "node_label = {node : torch.randint(0, 2, ()) for node in G.nodes()}\n",
        "\n",
        "# Set the random features and labels to G\n",
        "nx.set_node_attributes(G, node_feature, name='node_feature')\n",
        "nx.set_node_attributes(G, node_label, name='node_label')\n",
        "\n",
        "# Print one node example\n",
        "for node in G.nodes(data=True):\n",
        "  print(node)\n",
        "  break\n",
        "\n",
        "color_map = ['#c92506' if node[1]['node_label'].item() == 0 else '#fcec00' for node in G.nodes(data=True)]\n",
        "\n",
        "# Visualize the graph\n",
        "visualize(G, color_map=color_map)\n",
        "\n",
        "# Transform the networkx graph into the deepsnap graph\n",
        "graph = Graph(G)\n",
        "\n",
        "# Print out the general deepsnap graph information\n",
        "print(graph)\n",
        "\n",
        "# DeepSNAP will convert node attributes to tensors\n",
        "# Notice the type of tensors\n",
        "print(\"Node feature (node_feature) has shape {} and type {}\".format(graph.node_feature.shape, graph.node_feature.dtype))\n",
        "print(\"Node label (node_label) has shape {} and type {}\".format(graph.node_label.shape, graph.node_label.dtype))\n",
        "\n",
        "# DeepSNAP will also generate the edge_index tensor\n",
        "print(\"Edge index (edge_index) has shape {} and type {}\".format(graph.edge_index.shape, graph.edge_index.dtype))\n",
        "\n",
        "# Different from only storing tensors, deepsnap graph also references to the networkx graph\n",
        "# We will discuss why the reference will be helpful later\n",
        "print(\"The DeepSNAP graph has {} as the internal manupulation graph\".format(type(graph.G)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PNMbc307KOQD"
      },
      "source": [
        "In DeepSNAP we have three levels of attributes. In this example, we have the **node level** attributes including `node_feature` and `node_label`. The other two levels of attributes are graph and edge attributes. The usage is similar to the node level one except that the feature becomes `edge_feature` or `graph_feature` and label becomes `edge_label` or `graph_label` etc."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G8Xz58_Da0qL"
      },
      "source": [
        "Similar to the NetworkX graph, we can easily get some basic information of the graph through class properties directly."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "dLo4zWAoeg6S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e79245ca-d154-409f-c90d-f6c1e1c3bca5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The random graph has 100 nodes\n",
            "The random graph has 262 edges\n"
          ]
        }
      ],
      "source": [
        "# Number of nodes\n",
        "print(\"The random graph has {} nodes\".format(graph.num_nodes))\n",
        "\n",
        "# Number of edges\n",
        "print(\"The random graph has {} edges\".format(graph.num_edges))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Po7IaRmwblI5"
      },
      "source": [
        "DeepSNAP also provides functions that can automatically transform the PyG datasets into a list of DeepSNAP graphs.\n",
        "\n",
        "Here we transform the CORA dataset into a list of DeepSNAP graphs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "ZFkg2kCgcFwR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "97aa874e-996a-4627-c1d4-dd8c2aaeef25"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.x\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.tx\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.allx\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.y\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.ty\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.ally\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.graph\n",
            "Downloading https://github.com/kimiyoung/planetoid/raw/master/data/ind.cora.test.index\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Graph(G=[], edge_index=[2, 10556], edge_label_index=[2, 10556], node_feature=[2708, 1433], node_label=[2708], node_label_index=[2708])\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Processing...\n",
            "Done!\n"
          ]
        }
      ],
      "source": [
        "root = './tmp/cora'\n",
        "name = 'Cora'\n",
        "\n",
        "# The Cora dataset\n",
        "pyg_dataset= Planetoid(root, name)\n",
        "\n",
        "# PyG dataset to a list of deepsnap graphs\n",
        "graphs = GraphDataset.pyg_to_graphs(pyg_dataset)\n",
        "\n",
        "# Get the first deepsnap graph (CORA only has one graph)\n",
        "graph = graphs[0]\n",
        "print(graph)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NLm5vVYMAP2x"
      },
      "source": [
        "## Question 2.1: What is the number of classes and number of features in the CORA graph? (5 points)\n",
        "\n",
        "Submit your answers on Gradescope."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "8iF_Kyqr_JbY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6231a1b1-485e-4ae6-cacf-3369fdfad5d8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cora has 7 classes\n",
            "Cora has 1433 features\n"
          ]
        }
      ],
      "source": [
        "def get_num_node_classes(graph):\n",
        "  # TODO: Implement this function that takes a deepsnap graph object\n",
        "  # and return the number of node classes of that graph.\n",
        "\n",
        "  num_node_classes = 0\n",
        "\n",
        "  ############# Your code here #############\n",
        "  ## (~1 line of code)\n",
        "  ## Note\n",
        "  ## 1. Colab autocomplete functionality might be useful\n",
        "  ## 2. DeepSNAP documentation might be useful https://snap.stanford.edu/deepsnap/modules/graph.html\n",
        "\n",
        "  num_node_classes = graph.num_node_labels\n",
        "\n",
        "  ##########################################\n",
        "\n",
        "  return num_node_classes\n",
        "\n",
        "def get_num_node_features(graph):\n",
        "  # TODO: Implement this function that takes a deepsnap graph object\n",
        "  # and return the number of node features of that graph.\n",
        "\n",
        "  num_node_features = 0\n",
        "\n",
        "  ############# Your code here #############\n",
        "  ## (~1 line of code)\n",
        "  ## Note\n",
        "  ## 1. Colab autocomplete functionality might be useful\n",
        "  ## 2. DeepSNAP documentation might be useful https://snap.stanford.edu/deepsnap/modules/graph.html\n",
        "\n",
        "  num_node_features = graph.num_node_features\n",
        "\n",
        "  ##########################################\n",
        "\n",
        "  return num_node_features\n",
        "\n",
        "num_node_classes = get_num_node_classes(graph)\n",
        "num_node_features = get_num_node_features(graph)\n",
        "print(\"{} has {} classes\".format(name, num_node_classes))\n",
        "print(\"{} has {} features\".format(name, num_node_features))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rwKbzhHUAckZ"
      },
      "source": [
        "## DeepSNAP Dataset\n",
        "\n",
        "Now, lets talk about DeepSNAP dataset. A `deepsnap.dataset.GraphDataset` contains a list of `deepsnap.graph.Graph` objects. In addition to list of graphs, you can also specify what task the dataset will be used on, such as node level task (`task=node`), edge level task (`task=link_pred`) and graph level task (`task=graph`).\n",
        "\n",
        "It also contains many other useful parameters during initialization and other functinoalities. If you are interested, you can take a look at the [documentation](https://snap.stanford.edu/deepsnap/modules/dataset.html#deepsnap-graphdataset)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HSidf9E0hn2s"
      },
      "source": [
        "Lets now use COX2 dataset which contains a list of graphs and specify the task to `graph` when we initialize the DeepSNAP dataset."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "l4kqUldyoaS_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4f1a33e7-cf45-445f-870e-10f383ede1e1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading https://www.chrsmrrs.com/graphkerneldatasets/COX2.zip\n",
            "Extracting tmp/cox2/COX2/COX2.zip\n",
            "Processing...\n",
            "Done!\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GraphDataset(467)\n"
          ]
        }
      ],
      "source": [
        "root = './tmp/cox2'\n",
        "name = 'COX2'\n",
        "\n",
        "# Load the dataset through PyG\n",
        "pyg_dataset = TUDataset(root, name)\n",
        "\n",
        "# Convert to a list of deepsnap graphs\n",
        "graphs = GraphDataset.pyg_to_graphs(pyg_dataset)\n",
        "\n",
        "# Convert list of deepsnap graphs to deepsnap dataset with specified task=graph\n",
        "dataset = GraphDataset(graphs, task='graph')\n",
        "print(dataset)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7sCV3xJWCddX"
      },
      "source": [
        "## Question 2.2: What is the label of the graph (index 100 in the COX2 dataset)? (5 points)\n",
        "\n",
        "Submit your answers on Gradescope."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "LIis9oTZAfs3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bd311392-323a-440d-bcb5-703d52ec5c37"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Graph(G=[], edge_index=[2, 82], edge_label_index=[2, 82], graph_label=[1], node_feature=[39, 35], node_label_index=[39], task=[])\n",
            "Graph with index 100 has label tensor([0])\n"
          ]
        }
      ],
      "source": [
        "def get_graph_class(dataset, idx):\n",
        "  # TODO: Implement this function that takes a deepsnap dataset object,\n",
        "  # the index of the graph in the dataset, and returns the class/label \n",
        "  # of the graph (in integer).\n",
        "\n",
        "  label = -1\n",
        "\n",
        "  ############# Your code here ############\n",
        "  ## (~1 line of code)\n",
        "  ## Note\n",
        "  ## 1. The label refers to the graph-level attribute\n",
        "\n",
        "  label = dataset[idx].graph_label\n",
        "\n",
        "  #########################################\n",
        "\n",
        "  return label\n",
        "\n",
        "graph_0 = dataset[0]\n",
        "print(graph_0)\n",
        "idx = 100\n",
        "label = get_graph_class(dataset, idx)\n",
        "print('Graph with index {} has label {}'.format(idx, label))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fKhcVeAhCwoY"
      },
      "source": [
        "## Question 2.3: What is the number of edges for the graph (index 200 in the COX2 dataset)? (5 points)\n",
        "\n",
        "Submit your answers on Gradescope."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "f5m2DOfhBtWv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c4288da-9e4d-47a1-9f6f-73cb0a122417"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Graph with index 200 has 49 edges\n"
          ]
        }
      ],
      "source": [
        "def get_graph_num_edges(dataset, idx):\n",
        "  # TODO: Implement this function that takes a deepsnap dataset object,\n",
        "  # the index of the graph in dataset, and returns the number of \n",
        "  # edges in the graph (in integer).\n",
        "\n",
        "  num_edges = 0\n",
        "\n",
        "  ############# Your code here ############\n",
        "  ## (~1 lines of code)\n",
        "  ## Note\n",
        "  ## 1. You can use the class property directly\n",
        "\n",
        "  num_edges = dataset[idx].num_edges\n",
        "\n",
        "  #########################################\n",
        "\n",
        "  return num_edges\n",
        "\n",
        "idx = 200\n",
        "num_edges = get_graph_num_edges(dataset, idx)\n",
        "print('Graph with index {} has {} edges'.format(idx, num_edges))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AXa7yIG4E0Fp"
      },
      "source": [
        "# 3 DeepSNAP Advanced\n",
        "\n",
        "We have learned the basic use of DeepSNAP graph and dataset :)\n",
        "\n",
        "Lets move on to some more advanced functionalities.\n",
        "\n",
        "In this section we will use DeepSNAP for faeture computation and transductive/inductive splittings."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y5fsGBLY8cxa"
      },
      "source": [
        "## Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "g-jgRLiQ8cSj"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import networkx as nx\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from deepsnap.graph import Graph\n",
        "from deepsnap.batch import Batch\n",
        "from deepsnap.dataset import GraphDataset\n",
        "from torch_geometric.datasets import Planetoid, TUDataset\n",
        "\n",
        "from torch.utils.data import DataLoader"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HnazPGGAJAZN"
      },
      "source": [
        "## Data Split in Graphs\n",
        "\n",
        "Data splitting in graphs can be much harder than that in CV or NLP.\n",
        "\n",
        "In general, the data splitting in graphs can be divided into two settings, **inductive** and **transductive**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l9KG_MhqsWBp"
      },
      "source": [
        "## Inductive Split\n",
        "\n",
        "As what we have learned in the lecture, inductive setting will split multiple graphs into each training/valiation and test sets.\n",
        "\n",
        "Here is an example of DeepSNAP inductive splitting for a list of graphs in the graph level task (graph classification etc.)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "Gpc6bTm3GF02",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3b39a570-2193-41c0-bfbc-99a7bf69ea9a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "COX2 train dataset: GraphDataset(373)\n",
            "COX2 validation dataset: GraphDataset(46)\n",
            "COX2 test dataset: GraphDataset(48)\n"
          ]
        }
      ],
      "source": [
        "root = './tmp/cox2'\n",
        "name = 'COX2'\n",
        "\n",
        "pyg_dataset = TUDataset(root, name)\n",
        "\n",
        "graphs = GraphDataset.pyg_to_graphs(pyg_dataset)\n",
        "\n",
        "# Here we specify the task as graph-level task such as graph classification\n",
        "task = 'graph'\n",
        "dataset = GraphDataset(graphs, task=task)\n",
        "\n",
        "# Specify transductive=False (inductive)\n",
        "dataset_train, dataset_val, dataset_test = dataset.split(transductive=False, split_ratio=[0.8, 0.1, 0.1])\n",
        "\n",
        "print(\"COX2 train dataset: {}\".format(dataset_train))\n",
        "print(\"COX2 validation dataset: {}\".format(dataset_val))\n",
        "print(\"COX2 test dataset: {}\".format(dataset_test))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yWKQwa4WsgQp"
      },
      "source": [
        "## Transductive Split\n",
        "\n",
        "In transductive setting, the training /validation / test sets are on the same graph.\n",
        "\n",
        "Here we transductively split the CORA graph in the node level task. \n",
        "\n",
        "(Notice that in DeepSNAP default setting the split is random, but you can also make a fixed split by specifying `fixed_split=True` when loading the dataset from PyG or changing the `node_label_index` directly)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "b5OdxSg4sfyR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "26c3a0e5-9e9d-4d0a-944a-67135fec5910"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cora train dataset: GraphDataset(1)\n",
            "Cora validation dataset: GraphDataset(1)\n",
            "Cora test dataset: GraphDataset(1)\n",
            "Original Cora has 2708 nodes\n",
            "After the split, Cora has 2166 training nodes\n",
            "After the split, Cora has 270 validation nodes\n",
            "After the split, Cora has 272 test nodes\n"
          ]
        }
      ],
      "source": [
        "root = './tmp/cora'\n",
        "name = 'Cora'\n",
        "\n",
        "pyg_dataset = Planetoid(root, name)\n",
        "\n",
        "graphs = GraphDataset.pyg_to_graphs(pyg_dataset)\n",
        "\n",
        "# Here we specify the task as node-level task such as node classification\n",
        "task = 'node'\n",
        "\n",
        "dataset = GraphDataset(graphs, task=task)\n",
        "\n",
        "# Specify we want the transductive splitting\n",
        "dataset_train, dataset_val, dataset_test = dataset.split(transductive=True, split_ratio=[0.8, 0.1, 0.1])\n",
        "\n",
        "print(\"Cora train dataset: {}\".format(dataset_train))\n",
        "print(\"Cora validation dataset: {}\".format(dataset_val))\n",
        "print(\"Cora test dataset: {}\".format(dataset_test))\n",
        "\n",
        "print(\"Original Cora has {} nodes\".format(dataset.num_nodes[0]))\n",
        "\n",
        "# The nodes in each set can be find in node_label_index\n",
        "print(\"After the split, Cora has {} training nodes\".format(dataset_train[0].node_label_index.shape[0]))\n",
        "print(\"After the split, Cora has {} validation nodes\".format(dataset_val[0].node_label_index.shape[0]))\n",
        "print(\"After the split, Cora has {} test nodes\".format(dataset_test[0].node_label_index.shape[0]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d7ePKgM00lGE"
      },
      "source": [
        "## Edge Level Split\n",
        "\n",
        "Compared to the node and graph level splitting, edge level splitting is a little bit tricky ;)\n",
        "\n",
        "Usually in edge level splitting, we need to sample negative edges, split positive edges into different datasets, split training edges into message passing edges and supervision edges, and resample the negative edges during the training etc."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SnzISX5RoiR6"
      },
      "source": [
        "### All Mode\n",
        "\n",
        "Now lets start with a simpler edge level splitting mode, the `edge_train_mode=\"all\"` mode in DeepSNAP."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "_D104xO6137n",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "567db922-38c4-4d76-8d23-870ae3942bf7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cora train dataset: GraphDataset(1)\n",
            "Cora validation dataset: GraphDataset(1)\n",
            "Cora test dataset: GraphDataset(1)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        }
      ],
      "source": [
        "root = './tmp/cora'\n",
        "name = 'Cora'\n",
        "\n",
        "pyg_dataset = Planetoid(root, name)\n",
        "\n",
        "graphs = GraphDataset.pyg_to_graphs(pyg_dataset)\n",
        "\n",
        "# Specify task as link_pred for edge-level task\n",
        "task = 'link_pred'\n",
        "\n",
        "# Specify the train mode, \"all\" mode is default for deepsnap dataset\n",
        "edge_train_mode = \"all\"\n",
        "\n",
        "dataset = GraphDataset(graphs, task=task, edge_train_mode=edge_train_mode)\n",
        "\n",
        "# Transductive link prediction split\n",
        "dataset_train, dataset_val, dataset_test = dataset.split(transductive=True, split_ratio=[0.8, 0.1, 0.1])\n",
        "\n",
        "print(\"Cora train dataset: {}\".format(dataset_train))\n",
        "print(\"Cora validation dataset: {}\".format(dataset_val))\n",
        "print(\"Cora test dataset: {}\".format(dataset_test))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GscopwOXC_Y7"
      },
      "source": [
        "In DeepSNAP, the indices of supervision edges are stored in `edge_label_index` tensor and the corresponding edge labels are stored in `edge_label` tensor."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "XJF8fZnA2eLR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c1332811-03ce-4f54-c136-abe49acef2de"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original Cora graph has 5278 edges\n",
            "Because Cora graph is undirected, the original edge_index has shape torch.Size([2, 10556])\n",
            "The training set has message passing edge index shape torch.Size([2, 8444])\n",
            "The training set has supervision edge index shape torch.Size([2, 16888])\n",
            "The validation set has message passing edge index shape torch.Size([2, 8444])\n",
            "The validation set has supervision edge index shape torch.Size([2, 2108])\n",
            "The test set has message passing edge index shape torch.Size([2, 9498])\n",
            "The test set has supervision edge index shape torch.Size([2, 2116])\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        }
      ],
      "source": [
        "print(\"Original Cora graph has {} edges\".format(dataset[0].num_edges))\n",
        "print(\"Because Cora graph is undirected, the original edge_index has shape {}\".format(dataset[0].edge_index.shape))\n",
        "\n",
        "print(\"The training set has message passing edge index shape {}\".format(dataset_train[0].edge_index.shape))\n",
        "print(\"The training set has supervision edge index shape {}\".format(dataset_train[0].edge_label_index.shape))\n",
        "\n",
        "print(\"The validation set has message passing edge index shape {}\".format(dataset_val[0].edge_index.shape))\n",
        "print(\"The validation set has supervision edge index shape {}\".format(dataset_val[0].edge_label_index.shape))\n",
        "\n",
        "print(\"The test set has message passing edge index shape {}\".format(dataset_test[0].edge_index.shape))\n",
        "print(\"The test set has supervision edge index shape {}\".format(dataset_test[0].edge_label_index.shape))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s6BX-I_oEKQX"
      },
      "source": [
        "We can see that both training and validation sets have the same message passing edges (`edge_index`) in the `all` mode. Also, in training set, the postive supervision edges (`edge_label_index`) are same with the message passing edges. However, in the test set the message passing edges are the combination of message passing edges from training and validation sets.\n",
        "\n",
        "Notice that the `edge_label` and `edge_label_index` have included the negative edges (default number of negative edges is same with the number of positive edges).\n",
        "\n",
        "Now, lets implement a function that checks whether two edge index tensors are disjoint and explore more edge splitting properties by using that function."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YOZHDskbAKN6"
      },
      "source": [
        "## Question 3.1 - 3.5: Implement the function that checks whether two edge_index tensors are disjoint. Then answer the True/False questions below. (5 points)\n",
        "\n",
        "Submit your answers on Gradescope."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "wgRYdyPp8EmO"
      },
      "outputs": [],
      "source": [
        "def edge_indices_disjoint(edge_index_1, edge_index_2):\n",
        "  # TODO: Implement this function that takes two edge index tensors,\n",
        "  # and returns whether these two edge index tensors are disjoint.\n",
        "  disjoint = None\n",
        "\n",
        "  ############# Your code here ############\n",
        "  ## (~5 lines of code)\n",
        "  ## Note\n",
        "  ## 1. Here disjoint means that there is no single edge belongs to either edge index tensors\n",
        "  ## 2. You do not need to consider the undirected case. For example, if edge_index_1 contains\n",
        "  ## edge (a, b) and edge_index_2 contains edge (b, a). We will treat them as disjoint in this\n",
        "  ## function.\n",
        "\n",
        "  edge_index_1 = edge_index_1.permute(1, 0)\n",
        "  edge_index_2 = edge_index_2.permute(1, 0)\n",
        "\n",
        "  disjoint = True\n",
        "  for edge in edge_index_1:\n",
        "      eq = edge_index_2 == edge\n",
        "      if torch.bitwise_and(eq[:, 0], eq[:, 1]).any():\n",
        "          return False\n",
        "\n",
        "  #########################################\n",
        "\n",
        "  return disjoint"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "EL4ASIDDEIUf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb3c48bc-1be3-4bab-980c-174c339ef898"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.1 Training (supervision) positve and negative edges are disjoint = True\n",
            "3.2 Validation (supervision) positve and negative edges are disjoint = True\n",
            "3.3 Test (supervision) positve and negative edges are disjoint = True\n",
            "3.4 Test (supervision) positve and validation (supervision) positve edges are disjoint = True\n",
            "3.5 Validation (supervision) positve and training (supervision) positve edges are disjoint = True\n"
          ]
        }
      ],
      "source": [
        "num_train_edges = dataset_train[0].edge_label_index.shape[1] // 2\n",
        "train_pos_edge_index = dataset_train[0].edge_label_index[:, :num_train_edges]\n",
        "train_neg_edge_index = dataset_train[0].edge_label_index[:, num_train_edges:]\n",
        "print(\"3.1 Training (supervision) positve and negative edges are disjoint = {}\"\\\n",
        "        .format(edge_indices_disjoint(train_pos_edge_index, train_neg_edge_index)))\n",
        "\n",
        "num_val_edges = dataset_val[0].edge_label_index.shape[1] // 2\n",
        "val_pos_edge_index = dataset_val[0].edge_label_index[:, :num_val_edges]\n",
        "val_neg_edge_index = dataset_val[0].edge_label_index[:, num_val_edges:]\n",
        "print(\"3.2 Validation (supervision) positve and negative edges are disjoint = {}\"\\\n",
        "        .format(edge_indices_disjoint(val_pos_edge_index, val_neg_edge_index)))\n",
        "\n",
        "num_test_edges = dataset_test[0].edge_label_index.shape[1] // 2\n",
        "test_pos_edge_index = dataset_test[0].edge_label_index[:, :num_test_edges]\n",
        "test_neg_edge_index = dataset_test[0].edge_label_index[:, num_test_edges:]\n",
        "print(\"3.3 Test (supervision) positve and negative edges are disjoint = {}\"\\\n",
        "        .format(edge_indices_disjoint(test_pos_edge_index, test_neg_edge_index)))\n",
        "\n",
        "print(\"3.4 Test (supervision) positve and validation (supervision) positve edges are disjoint = {}\"\\\n",
        "        .format(edge_indices_disjoint(test_pos_edge_index, val_pos_edge_index)))\n",
        "print(\"3.5 Validation (supervision) positve and training (supervision) positve edges are disjoint = {}\"\\\n",
        "        .format(edge_indices_disjoint(val_pos_edge_index, train_pos_edge_index)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8jLoVN5ZBTuA"
      },
      "source": [
        "### Disjoint Mode\n",
        "\n",
        "Now lets look at a relatively more complex transductive edge split setting, which is the `edge_train_mode=\"disjoint\"` mode in DeepSNAP (also the transductive link prediction splitting talked in the lecture)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "3Rqzfb-0BTBm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "06bd6844-cf98-4181-828b-0a673af34199"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The edge index of original graph has shape: torch.Size([2, 10556])\n",
            "The edge index of training message edges has shape: torch.Size([2, 6754])\n",
            "The edge index of training supervision edges has shape: torch.Size([2, 3380])\n",
            "The edge index of validation message edges has shape: torch.Size([2, 8444])\n",
            "The edge index of validation supervision edges has shape: torch.Size([2, 2108])\n",
            "The edge index of test message edges has shape: torch.Size([2, 9498])\n",
            "The edge index of test supervision edges has shape: torch.Size([2, 2116])\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        }
      ],
      "source": [
        "edge_train_mode = \"disjoint\"\n",
        "\n",
        "dataset = GraphDataset(graphs, task='link_pred', edge_train_mode=edge_train_mode)\n",
        "orig_edge_index = dataset[0].edge_index\n",
        "dataset_train, dataset_val, dataset_test = dataset.split(\n",
        "    transductive=True, split_ratio=[0.8, 0.1, 0.1])\n",
        "\n",
        "train_message_edge_index = dataset_train[0].edge_index\n",
        "train_sup_edge_index = dataset_train[0].edge_label_index\n",
        "val_sup_edge_index = dataset_val[0].edge_label_index\n",
        "test_sup_edge_index = dataset_test[0].edge_label_index\n",
        "\n",
        "print(\"The edge index of original graph has shape: {}\".format(orig_edge_index.shape))\n",
        "print(\"The edge index of training message edges has shape: {}\".format(train_message_edge_index.shape))\n",
        "print(\"The edge index of training supervision edges has shape: {}\".format(train_sup_edge_index.shape))\n",
        "print(\"The edge index of validation message edges has shape: {}\".format(dataset_val[0].edge_index.shape))\n",
        "print(\"The edge index of validation supervision edges has shape: {}\".format(val_sup_edge_index.shape))\n",
        "print(\"The edge index of test message edges has shape: {}\".format(dataset_test[0].edge_index.shape))\n",
        "print(\"The edge index of test supervision edges has shape: {}\".format(test_sup_edge_index.shape))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TUkBhiJNciol"
      },
      "source": [
        "You can see that the training / validation message passing edges and training supervision edges are splitted differently in those two modes!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2WKfRjqAJHtK"
      },
      "source": [
        "### Resample Negative Edges\n",
        "\n",
        "During each training iteration, we usually need to resample the negative edges.\n",
        "\n",
        "Below we print the training and validation sets negative edges in two training iterations.\n",
        "\n",
        "You should find that the negative edges in training set will be resampled."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "AMEbnx63JHWj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7136599f-3e51-47d1-8108-2595ccad70a5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First iteration training negative edges:\n",
            "tensor([[ 378,  176, 1376,  ..., 1253,  579, 2212],\n",
            "        [1297, 1301, 1445,  ..., 1088, 1677,  489]])\n",
            "Second iteration training negative edges:\n",
            "tensor([[1874, 1337, 1555,  ...,  367, 1231, 1807],\n",
            "        [1828,  254, 2029,  ...,  199, 2425,  813]])\n",
            "First iteration validation negative edges:\n",
            "tensor([[2688,    4, 2706,  ...,  937, 1122, 1076],\n",
            "        [2053, 1895, 1364,  ..., 2665, 2399, 1563]])\n",
            "Second iteration validation negative edges:\n",
            "tensor([[2688,    4, 2706,  ...,  937, 1122, 1076],\n",
            "        [2053, 1895, 1364,  ..., 2665, 2399, 1563]])\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        }
      ],
      "source": [
        "dataset = GraphDataset(graphs, task='link_pred', edge_train_mode=\"disjoint\")\n",
        "datasets = {}\n",
        "follow_batch = []\n",
        "datasets['train'], datasets['val'], datasets['test'] = dataset.split(\n",
        "    transductive=True, split_ratio=[0.8, 0.1, 0.1])\n",
        "dataloaders = {\n",
        "  split: DataLoader(\n",
        "    ds, collate_fn=Batch.collate(follow_batch),\n",
        "    batch_size=1, shuffle=(split=='train')\n",
        "  )\n",
        "  for split, ds in datasets.items()\n",
        "}\n",
        "neg_edges_1 = None\n",
        "for batch in dataloaders['train']:\n",
        "  num_edges = batch.edge_label_index.shape[1] // 2\n",
        "  neg_edges_1 = batch.edge_label_index[:, num_edges:]\n",
        "  print(\"First iteration training negative edges:\")\n",
        "  print(neg_edges_1)\n",
        "  break\n",
        "neg_edges_2 = None\n",
        "for batch in dataloaders['train']:\n",
        "  num_edges = batch.edge_label_index.shape[1] // 2\n",
        "  neg_edges_2 = batch.edge_label_index[:, num_edges:]\n",
        "  print(\"Second iteration training negative edges:\")\n",
        "  print(neg_edges_2)\n",
        "  break\n",
        "\n",
        "neg_edges_1 = None\n",
        "for batch in dataloaders['val']:\n",
        "  num_edges = batch.edge_label_index.shape[1] // 2\n",
        "  neg_edges_1 = batch.edge_label_index[:, num_edges:]\n",
        "  print(\"First iteration validation negative edges:\")\n",
        "  print(neg_edges_1)\n",
        "  break\n",
        "neg_edges_2 = None\n",
        "for batch in dataloaders['val']:\n",
        "  num_edges = batch.edge_label_index.shape[1] // 2\n",
        "  neg_edges_2 = batch.edge_label_index[:, num_edges:]\n",
        "  print(\"Second iteration validation negative edges:\")\n",
        "  print(neg_edges_2)\n",
        "  break"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DEzqh7wEdrh0"
      },
      "source": [
        "If you are interested in more graph splitting settings, please refer to the DeepSNAP dataset [documentation](https://snap.stanford.edu/deepsnap/modules/dataset.html)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XkrYyeSUI_9_"
      },
      "source": [
        "## Graph Transformation and Feature Computation\n",
        "\n",
        "The other DeepSNAP core functionality is graph transformation / feature computation.\n",
        "\n",
        "In DeepSNAP, we divide graph transformation / feature computation into two different types. One is the transformation before training (transform the whole dataset before training directly) and another one is the transformation during training (transform batches of graphs).\n",
        "\n",
        "Here is an example that uses NetworkX back end to calculate the PageRank value and update the value to tensors before the training (transform the dataset)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "gnAVbZINLZ4I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e5e34a6e-c793-4b9d-c4b3-55d18aebdd4a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of features before transformation: 35\n",
            "Number of features after transformation: 36\n"
          ]
        }
      ],
      "source": [
        "def pagerank_transform_fn(graph):\n",
        "\n",
        "  # Get the referenced networkx graph\n",
        "  G = graph.G\n",
        "\n",
        "  # Calculate the pagerank by using networkx\n",
        "  pr = nx.pagerank(G)\n",
        "\n",
        "  # Transform the pagerank values to tensor\n",
        "  pr_feature = torch.tensor([pr[node] for node in range(graph.num_nodes)], dtype=torch.float32)\n",
        "  pr_feature = pr_feature.view(graph.num_nodes, 1)\n",
        "\n",
        "  # Concat the pagerank values to the node feature\n",
        "  graph.node_feature = torch.cat([graph.node_feature, pr_feature], dim=-1)\n",
        "\n",
        "root = './tmp/cox2'\n",
        "name = 'COX2'\n",
        "pyg_dataset = TUDataset(root, name)\n",
        "graphs = GraphDataset.pyg_to_graphs(pyg_dataset)\n",
        "dataset = GraphDataset(graphs, task='graph')\n",
        "print(\"Number of features before transformation: {}\".format(dataset.num_node_features))\n",
        "dataset.apply_transform(pagerank_transform_fn, update_tensor=False)\n",
        "print(\"Number of features after transformation: {}\".format(dataset.num_node_features))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LHByE87SQkUw"
      },
      "source": [
        "## Question 3.6: Implement the transformation below and report the clustering coefficient of the node (index 3) of the graph (index 406) in the COX2 dataset. Rounded the answer to two decimal places. (5 points)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "RNEjfOZRNjYb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea7e19a0-7c9d-4753-f278-f9a2969e3ea5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading https://www.chrsmrrs.com/graphkerneldatasets/COX2.zip\n",
            "Extracting cox2/COX2/COX2.zip\n",
            "Processing...\n",
            "Done!\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The node has clustering coefficient: 0.17\n"
          ]
        }
      ],
      "source": [
        "def cluster_transform_fn(graph):\n",
        "  # TODO: Implement this function that takes an deepsnap graph object,\n",
        "  # transform the graph by adding nodes clustering coefficient into the \n",
        "  # graph.node_feature\n",
        "\n",
        "  ############# Your code here ############\n",
        "  ## (~5 lines of code)\n",
        "  ## Note\n",
        "  ## 1. Compute the clustering coefficient value for each node and\n",
        "  ## concat them to the last dimension of graph.node_feature\n",
        "\n",
        "  coeffs = nx.clustering(graph.G)\n",
        "  coeffs = torch.Tensor(list(coeffs.values())).unsqueeze(1)\n",
        "  graph.node_feature = torch.hstack((graph.node_feature, coeffs))\n",
        "\n",
        "  #########################################\n",
        "\n",
        "root = './cox2'\n",
        "name = 'COX2'\n",
        "pyg_dataset = TUDataset(root, name)\n",
        "graphs = GraphDataset.pyg_to_graphs(pyg_dataset)\n",
        "dataset = GraphDataset(graphs, task='graph')\n",
        "\n",
        "# Transform the dataset\n",
        "dataset.apply_transform(cluster_transform_fn, update_tensor=False)\n",
        "\n",
        "node_idx = 3\n",
        "graph_idx = 406\n",
        "node_feature = dataset[graph_idx].node_feature\n",
        "\n",
        "print(\"The node has clustering coefficient: {}\".format(round(node_feature[node_idx][-1].item(), 2)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4P5Ig7XaPYzp"
      },
      "source": [
        "Apart from transforming the dataset, DeepSNAP can also transform the graph (usually the `deepsnap.batch.Batch`) during each training iteration.\n",
        "\n",
        "Also, DeepSNAP supports the synchronization of the transformation between the referenced graph objects and tensor representations. For example, you can just update the NetworkX graph object in the transform function, and by specifying `update_tensor=True` the internal tensor representations will be automatically updated.\n",
        "\n",
        "For more information, please refer to the DeepSNAP [documentation](https://snap.stanford.edu/deepsnap/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s-YLYMLFQYqp"
      },
      "source": [
        "# 4 Edge Level Prediction\n",
        "\n",
        "From last section, we know how DeepSNAP transductive split the edges in the link prediction task.\n",
        "\n",
        "Now lets use DeepSNAP and PyG together to implement a edge level prediction (link prediction) model!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "hrKCNtvERypQ"
      },
      "outputs": [],
      "source": [
        "import copy\n",
        "import torch\n",
        "import numpy as np\n",
        "import networkx as nx\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from deepsnap.graph import Graph\n",
        "from deepsnap.batch import Batch\n",
        "from deepsnap.dataset import GraphDataset\n",
        "from torch_geometric.datasets import Planetoid, TUDataset\n",
        "\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "import torch.nn.functional as F\n",
        "from torch_geometric.nn import SAGEConv\n",
        "\n",
        "class LinkPredModel(torch.nn.Module):\n",
        "    def __init__(self, input_dim, hidden_dim, num_classes, dropout=0.2):\n",
        "        super(LinkPredModel, self).__init__()\n",
        "\n",
        "        self.conv1 = SAGEConv(input_dim, hidden_dim)\n",
        "        self.conv2 = SAGEConv(hidden_dim, num_classes)\n",
        "\n",
        "        self.loss_fn = None\n",
        "\n",
        "        ############# Your code here #############\n",
        "        ## (~1 line of code)\n",
        "        ## Note\n",
        "        ## 1. Initialize the loss function to BCEWithLogitsLoss\n",
        "\n",
        "        self.loss_fn = nn.BCEWithLogitsLoss()\n",
        "\n",
        "        ##########################################\n",
        "\n",
        "        self.dropout = dropout\n",
        "\n",
        "    def reset_parameters(self):\n",
        "        self.conv1.reset_parameters()\n",
        "        self.conv2.reset_parameters()\n",
        "\n",
        "    def forward(self, batch):\n",
        "        node_feature, edge_index, edge_label_index = batch.node_feature, batch.edge_index, batch.edge_label_index\n",
        "        \n",
        "        ############# Your code here #############\n",
        "        ## (~6 line of code)\n",
        "        ## Note\n",
        "        ## 1. Feed the node feature into the first conv layer\n",
        "        ## 2. Add a ReLU after the first conv layer\n",
        "        ## 3. Add dropout after the ReLU (with probability self.dropout)\n",
        "        ## 4. Feed the output to the second conv layer\n",
        "        ## 5. Select the embeddings of the source nodes and destination nodes\n",
        "        ## by using the edge_label_index and compute the similarity of each pair\n",
        "        ## by dot product\n",
        "\n",
        "\n",
        "        out = self.conv1(node_feature, edge_index)\n",
        "        out = F.relu(out)\n",
        "        out = F.dropout(out, p=self.dropout, training=self.training)\n",
        "        out = self.conv2(out, edge_index)\n",
        "        src_emb, dest_emb = out[edge_label_index[0]], out[edge_label_index[1]]\n",
        "        # https://discuss.pytorch.org/t/dot-product-batch-wise/9746/11\n",
        "        pred = (src_emb * dest_emb).sum(1)\n",
        "        \n",
        "        ##########################################\n",
        "\n",
        "        return pred\n",
        "    \n",
        "    def loss(self, pred, link_label):\n",
        "        return self.loss_fn(pred, link_label)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "uuKbGFOu1Ka8"
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import *\n",
        "\n",
        "def train(model, dataloaders, optimizer, args):\n",
        "    val_max = 0\n",
        "    best_model = model\n",
        "\n",
        "    for epoch in range(1, args[\"epochs\"]):\n",
        "        for i, batch in enumerate(dataloaders['train']):\n",
        "            \n",
        "            batch.to(args[\"device\"])\n",
        "\n",
        "            ############# Your code here #############\n",
        "            ## (~6 lines of code)\n",
        "            ## Note\n",
        "            ## 1. Zero grad the optimizer\n",
        "            ## 2. Compute loss and backpropagate\n",
        "            ## 3. Update the model parameters\n",
        "\n",
        "            optimizer.zero_grad()\n",
        "            pred = model(batch)\n",
        "            loss = model.loss(pred, batch.edge_label.float())\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            ##########################################\n",
        "\n",
        "            log = 'Epoch: {:03d}, Train: {:.4f}, Val: {:.4f}, Test: {:.4f}, Loss: {}'\n",
        "            score_train = test(model, dataloaders['train'], args)\n",
        "            score_val = test(model, dataloaders['val'], args)\n",
        "            score_test = test(model, dataloaders['test'], args)\n",
        "\n",
        "            print(log.format(epoch, score_train, score_val, score_test, loss.item()))\n",
        "            if val_max < score_val:\n",
        "                val_max = score_val\n",
        "                best_model = copy.deepcopy(model)\n",
        "    return best_model\n",
        "\n",
        "def test(model, dataloader, args):\n",
        "    model.eval()\n",
        "\n",
        "    score = 0\n",
        "\n",
        "    ############# Your code here #############\n",
        "    ## (~5 lines of code)\n",
        "    ## Note\n",
        "    ## 1. Loop through batches in the dataloader\n",
        "    ## 2. Feed the batch to the model\n",
        "    ## 3. Feed the model output to sigmoid\n",
        "    ## 4. Compute the ROC-AUC score by using sklearn roc_auc_score function\n",
        "    ## 5. Edge labels are stored in batch.edge_label\n",
        "\n",
        "    for batch in dataloader:\n",
        "        batch.to(args['device'])\n",
        "        with torch.no_grad():\n",
        "            out = model(batch)\n",
        "            out = torch.sigmoid(out)\n",
        "        score = roc_auc_score(batch.edge_label.cpu(), out.cpu())\n",
        "    \n",
        "    ##########################################\n",
        " \n",
        "    return score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "JTKWYX1b33V3"
      },
      "outputs": [],
      "source": [
        "# Please don't change any parameters\n",
        "args = {\n",
        "    \"device\" : 'cuda' if torch.cuda.is_available() else 'cpu',\n",
        "    \"hidden_dim\" : 128,\n",
        "    \"epochs\" : 200,\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "Klw_xYnE27xQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c211817a-aaf8-4890-93f6-21a6a03716d2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 001, Train: 0.5113, Val: 0.4803, Test: 0.4766, Loss: 0.6932187080383301\n",
            "Epoch: 002, Train: 0.5060, Val: 0.4811, Test: 0.4772, Loss: 0.6931135058403015\n",
            "Epoch: 003, Train: 0.5020, Val: 0.4820, Test: 0.4781, Loss: 0.6930772066116333\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 004, Train: 0.5151, Val: 0.4832, Test: 0.4792, Loss: 0.6930973529815674\n",
            "Epoch: 005, Train: 0.5133, Val: 0.4847, Test: 0.4807, Loss: 0.6931300163269043\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 006, Train: 0.5151, Val: 0.4866, Test: 0.4821, Loss: 0.6930550336837769\n",
            "Epoch: 007, Train: 0.5156, Val: 0.4885, Test: 0.4838, Loss: 0.6930240392684937\n",
            "Epoch: 008, Train: 0.5207, Val: 0.4906, Test: 0.4855, Loss: 0.6930330395698547\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 009, Train: 0.5358, Val: 0.4930, Test: 0.4873, Loss: 0.6930401921272278\n",
            "Epoch: 010, Train: 0.5234, Val: 0.4952, Test: 0.4893, Loss: 0.6930070519447327\n",
            "Epoch: 011, Train: 0.5311, Val: 0.4976, Test: 0.4913, Loss: 0.6929885745048523\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 012, Train: 0.5411, Val: 0.4998, Test: 0.4935, Loss: 0.6930047869682312\n",
            "Epoch: 013, Train: 0.5284, Val: 0.5026, Test: 0.4956, Loss: 0.6929824352264404\n",
            "Epoch: 014, Train: 0.5377, Val: 0.5053, Test: 0.4979, Loss: 0.6929584741592407\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 015, Train: 0.5487, Val: 0.5080, Test: 0.5001, Loss: 0.6929216980934143\n",
            "Epoch: 016, Train: 0.5533, Val: 0.5106, Test: 0.5022, Loss: 0.6928879618644714\n",
            "Epoch: 017, Train: 0.5550, Val: 0.5132, Test: 0.5044, Loss: 0.6928907036781311\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 018, Train: 0.5500, Val: 0.5157, Test: 0.5065, Loss: 0.6928508877754211\n",
            "Epoch: 019, Train: 0.5670, Val: 0.5187, Test: 0.5088, Loss: 0.6928209066390991\n",
            "Epoch: 020, Train: 0.5574, Val: 0.5206, Test: 0.5111, Loss: 0.6927446722984314\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 021, Train: 0.5669, Val: 0.5232, Test: 0.5131, Loss: 0.6927763819694519\n",
            "Epoch: 022, Train: 0.5736, Val: 0.5259, Test: 0.5151, Loss: 0.6927242875099182\n",
            "Epoch: 023, Train: 0.5798, Val: 0.5281, Test: 0.5171, Loss: 0.6926243901252747\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 024, Train: 0.5784, Val: 0.5300, Test: 0.5190, Loss: 0.6927146315574646\n",
            "Epoch: 025, Train: 0.5727, Val: 0.5319, Test: 0.5207, Loss: 0.6926056146621704\n",
            "Epoch: 026, Train: 0.5843, Val: 0.5339, Test: 0.5224, Loss: 0.6926422119140625\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 027, Train: 0.5826, Val: 0.5360, Test: 0.5243, Loss: 0.6925709843635559\n",
            "Epoch: 028, Train: 0.5853, Val: 0.5382, Test: 0.5257, Loss: 0.6924177408218384\n",
            "Epoch: 029, Train: 0.5827, Val: 0.5399, Test: 0.5273, Loss: 0.6924520134925842\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 030, Train: 0.5964, Val: 0.5418, Test: 0.5289, Loss: 0.6923269629478455\n",
            "Epoch: 031, Train: 0.5873, Val: 0.5436, Test: 0.5303, Loss: 0.6923644542694092\n",
            "Epoch: 032, Train: 0.5958, Val: 0.5456, Test: 0.5318, Loss: 0.6921922564506531\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 033, Train: 0.5931, Val: 0.5474, Test: 0.5328, Loss: 0.6922019124031067\n",
            "Epoch: 034, Train: 0.5994, Val: 0.5489, Test: 0.5339, Loss: 0.6921339631080627\n",
            "Epoch: 035, Train: 0.6013, Val: 0.5502, Test: 0.5350, Loss: 0.6919066905975342\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 036, Train: 0.6052, Val: 0.5511, Test: 0.5360, Loss: 0.691988468170166\n",
            "Epoch: 037, Train: 0.5920, Val: 0.5522, Test: 0.5368, Loss: 0.6917814612388611\n",
            "Epoch: 038, Train: 0.6015, Val: 0.5534, Test: 0.5378, Loss: 0.6918238401412964\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 039, Train: 0.6093, Val: 0.5541, Test: 0.5387, Loss: 0.6917338967323303\n",
            "Epoch: 040, Train: 0.6038, Val: 0.5552, Test: 0.5395, Loss: 0.6915621757507324\n",
            "Epoch: 041, Train: 0.5987, Val: 0.5558, Test: 0.5399, Loss: 0.6912254691123962\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 042, Train: 0.6046, Val: 0.5564, Test: 0.5408, Loss: 0.6912379860877991\n",
            "Epoch: 043, Train: 0.6129, Val: 0.5573, Test: 0.5414, Loss: 0.6909139752388\n",
            "Epoch: 044, Train: 0.6176, Val: 0.5580, Test: 0.5420, Loss: 0.6908157467842102\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 045, Train: 0.6132, Val: 0.5587, Test: 0.5426, Loss: 0.6905868649482727\n",
            "Epoch: 046, Train: 0.6072, Val: 0.5594, Test: 0.5429, Loss: 0.6904861927032471\n",
            "Epoch: 047, Train: 0.6117, Val: 0.5600, Test: 0.5432, Loss: 0.6899755597114563\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 048, Train: 0.5986, Val: 0.5606, Test: 0.5436, Loss: 0.6898428797721863\n",
            "Epoch: 049, Train: 0.6005, Val: 0.5615, Test: 0.5437, Loss: 0.6897546648979187\n",
            "Epoch: 050, Train: 0.6166, Val: 0.5626, Test: 0.5440, Loss: 0.6897253394126892\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 051, Train: 0.6086, Val: 0.5630, Test: 0.5446, Loss: 0.689395010471344\n",
            "Epoch: 052, Train: 0.6072, Val: 0.5640, Test: 0.5449, Loss: 0.6887200474739075\n",
            "Epoch: 053, Train: 0.6145, Val: 0.5649, Test: 0.5453, Loss: 0.6889825463294983\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 054, Train: 0.6019, Val: 0.5657, Test: 0.5461, Loss: 0.688298761844635\n",
            "Epoch: 055, Train: 0.6055, Val: 0.5664, Test: 0.5469, Loss: 0.6880054473876953\n",
            "Epoch: 056, Train: 0.6049, Val: 0.5677, Test: 0.5476, Loss: 0.6873326301574707\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 057, Train: 0.6169, Val: 0.5687, Test: 0.5486, Loss: 0.6869208216667175\n",
            "Epoch: 058, Train: 0.6241, Val: 0.5699, Test: 0.5497, Loss: 0.6863763928413391\n",
            "Epoch: 059, Train: 0.6212, Val: 0.5714, Test: 0.5511, Loss: 0.6854187250137329\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 060, Train: 0.6132, Val: 0.5726, Test: 0.5523, Loss: 0.6847037672996521\n",
            "Epoch: 061, Train: 0.6241, Val: 0.5740, Test: 0.5537, Loss: 0.6840149760246277\n",
            "Epoch: 062, Train: 0.6171, Val: 0.5753, Test: 0.5551, Loss: 0.6832560896873474\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 063, Train: 0.6161, Val: 0.5778, Test: 0.5571, Loss: 0.6837121248245239\n",
            "Epoch: 064, Train: 0.6175, Val: 0.5801, Test: 0.5595, Loss: 0.6827382445335388\n",
            "Epoch: 065, Train: 0.6302, Val: 0.5828, Test: 0.5623, Loss: 0.6806238293647766\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 066, Train: 0.6287, Val: 0.5864, Test: 0.5657, Loss: 0.6823376417160034\n",
            "Epoch: 067, Train: 0.6314, Val: 0.5906, Test: 0.5703, Loss: 0.6797727346420288\n",
            "Epoch: 068, Train: 0.6286, Val: 0.5960, Test: 0.5753, Loss: 0.6780606508255005\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 069, Train: 0.6422, Val: 0.6010, Test: 0.5804, Loss: 0.6744851469993591\n",
            "Epoch: 070, Train: 0.6371, Val: 0.6066, Test: 0.5868, Loss: 0.6750657558441162\n",
            "Epoch: 071, Train: 0.6492, Val: 0.6123, Test: 0.5942, Loss: 0.6745082139968872\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 072, Train: 0.6596, Val: 0.6173, Test: 0.6025, Loss: 0.6729731559753418\n",
            "Epoch: 073, Train: 0.6764, Val: 0.6235, Test: 0.6118, Loss: 0.6690877676010132\n",
            "Epoch: 074, Train: 0.6867, Val: 0.6300, Test: 0.6216, Loss: 0.6682180762290955\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 075, Train: 0.6848, Val: 0.6374, Test: 0.6321, Loss: 0.6640618443489075\n",
            "Epoch: 076, Train: 0.6861, Val: 0.6463, Test: 0.6432, Loss: 0.6635240912437439\n",
            "Epoch: 077, Train: 0.6894, Val: 0.6564, Test: 0.6551, Loss: 0.6619279384613037\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 078, Train: 0.7015, Val: 0.6662, Test: 0.6657, Loss: 0.6578978896141052\n",
            "Epoch: 079, Train: 0.7040, Val: 0.6753, Test: 0.6748, Loss: 0.6525493860244751\n",
            "Epoch: 080, Train: 0.7095, Val: 0.6863, Test: 0.6844, Loss: 0.6570131182670593\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 081, Train: 0.7214, Val: 0.6950, Test: 0.6944, Loss: 0.6513517498970032\n",
            "Epoch: 082, Train: 0.7215, Val: 0.7024, Test: 0.7022, Loss: 0.6447213888168335\n",
            "Epoch: 083, Train: 0.7176, Val: 0.7064, Test: 0.7069, Loss: 0.6397587060928345\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 084, Train: 0.7121, Val: 0.7090, Test: 0.7104, Loss: 0.6416007876396179\n",
            "Epoch: 085, Train: 0.7140, Val: 0.7099, Test: 0.7132, Loss: 0.6371888518333435\n",
            "Epoch: 086, Train: 0.7149, Val: 0.7100, Test: 0.7149, Loss: 0.6349907517433167\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 087, Train: 0.7112, Val: 0.7104, Test: 0.7161, Loss: 0.6370675563812256\n",
            "Epoch: 088, Train: 0.7197, Val: 0.7109, Test: 0.7171, Loss: 0.633512020111084\n",
            "Epoch: 089, Train: 0.7133, Val: 0.7118, Test: 0.7187, Loss: 0.6274824142456055\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 090, Train: 0.7066, Val: 0.7111, Test: 0.7194, Loss: 0.6317376494407654\n",
            "Epoch: 091, Train: 0.7253, Val: 0.7116, Test: 0.7207, Loss: 0.6214967966079712\n",
            "Epoch: 092, Train: 0.7281, Val: 0.7122, Test: 0.7222, Loss: 0.6219106316566467\n",
            "Epoch: 093, Train: 0.7288, Val: 0.7137, Test: 0.7246, Loss: 0.6201237440109253\n",
            "Epoch: 094, Train: 0.7337, Val: 0.7157, Test: 0.7264, Loss: 0.6145839691162109\n",
            "Epoch: 095, Train: 0.7395, Val: 0.7166, Test: 0.7278, Loss: 0.6270993947982788\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 096, Train: 0.7348, Val: 0.7159, Test: 0.7285, Loss: 0.6201961636543274\n",
            "Epoch: 097, Train: 0.7398, Val: 0.7147, Test: 0.7288, Loss: 0.6194681525230408\n",
            "Epoch: 098, Train: 0.7525, Val: 0.7148, Test: 0.7297, Loss: 0.6062876582145691\n",
            "Epoch: 099, Train: 0.7570, Val: 0.7168, Test: 0.7317, Loss: 0.613043487071991\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 100, Train: 0.7480, Val: 0.7182, Test: 0.7333, Loss: 0.6048718690872192\n",
            "Epoch: 101, Train: 0.7518, Val: 0.7187, Test: 0.7343, Loss: 0.6018510460853577\n",
            "Epoch: 102, Train: 0.7655, Val: 0.7187, Test: 0.7348, Loss: 0.6017378568649292\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 103, Train: 0.7729, Val: 0.7183, Test: 0.7359, Loss: 0.6004553437232971\n",
            "Epoch: 104, Train: 0.7720, Val: 0.7185, Test: 0.7367, Loss: 0.5956078767776489\n",
            "Epoch: 105, Train: 0.7765, Val: 0.7203, Test: 0.7370, Loss: 0.5892879366874695\n",
            "Epoch: 106, Train: 0.7919, Val: 0.7208, Test: 0.7374, Loss: 0.5959789156913757\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 107, Train: 0.7786, Val: 0.7211, Test: 0.7380, Loss: 0.6019280552864075\n",
            "Epoch: 108, Train: 0.7831, Val: 0.7213, Test: 0.7389, Loss: 0.589964747428894\n",
            "Epoch: 109, Train: 0.7780, Val: 0.7212, Test: 0.7394, Loss: 0.5892671346664429\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 110, Train: 0.7840, Val: 0.7210, Test: 0.7398, Loss: 0.5950331091880798\n",
            "Epoch: 111, Train: 0.7848, Val: 0.7213, Test: 0.7404, Loss: 0.5858016014099121\n",
            "Epoch: 112, Train: 0.7911, Val: 0.7214, Test: 0.7410, Loss: 0.5853193998336792\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 113, Train: 0.7956, Val: 0.7220, Test: 0.7416, Loss: 0.5804494619369507\n",
            "Epoch: 114, Train: 0.8057, Val: 0.7229, Test: 0.7417, Loss: 0.5809146761894226\n",
            "Epoch: 115, Train: 0.7945, Val: 0.7230, Test: 0.7415, Loss: 0.5847777128219604\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 116, Train: 0.7947, Val: 0.7236, Test: 0.7420, Loss: 0.5857141613960266\n",
            "Epoch: 117, Train: 0.8025, Val: 0.7256, Test: 0.7436, Loss: 0.5875532627105713\n",
            "Epoch: 118, Train: 0.8131, Val: 0.7271, Test: 0.7452, Loss: 0.5770830512046814\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 119, Train: 0.7973, Val: 0.7277, Test: 0.7469, Loss: 0.5711870789527893\n",
            "Epoch: 120, Train: 0.8155, Val: 0.7298, Test: 0.7477, Loss: 0.5824239253997803\n",
            "Epoch: 121, Train: 0.8115, Val: 0.7313, Test: 0.7488, Loss: 0.5743969678878784\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 122, Train: 0.8086, Val: 0.7324, Test: 0.7500, Loss: 0.5741643905639648\n",
            "Epoch: 123, Train: 0.8217, Val: 0.7346, Test: 0.7519, Loss: 0.5719629526138306\n",
            "Epoch: 124, Train: 0.8264, Val: 0.7371, Test: 0.7540, Loss: 0.5678709149360657\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 125, Train: 0.8244, Val: 0.7391, Test: 0.7554, Loss: 0.5648061633110046\n",
            "Epoch: 126, Train: 0.8258, Val: 0.7414, Test: 0.7573, Loss: 0.5776833891868591\n",
            "Epoch: 127, Train: 0.8351, Val: 0.7432, Test: 0.7579, Loss: 0.5744064450263977\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 128, Train: 0.8345, Val: 0.7451, Test: 0.7596, Loss: 0.564267098903656\n",
            "Epoch: 129, Train: 0.8317, Val: 0.7482, Test: 0.7625, Loss: 0.5598211288452148\n",
            "Epoch: 130, Train: 0.8437, Val: 0.7515, Test: 0.7651, Loss: 0.5599493384361267\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 131, Train: 0.8407, Val: 0.7538, Test: 0.7672, Loss: 0.5575718283653259\n",
            "Epoch: 132, Train: 0.8465, Val: 0.7563, Test: 0.7691, Loss: 0.5453273057937622\n",
            "Epoch: 133, Train: 0.8553, Val: 0.7577, Test: 0.7700, Loss: 0.5594778656959534\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 134, Train: 0.8542, Val: 0.7589, Test: 0.7706, Loss: 0.5447884798049927\n",
            "Epoch: 135, Train: 0.8481, Val: 0.7629, Test: 0.7744, Loss: 0.5434507727622986\n",
            "Epoch: 136, Train: 0.8582, Val: 0.7664, Test: 0.7777, Loss: 0.5429756045341492\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 137, Train: 0.8574, Val: 0.7690, Test: 0.7803, Loss: 0.5369146466255188\n",
            "Epoch: 138, Train: 0.8649, Val: 0.7704, Test: 0.7814, Loss: 0.540014386177063\n",
            "Epoch: 139, Train: 0.8631, Val: 0.7696, Test: 0.7812, Loss: 0.5467014908790588\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 140, Train: 0.8636, Val: 0.7736, Test: 0.7847, Loss: 0.5308434963226318\n",
            "Epoch: 141, Train: 0.8643, Val: 0.7771, Test: 0.7890, Loss: 0.5348182916641235\n",
            "Epoch: 142, Train: 0.8740, Val: 0.7788, Test: 0.7911, Loss: 0.529609739780426\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 143, Train: 0.8774, Val: 0.7791, Test: 0.7914, Loss: 0.5273677706718445\n",
            "Epoch: 144, Train: 0.8722, Val: 0.7784, Test: 0.7914, Loss: 0.5122633576393127\n",
            "Epoch: 145, Train: 0.8798, Val: 0.7782, Test: 0.7917, Loss: 0.5252378582954407\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 146, Train: 0.8827, Val: 0.7803, Test: 0.7937, Loss: 0.5202476382255554\n",
            "Epoch: 147, Train: 0.8809, Val: 0.7825, Test: 0.7958, Loss: 0.5226002335548401\n",
            "Epoch: 148, Train: 0.8881, Val: 0.7827, Test: 0.7959, Loss: 0.5260870456695557\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 149, Train: 0.8759, Val: 0.7820, Test: 0.7958, Loss: 0.5193290710449219\n",
            "Epoch: 150, Train: 0.8874, Val: 0.7807, Test: 0.7949, Loss: 0.5183988809585571\n",
            "Epoch: 151, Train: 0.8883, Val: 0.7815, Test: 0.7962, Loss: 0.5262888073921204\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 152, Train: 0.8837, Val: 0.7827, Test: 0.7976, Loss: 0.5175148844718933\n",
            "Epoch: 153, Train: 0.8994, Val: 0.7835, Test: 0.7986, Loss: 0.5295250415802002\n",
            "Epoch: 154, Train: 0.8933, Val: 0.7820, Test: 0.7969, Loss: 0.5147508382797241\n",
            "Epoch: 155, Train: 0.8926, Val: 0.7802, Test: 0.7950, Loss: 0.5156428217887878\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 156, Train: 0.8941, Val: 0.7809, Test: 0.7958, Loss: 0.5205954313278198\n",
            "Epoch: 157, Train: 0.8890, Val: 0.7816, Test: 0.7970, Loss: 0.511526882648468\n",
            "Epoch: 158, Train: 0.8943, Val: 0.7832, Test: 0.7981, Loss: 0.5030187964439392\n",
            "Epoch: 159, Train: 0.9007, Val: 0.7836, Test: 0.7983, Loss: 0.5145950317382812\n",
            "Epoch: 160, Train: 0.9015, Val: 0.7824, Test: 0.7972, Loss: 0.5129411220550537\n",
            "Epoch: 161, Train: 0.8990, Val: 0.7819, Test: 0.7966, Loss: 0.5114555954933167\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 162, Train: 0.8995, Val: 0.7839, Test: 0.7976, Loss: 0.5008448958396912\n",
            "Epoch: 163, Train: 0.9057, Val: 0.7842, Test: 0.7977, Loss: 0.5043855905532837\n",
            "Epoch: 164, Train: 0.9037, Val: 0.7833, Test: 0.7969, Loss: 0.5072596073150635\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 165, Train: 0.9015, Val: 0.7807, Test: 0.7947, Loss: 0.4963041841983795\n",
            "Epoch: 166, Train: 0.9038, Val: 0.7792, Test: 0.7929, Loss: 0.5100876092910767\n",
            "Epoch: 167, Train: 0.9039, Val: 0.7822, Test: 0.7952, Loss: 0.5106340646743774\n",
            "Epoch: 168, Train: 0.9134, Val: 0.7862, Test: 0.7979, Loss: 0.5023096799850464\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 169, Train: 0.9073, Val: 0.7863, Test: 0.7980, Loss: 0.5031098127365112\n",
            "Epoch: 170, Train: 0.9109, Val: 0.7847, Test: 0.7961, Loss: 0.5139336585998535\n",
            "Epoch: 171, Train: 0.9168, Val: 0.7841, Test: 0.7954, Loss: 0.4970012605190277\n",
            "Epoch: 172, Train: 0.9113, Val: 0.7869, Test: 0.7977, Loss: 0.4944782257080078\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 173, Train: 0.9097, Val: 0.7883, Test: 0.7989, Loss: 0.5064901113510132\n",
            "Epoch: 174, Train: 0.9147, Val: 0.7869, Test: 0.7979, Loss: 0.49536603689193726\n",
            "Epoch: 175, Train: 0.9167, Val: 0.7852, Test: 0.7964, Loss: 0.5053444504737854\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 176, Train: 0.9113, Val: 0.7857, Test: 0.7967, Loss: 0.49575912952423096\n",
            "Epoch: 177, Train: 0.9198, Val: 0.7884, Test: 0.7991, Loss: 0.4916033446788788\n",
            "Epoch: 178, Train: 0.9146, Val: 0.7896, Test: 0.7991, Loss: 0.4996282160282135\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 179, Train: 0.9184, Val: 0.7893, Test: 0.7981, Loss: 0.49178072810173035\n",
            "Epoch: 180, Train: 0.9209, Val: 0.7876, Test: 0.7963, Loss: 0.5079232454299927\n",
            "Epoch: 181, Train: 0.9214, Val: 0.7891, Test: 0.7972, Loss: 0.49613627791404724\n",
            "Epoch: 182, Train: 0.9201, Val: 0.7867, Test: 0.7952, Loss: 0.5090065002441406\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 183, Train: 0.9223, Val: 0.7872, Test: 0.7954, Loss: 0.4986121654510498\n",
            "Epoch: 184, Train: 0.9207, Val: 0.7906, Test: 0.7983, Loss: 0.49723052978515625\n",
            "Epoch: 185, Train: 0.9256, Val: 0.7913, Test: 0.7996, Loss: 0.5000075101852417\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 186, Train: 0.9210, Val: 0.7903, Test: 0.7984, Loss: 0.4952183961868286\n",
            "Epoch: 187, Train: 0.9261, Val: 0.7886, Test: 0.7969, Loss: 0.4825252592563629\n",
            "Epoch: 188, Train: 0.9243, Val: 0.7874, Test: 0.7966, Loss: 0.5004292726516724\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 189, Train: 0.9286, Val: 0.7875, Test: 0.7968, Loss: 0.4979134202003479\n",
            "Epoch: 190, Train: 0.9367, Val: 0.7890, Test: 0.7982, Loss: 0.48598700761795044\n",
            "Epoch: 191, Train: 0.9206, Val: 0.7880, Test: 0.7975, Loss: 0.48928743600845337\n",
            "Epoch: 192, Train: 0.9297, Val: 0.7872, Test: 0.7970, Loss: 0.492584228515625\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 193, Train: 0.9297, Val: 0.7859, Test: 0.7961, Loss: 0.4855075180530548\n",
            "Epoch: 194, Train: 0.9282, Val: 0.7869, Test: 0.7978, Loss: 0.4982924163341522\n",
            "Epoch: 195, Train: 0.9341, Val: 0.7870, Test: 0.7978, Loss: 0.4948981702327728\n",
            "Epoch: 196, Train: 0.9301, Val: 0.7851, Test: 0.7965, Loss: 0.48205119371414185\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 197, Train: 0.9324, Val: 0.7858, Test: 0.7973, Loss: 0.4805736839771271\n",
            "Epoch: 198, Train: 0.9377, Val: 0.7838, Test: 0.7961, Loss: 0.47734254598617554\n",
            "Epoch: 199, Train: 0.9314, Val: 0.7784, Test: 0.7916, Loss: 0.48848608136177063\n",
            "Train: 0.9174, Val: 0.7913, Test: 0.7996\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n",
            "/usr/local/lib/python3.7/dist-packages/deepsnap/graph.py:2126: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n",
            "  row = perm // num_nodes\n"
          ]
        }
      ],
      "source": [
        "pyg_dataset = Planetoid('./tmp/cora', 'Cora')\n",
        "graphs = GraphDataset.pyg_to_graphs(pyg_dataset)\n",
        "\n",
        "dataset = GraphDataset(\n",
        "        graphs,\n",
        "        task='link_pred',\n",
        "        edge_train_mode=\"disjoint\"\n",
        "    )\n",
        "datasets = {}\n",
        "datasets['train'], datasets['val'], datasets['test']= dataset.split(\n",
        "            transductive=True, split_ratio=[0.85, 0.05, 0.1])\n",
        "input_dim = datasets['train'].num_node_features\n",
        "num_classes = datasets['train'].num_edge_labels\n",
        "\n",
        "model = LinkPredModel(input_dim, args[\"hidden_dim\"], num_classes).to(args[\"device\"])\n",
        "model.reset_parameters()\n",
        "\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)\n",
        "\n",
        "dataloaders = {split: DataLoader(\n",
        "            ds, collate_fn=Batch.collate([]),\n",
        "            batch_size=1, shuffle=(split=='train'))\n",
        "            for split, ds in datasets.items()}\n",
        "best_model = train(model, dataloaders, optimizer, args)\n",
        "log = \"Train: {:.4f}, Val: {:.4f}, Test: {:.4f}\"\n",
        "best_train_roc = test(best_model, dataloaders['train'], args)\n",
        "best_val_roc = test(best_model, dataloaders['val'], args)\n",
        "best_test_roc = test(best_model, dataloaders['test'], args)\n",
        "print(log.format(best_train_roc, best_val_roc, best_test_roc))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j5brlsKElP0_"
      },
      "source": [
        "## Question 4: What is the maximum ROC-AUC score you could get for the best_model on test set? (13 points)\n",
        "\n",
        "Submit your answers on Gradescope."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e7JXsMTBgeOI"
      },
      "source": [
        "# Submission\n",
        "\n",
        "In order to get credit, you must go submit your answers on Gradescope.\n",
        "\n",
        "Also, you need to submit the `ipynb` file of Colab 3, by clicking `File` and `Download .ipynb`. Please make sure that your output of each cell is available in your `ipynb` file."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "machine_shape": "hm",
      "name": "Copy of CS224W - Colab 3.ipynb",
      "provenance": [],
      "toc_visible": 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"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}