04-link-prediction-solution.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "04-link-prediction.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cmaAIUNJaG6T"
      },
      "source": [
        "# Link Prediction\n",
        "\n",
        "Build a GNN to predict links in a citation graph of academic papers.\n",
        "\n",
        "The citation graph we will use for training this GNN is the [CORA Dataset](https://relational.fit.cvut.cz/dataset/CORA) available from the `torch_geometric.datasets.Planetoid` package.\n",
        "\n",
        "## Setup\n",
        "\n",
        "The following two cells import Pytorch Geometric (PyG) and a couple of supporting Pytorch packages that are customized against the torch version."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "FlIGW0T2aBR2",
        "outputId": "511ac326-232b-4d33-a499-aae171e80b3a"
      },
      "source": [
        "import torch\n",
        "torch.__version__"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'1.9.0+cu111'"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jc2WG-ILaMfp"
      },
      "source": [
        "%%capture\n",
        "!pip install -q torch-scatter -f https://pytorch-geometric.com/whl/torch-1.9.0+cu111.html\n",
        "!pip install -q torch-sparse -f https://pytorch-geometric.com/whl/torch-1.9.0+cu111.html\n",
        "!pip install -q torch-geometric"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "825fkr6ukLSR"
      },
      "source": [
        "## Dataset\n",
        "\n",
        "The CORA dataset consists of a single graph consisting of 2,708 academic papers. Here is the output of printing `dataset[0]` from the [node classification example solution](02-node-classification.ipynb).\n",
        "\n",
        "```\n",
        "Data(x=[2708, 1433], edge_index=[2, 10556], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708])\n",
        "```\n",
        "\n",
        "The partitioning in different splits is achieved using the different masks. For edge prediction, however, we want to look at edges, so we will apply a transform to the Planetoid dataset to split the dataset randomly by edge.\n",
        "\n",
        "In addition, we will add negative examples, i.e. edges that don't occur in the graph.\n",
        "\n",
        "* Compose a transform consisting of `torch_geometric.transforms.NormalizeFeatures` and `torch_geometric.transforms.RandomLinkSplit`. \n",
        "* The `NormalizeFeatures` transform normalizes the node feature vector elements so they add up to 1. This is to normalize the vectors so their dot product is the same as cosine similarity, a value between 0 (negative pair label) and 1 (positive pair label).\n",
        "* The `RandomLinkSplit` splits the graph into subgraphs by edge. Split the graph such that 85% edges are in the training split, 5% edges are in the validation split and 10% edges in the test split.\n",
        "* Add negative training samples, i.e. edges that don't exist in the training subgraph and with an `edge_label` of 0. This is to allow the GNN to see negative examples during training. Add an equal number of negative samples as positive examples. You can do so by setting the `add_negative_train_samples` parameter of `RandomLinkSplit` to `True`.\n",
        "* Set this transform to the `Planetoid` call to download the CORA dataset using the `transform` parameter, this will automatically create 3 edge-oriented data splits, with additional attributes in their corresponding `Data` objects as shown below.\n",
        "\n",
        "```\n",
        "(\n",
        "    Data(x=[2708, 1433], edge_index=[2, 8976], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708], edge_label=[8976], edge_label_index=[2, 8976]),\n",
        "    Data(x=[2708, 1433], edge_index=[2, 8976], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708], edge_label=[526], edge_label_index=[2, 526]),\n",
        "    Data(x=[2708, 1433], edge_index=[2, 9502], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708], edge_label=[1054], edge_label_index=[2, 1054])\n",
        ")\n",
        "```\n",
        "\n",
        "Compute and verify the following on the downloaded dataset.\n",
        "\n",
        "* Number of (node) features (should be 1,433)\n",
        "* Number of target classes (should be 7)\n",
        "* The contents of the first element of the dataset should consist of 3 `Data` elements as shown above."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pIqmsol9CttN"
      },
      "source": [
        "import torch_geometric.transforms as T\n",
        "from torch_geometric.datasets import Planetoid"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AuF6s5CWoLG0",
        "outputId": "df4f04c5-6f19-41a0-bc43-4a2f2a6ea0c5"
      },
      "source": [
        "transform = T.Compose([\n",
        "    T.NormalizeFeatures(),\n",
        "    T.RandomLinkSplit(num_val=0.05, \n",
        "                      num_test=0.1, \n",
        "                      is_undirected=True,\n",
        "                      add_negative_train_samples=True),\n",
        "])\n",
        "dataset = Planetoid(root=\"cora\", name='CORA', transform=transform)\n",
        "dataset"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "CORA()"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ptA0vdWZo2GH",
        "outputId": "eec3ea8c-5b6a-4e7e-9e27-3ce54f08237c"
      },
      "source": [
        "dataset.num_features"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1433"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ntyApckWo8X6",
        "outputId": "e87ef698-6813-4020-b1d9-fa9841997be7"
      },
      "source": [
        "dataset.num_classes"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C3CNPNFEo-2R",
        "outputId": "64049f1c-b87a-4a11-8046-6e3a7f7a541c"
      },
      "source": [
        "dataset[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(Data(x=[2708, 1433], edge_index=[2, 8976], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708], edge_label=[8976], edge_label_index=[2, 8976]),\n",
              " Data(x=[2708, 1433], edge_index=[2, 8976], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708], edge_label=[526], edge_label_index=[2, 526]),\n",
              " Data(x=[2708, 1433], edge_index=[2, 9502], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708], edge_label=[1054], edge_label_index=[2, 1054]))"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GDjII6PNlB-D"
      },
      "source": [
        "## DataLoader\n",
        "\n",
        "The `Data` splits do not lend themselves to batch level training. For this exercise, we will work with each subgraph in its entirety.\n",
        "\n",
        "Note that you could create `DataLoaders` from the splits by doing this:\n",
        "\n",
        "`train_loader = DataLoader([train_dataset], shuffle=True, ...)`\n",
        "\n",
        "but it will result in a single batch.\n",
        "\n",
        "Separate the splits into a `train_dataset`, `val_dataset` and `test_dataset`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iRESsFgVlIpp"
      },
      "source": [
        "from torch_geometric.loader import DataLoader"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gzGWdbvalFyA"
      },
      "source": [
        "train_dataset, val_dataset, test_dataset = dataset[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lakd48salQkW"
      },
      "source": [
        "## Model\n",
        "\n",
        "Conceptually, we generate encodings for each node participating in an edge (positive or negative) and compute the similarity between all pairs of nodes. The network learns to push positive node pairs closer together and negative node pairs further apart using gradient descent.\n",
        "\n",
        "From an implementation point of view, the node embeddings are learned on the entire subgraph in one shot, then the source and destination node vectors are separated out and the similarities between them computed.\n",
        "\n",
        "Implement a network with the following layers.\n",
        "\n",
        "1. _k_ layers of `GCNConv`, the first one with input dimension `input_dim` and output dimension `hidden_dim`, and the other _k-1_ layers with input and output dimention `hidden_dim`.\n",
        "2. All `GCNConv` layers are followed by a `BatchNorm1d` layer.\n",
        "3. Except for the last `GCNConv` + `BatchNorm1d` pair, all are followed by a `Droput` layer and a `ReLU` activation layer.\n",
        "4. The output of the last `GCNConv` + `BatchNorm1d` is separated into source and destination nodes by calling `torch.index_select` on the output and the first and second rows of the `edge_label_index`.\n",
        "5. The similarity between all source and destination nodes is computed by computing the dot product of the source and destination nodes.\n",
        "6. Because our vectors are pre-normalized, the dot product is the same as cosine similarity, and the range of values corresponds to the labels 0 and 1 for negative and positive pair respectively.\n",
        "\n",
        "Verify that your network design is sound by sending the training dataset through a newly instantiated instance."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M9i0oKY0S17A"
      },
      "source": [
        "![fig-04-01.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i7E5Zki6lNFW"
      },
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch_geometric.nn as pyg_nn"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VnrFrdLBlcij"
      },
      "source": [
        "class LinkPredictor(nn.Module):\n",
        "  def __init__(self, input_dim, hidden_dim, output_dim, \n",
        "               num_graph_layers, dropout_pct):\n",
        "    super(LinkPredictor, self).__init__()\n",
        "\n",
        "    self.convs = nn.ModuleList()\n",
        "    self.convs.append(pyg_nn.GCNConv(input_dim, hidden_dim))\n",
        "    for i in range(num_graph_layers - 1):\n",
        "      self.convs.append(pyg_nn.GCNConv(hidden_dim, hidden_dim))\n",
        "\n",
        "    self.bns = nn.ModuleList()\n",
        "    for i in range(num_graph_layers):\n",
        "      self.bns.append(nn.BatchNorm1d(hidden_dim))\n",
        "\n",
        "    self.num_graph_layers = num_graph_layers\n",
        "    self.dropout_pct = dropout_pct\n",
        "\n",
        "  def forward(self, data):\n",
        "    x, edge_index, edge_label_index = data.x, data.edge_index, data.edge_label_index\n",
        "\n",
        "    for i in range(self.num_graph_layers - 1):\n",
        "      x = self.convs[i](x, edge_index)\n",
        "      x = self.bns[0](x)\n",
        "      x = F.dropout(x, p=self.dropout_pct)\n",
        "      x = F.relu(x)\n",
        "    x = self.convs[-1](x, edge_index)\n",
        "    x = self.bns[-1](x)\n",
        "    \n",
        "    src_nodes = torch.index_select(x, 0, edge_label_index[0, :].long())\n",
        "    dst_nodes = torch.index_select(x, 0, edge_label_index[1, :].long())\n",
        "    x = torch.sum(src_nodes * dst_nodes, dim=-1)\n",
        "    return x\n",
        "\n",
        "  def loss(self, pred, label):\n",
        "    return F.binary_cross_entropy_with_logits(pred, label)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ANWjODYWSikC",
        "outputId": "060d1460-b42a-44a7-fa41-dfb7cb9b5d83"
      },
      "source": [
        "model = LinkPredictor(dataset.num_features, 100, dataset.num_classes, 3, 0.5)\n",
        "pred = model(train_dataset)\n",
        "print(pred.size())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([8976])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lh3E0C3fQkXZ"
      },
      "source": [
        "## Training Loop\n",
        "\n",
        "As in the previous exercises, organize your code into a `train_step`, `eval_step` and `train_loop`.\n",
        "\n",
        "The target here is also binary, i.e. there may exist an edge between a pair of nodes or not, so once again we will use the ROC-AUC metric rather than accuracy to evaluate our model.\n",
        "\n",
        "In this case, since the graphs cannot be batched (using a DataLoader will iterate over a single batch), we can compute the ROC-AUC directly in the `train_step` and `eval_step` functions rather than postponing the computation in the `train_loop` function. As before, you should use the [Scikit-Learn ROC-AUC metric](https://scikit-learn.org/stable/modules/model_evaluation.html#roc-metrics) to compute the AUC metric.\n",
        "\n",
        "### train_step\n",
        "\n",
        "  1. In the `train_step` generate the predictions by running the `train_dataset` through the model, computing the loss, backpropagating the gradient of the loss and updating the model weights.\n",
        "  2. Compute the AUC score for the entire dataset using the Scikit-Learn function [roc_auc_score](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html#sklearn.metrics.roc_auc_score)\n",
        "  3. Report the loss and AUC score over the entire dataset.\n",
        "\n",
        "### eval_step\n",
        "\n",
        "  1. Generate the predictions against the validation or test dataset using the current state of the model. As before, compute the loss and AUC score, but do not backpropagate.\n",
        "\n",
        "### train_loop\n",
        "\n",
        "  1. Run the `train_step` and `eval_step` over the required number of epochs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fIMq6BAUk3gG"
      },
      "source": [
        "from sklearn.metrics import roc_auc_score"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KWmEJ7w2a49A"
      },
      "source": [
        "def train_step(model, optimizer, train_dataset, device):\n",
        "  model.train()\n",
        "  train_dataset.to(device)\n",
        "  optimizer.zero_grad()\n",
        "  pred = model(train_dataset)\n",
        "  label = train_dataset.edge_label\n",
        "  loss = model.loss(pred, label)\n",
        "  loss.backward()\n",
        "  optimizer.step()\n",
        "  auc = roc_auc_score(label.detach().cpu().numpy(), pred.detach().cpu().numpy())\n",
        "  num_edges = len(train_dataset.edge_label)\n",
        "  return loss, auc\n",
        "\n",
        "def eval_step(model, eval_dataset, device, is_validation=False):\n",
        "  model.eval()\n",
        "  eval_dataset.to(device)\n",
        "  with torch.no_grad():\n",
        "    pred = model(eval_dataset)\n",
        "    label = eval_dataset.edge_label\n",
        "    # print(\"pred:\", pred)\n",
        "    # print(\"label:\", label)\n",
        "    loss = model.loss(pred, label)\n",
        "    auc = roc_auc_score(label.cpu().numpy(), pred.cpu().numpy())\n",
        "    num_edges = len(eval_dataset.edge_label)\n",
        "  return loss, auc\n",
        "\n",
        "def train_loop(model, optimizer, train_dataset, val_dataset, device, \n",
        "               num_epochs, log_every=10):\n",
        "  history = []\n",
        "  for epoch in range(num_epochs):\n",
        "    train_loss, train_auc = train_step(model, optimizer, train_dataset, device)\n",
        "    val_loss, val_auc = eval_step(model, val_dataset, device, is_validation=True)\n",
        "    history.append((train_loss, train_auc, val_loss, val_auc))\n",
        "    if epoch == 0 or (epoch + 1) % log_every == 0:\n",
        "      print(\"EPOCH {:3d}, TRAIN loss: {:.5f}, AUC: {:.5f}, VAL loss: {:.5f}, AUC: {:.5f}\"\n",
        "        .format(epoch + 1, train_loss, train_auc, val_loss, val_auc))\n",
        "  return history"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B9aVKdQ3hHs0"
      },
      "source": [
        "## Train\n",
        "\n",
        "Train the model using the hyperparameters listed below. Use the Adam optimizer. Plot the training plots."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BzoE0bVGg_zJ"
      },
      "source": [
        "# model parameters\n",
        "INPUT_DIM = dataset.num_features\n",
        "HIDDEN_DIM = 128\n",
        "OUTPUT_DIM = dataset.num_classes\n",
        "NUM_GCN_LAYERS = 3\n",
        "DROPOUT_PCT = 0.5\n",
        "\n",
        "# optimizer\n",
        "LEARNING_RATE = 1e-2\n",
        "\n",
        "NUM_EPOCHS = 100"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sF1o6zahh_0P",
        "outputId": "42de943b-71ab-4192-ec76-cfab6f4fb660"
      },
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "device"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cpu')"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hZ4bJwg5hTHB"
      },
      "source": [
        "model = LinkPredictor(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, NUM_GCN_LAYERS, DROPOUT_PCT)\n",
        "optimizer = torch.optim.Adam(params=model.parameters(), lr=LEARNING_RATE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DL7oUD2chl3W",
        "outputId": "3a3be0d7-6149-4a3c-9901-034fadb4bfe7"
      },
      "source": [
        "history = train_loop(model, optimizer, train_dataset, val_dataset, device, NUM_EPOCHS)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EPOCH   1, TRAIN loss: 2.41641, AUC: 0.89285, VAL loss: 0.68715, AUC: 0.70284\n",
            "EPOCH  10, TRAIN loss: 0.66455, AUC: 0.95720, VAL loss: 0.85190, AUC: 0.64630\n",
            "EPOCH  20, TRAIN loss: 0.47634, AUC: 0.96188, VAL loss: 0.72152, AUC: 0.59145\n",
            "EPOCH  30, TRAIN loss: 0.38599, AUC: 0.97331, VAL loss: 0.72557, AUC: 0.62657\n",
            "EPOCH  40, TRAIN loss: 0.32438, AUC: 0.98664, VAL loss: 0.78033, AUC: 0.59904\n",
            "EPOCH  50, TRAIN loss: 0.29731, AUC: 0.98983, VAL loss: 0.84662, AUC: 0.62509\n",
            "EPOCH  60, TRAIN loss: 0.25566, AUC: 0.99363, VAL loss: 0.89606, AUC: 0.68529\n",
            "EPOCH  70, TRAIN loss: 0.23124, AUC: 0.99470, VAL loss: 0.95359, AUC: 0.68849\n",
            "EPOCH  80, TRAIN loss: 0.21638, AUC: 0.99606, VAL loss: 1.01580, AUC: 0.68363\n",
            "EPOCH  90, TRAIN loss: 0.19045, AUC: 0.99691, VAL loss: 1.02235, AUC: 0.67837\n",
            "EPOCH 100, TRAIN loss: 0.18223, AUC: 0.99734, VAL loss: 1.11732, AUC: 0.68603\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lV-Z_Clrn4Wy"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "id": "OxHxyL3mn29x",
        "outputId": "f1fc61bc-6e4b-4ab8-9e07-9e4c6fd9b3be"
      },
      "source": [
        "def display_training_plots(history):\n",
        "  train_losses, train_accs, val_losses, val_accs = [], [], [], []\n",
        "  for train_loss, train_acc, val_loss, val_acc in history:\n",
        "    train_losses.append(train_loss)\n",
        "    train_accs.append(train_acc)\n",
        "    val_losses.append(val_loss)\n",
        "    val_accs.append(val_acc)\n",
        "\n",
        "  xs = np.arange(len(train_losses))\n",
        "\n",
        "  plt.figure(figsize=(10, 5))\n",
        "\n",
        "  plt.subplot(2, 1, 1)\n",
        "  plt.plot(xs, train_losses, label=\"train\")\n",
        "  plt.plot(xs, val_losses, label=\"validation\")\n",
        "  plt.xlabel(\"iterations\")\n",
        "  plt.ylabel(\"loss\")\n",
        "  plt.legend(loc=\"best\")\n",
        "\n",
        "  plt.subplot(2, 1, 2)\n",
        "  plt.plot(xs, train_accs, label=\"train\")\n",
        "  plt.plot(xs, val_accs, label=\"validation\")\n",
        "  plt.xlabel(\"iterations\")\n",
        "  plt.ylabel(\"accuracy\")\n",
        "  plt.legend(loc=\"best\")\n",
        "\n",
        "  _ = plt.show()\n",
        "\n",
        "\n",
        "display_training_plots(history)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-hp9BenlRr5G"
      },
      "source": [
        "## Evaluation\n",
        "\n",
        "Evaluate the model against the `test_dataset` and report the AUC score."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WBsEFkZaiv6j",
        "outputId": "c65256a8-9c7f-4799-a759-963dc37645d4"
      },
      "source": [
        "_, test_auc = eval_step(model, test_dataset, device, is_validation=False)\n",
        "print(\"Test AUC {:.5f}\".format(test_auc))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test AUC 0.70196\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oP4oUoZHnhv-"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}