trackster-gnn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "35611454",
   "metadata": {},
   "outputs": [],
   "source": [
    "import awkward as ak\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "import torch_geometric.transforms as T\n",
    "from torch_geometric.nn import EdgeConv\n",
    "from torch_geometric.data import Data, Dataset\n",
    "from torch_geometric.loader import DataLoader\n",
    "#from torch_geometric.graphgym import params_count\n",
    "import torch_geometric.utils as Utils\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import mplhep as hep\n",
    "plt.style.use(hep.style.CMS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6f8d661a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GraphNet(nn.Module):\n",
    "    def __init__(self, input_dim = 12, hidden_dim = 64, output_dim = 1, aggr = 'add', niters = 4):\n",
    "        super(GraphNet, self).__init__()\n",
    "        \n",
    "        # transform to latent space\n",
    "        self.inputnetwork = nn.Sequential(\n",
    "            nn.Linear(input_dim, hidden_dim),\n",
    "            nn.BatchNorm1d(hidden_dim),\n",
    "            nn.ELU(),\n",
    "#             nn.Dropout(0.2),\n",
    "            nn.Linear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "#             nn.Dropout(0.2),\n",
    "#             nn.Linear(2*hidden_dim, hidden_dim),\n",
    "#             nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        # to compute messages\n",
    "        convnetwork = nn.Sequential(\n",
    "            nn.Linear(2 * hidden_dim, 2 * hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.2),\n",
    "            nn.Linear(2 * hidden_dim, hidden_dim),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        # EdgeConv\n",
    "        self.graphconv = EdgeConv(nn=convnetwork, aggr=aggr)\n",
    "        \n",
    "        # edge features from node embeddings for classification\n",
    "        self.edgenetwork = nn.Sequential(\n",
    "            nn.Linear(2 * hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.2),\n",
    "            nn.Linear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.2),\n",
    "            nn.Linear(hidden_dim, output_dim),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "        \n",
    "        self.niters = niters\n",
    "    \n",
    "    def forward(self, data):\n",
    "        X = data.x\n",
    "        #print(f\"edges {data.num_edges}\")\n",
    "        #print(f\"initial X size {X.size()}\")\n",
    "        H = self.inputnetwork(X)\n",
    "        #print(f\"size after inputnet {H.size()}\")\n",
    "        for i in range(self.niters):\n",
    "            (prepared_edges, _) = Utils.add_self_loops(data.edge_index)\n",
    "            H = self.graphconv(H, Utils.to_undirected(prepared_edges))\n",
    "            #print(f\"size of H after {i}th iter {H.size()}\")\n",
    "            \n",
    "        src, dst = data.edge_index\n",
    "        #print(f\"src size {H[src].size()} dest size {H[dst].size()}\")\n",
    "        #print(f\"torch cat {torch.cat([H[src], H[dst]], dim=-1).size()}\")\n",
    "        #print(f\"GraphNet returns {self.edgenetwork(torch.cat([H[src], H[dst]], dim=-1)).squeeze(-1).size()}\")\n",
    "        #print(f\"score size {(H[src] * H[dst]).sum(dim=-1)}\")\n",
    "        #return (H[src] * H[dst]).sum(dim=-1)\n",
    "        return self.edgenetwork(torch.cat([H[src], H[dst]], dim=-1)).squeeze(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4ee2ffea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Loading Files ...\n",
      "===== Loaded! \n"
     ]
    }
   ],
   "source": [
    "print(\"===== Loading Files ...\")\n",
    "trainData = \"./dataProcessed_improved/dataTraining.pt\"\n",
    "valData = \"./dataProcessed_improved/dataVal.pt\"\n",
    "testData = \"./dataProcessed_improved/dataTest.pt\"\n",
    "trainDataset = torch.load(trainData)\n",
    "valDataset = torch.load(valData)\n",
    "testDataset = torch.load(testData)\n",
    "print(\"===== Loaded! \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1130dea0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imbalance in training\n",
    "train_edges_total = 0\n",
    "train_edges_true = 0\n",
    "train_edges_false = 0\n",
    "\n",
    "for tr_data in trainDataset:\n",
    "    train_edges_total += len(tr_data.edge_index[0])\n",
    "    for label in tr_data.edge_label:\n",
    "        if label.numpy() == 0:\n",
    "            train_edges_false += 1\n",
    "        elif label.numpy() == 1:\n",
    "            train_edges_true += 1\n",
    "        \n",
    "print(f\"Total edges in training : {train_edges_total}\")\n",
    "print(f\"True edges : {train_edges_true}\")\n",
    "print(f\"False edges : {train_edges_false}\")\n",
    "\n",
    "# edges in test dataset\n",
    "test_edges_total = 0\n",
    "test_edges_true = 0\n",
    "test_edges_false = 0\n",
    "for test_data in testDataset:\n",
    "    test_edges_total += len(test_data.edge_index[0])\n",
    "    for label in test_data.edge_label:\n",
    "        if label.numpy() == 0:\n",
    "            test_edges_false += 1\n",
    "        elif label.numpy() == 1:\n",
    "            test_edges_true += 1\n",
    "            \n",
    "print(f\"\\nTotal edges in test : {test_edges_total}\")\n",
    "print(f\"True edges : {test_edges_true} - {test_edges_true/test_edges_total*100}%\")\n",
    "print(f\"False edges : {test_edges_false} - {test_edges_false/test_edges_total*100}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaedd574",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate weights\n",
    "w_false = train_edges_total/(2*train_edges_false)\n",
    "w_true = train_edges_total/(2*train_edges_true)\n",
    "print(f\"Weights True, False edges : {w_true}, {w_false}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7acb2dd9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100000"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(trainDataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ecd87322",
   "metadata": {},
   "outputs": [],
   "source": [
    "def focal_loss(bce_loss, targets, gamma, alpha):\n",
    "    \"\"\"Binary focal loss, mean.\n",
    "\n",
    "    Per https://discuss.pytorch.org/t/is-this-a-correct-implementation-for-focal-loss-in-pytorch/43327/5 with\n",
    "    improvements for alpha.\n",
    "    :param bce_loss: Binary Cross Entropy loss, a torch tensor.\n",
    "    :param targets: a torch tensor containing the ground truth, 0s and 1s.\n",
    "    :param gamma: focal loss power parameter, a float scalar.\n",
    "    :param alpha: weight of the class indicated by 1, a float scalar.\n",
    "    \"\"\"\n",
    "    p_t = torch.exp(-bce_loss)\n",
    "    alpha_tensor = (1 - alpha) + targets * (2 * alpha - 1)  # alpha if target = 1 and 1 - alpha if target = 0\n",
    "    f_loss = alpha_tensor * (1 - p_t) ** gamma * bce_loss\n",
    "    return f_loss.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6e7a7a8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr: 0.001\n",
      "epoch 0 - train loss 0.0268 - val loss 0.0203\n",
      "lr: 0.001\n",
      "epoch 1 - train loss 0.0200 - val loss 0.0185\n",
      "lr: 0.001\n",
      "epoch 2 - train loss 0.0187 - val loss 0.0176\n",
      "lr: 0.001\n",
      "epoch 3 - train loss 0.0182 - val loss 0.0174\n",
      "lr: 0.001\n",
      "epoch 4 - train loss 0.0180 - val loss 0.0178\n",
      "lr: 0.001\n",
      "epoch 5 - train loss 0.0177 - val loss 0.0167\n",
      "lr: 0.001\n",
      "epoch 6 - train loss 0.0174 - val loss 0.0170\n",
      "lr: 0.001\n",
      "epoch 7 - train loss 0.0171 - val loss 0.0159\n",
      "lr: 0.001\n",
      "epoch 8 - train loss 0.0170 - val loss 0.0160\n",
      "lr: 0.001\n",
      "epoch 9 - train loss 0.0171 - val loss 0.0157\n",
      "lr: 0.001\n",
      "epoch 10 - train loss 0.0170 - val loss 0.0160\n",
      "lr: 0.001\n",
      "epoch 11 - train loss 0.0171 - val loss 0.0162\n",
      "lr: 0.001\n",
      "epoch 12 - train loss 0.0169 - val loss 0.0156\n",
      "lr: 0.001\n",
      "epoch 13 - train loss 0.0169 - val loss 0.0157\n",
      "lr: 0.001\n",
      "epoch 14 - train loss 0.0168 - val loss 0.0160\n",
      "lr: 0.001\n",
      "epoch 15 - train loss 0.0169 - val loss 0.0157\n",
      "lr: 0.001\n",
      "epoch 16 - train loss 0.0168 - val loss 0.0161\n",
      "lr: 0.001\n",
      "epoch 17 - train loss 0.0168 - val loss 0.0157\n",
      "lr: 0.001\n",
      "epoch 18 - train loss 0.0167 - val loss 0.0158\n",
      "lr: 0.0001\n",
      "epoch 19 - train loss 0.0155 - val loss 0.0150\n",
      "lr: 0.0001\n",
      "epoch 20 - train loss 0.0154 - val loss 0.0150\n",
      "lr: 0.0001\n",
      "epoch 21 - train loss 0.0154 - val loss 0.0150\n",
      "lr: 0.0001\n",
      "epoch 22 - train loss 0.0153 - val loss 0.0148\n",
      "lr: 0.0001\n",
      "epoch 23 - train loss 0.0153 - val loss 0.0150\n",
      "lr: 0.0001\n",
      "epoch 24 - train loss 0.0152 - val loss 0.0149\n",
      "lr: 0.0001\n",
      "epoch 25 - train loss 0.0152 - val loss 0.0147\n",
      "lr: 0.0001\n",
      "epoch 26 - train loss 0.0152 - val loss 0.0147\n",
      "lr: 0.0001\n",
      "epoch 27 - train loss 0.0152 - val loss 0.0147\n",
      "lr: 0.0001\n",
      "epoch 28 - train loss 0.0152 - val loss 0.0148\n",
      "lr: 0.0001\n",
      "epoch 29 - train loss 0.0151 - val loss 0.0146\n",
      "lr: 0.0001\n",
      "epoch 30 - train loss 0.0151 - val loss 0.0146\n",
      "lr: 0.0001\n",
      "epoch 31 - train loss 0.0151 - val loss 0.0147\n",
      "lr: 0.0001\n",
      "epoch 32 - train loss 0.0151 - val loss 0.0145\n",
      "lr: 0.0001\n",
      "epoch 33 - train loss 0.0151 - val loss 0.0146\n",
      "lr: 0.0001\n",
      "epoch 34 - train loss 0.0150 - val loss 0.0145\n",
      "lr: 0.0001\n",
      "epoch 35 - train loss 0.0150 - val loss 0.0145\n",
      "lr: 0.0001\n",
      "epoch 36 - train loss 0.0150 - val loss 0.0145\n",
      "lr: 0.0001\n",
      "epoch 37 - train loss 0.0150 - val loss 0.0145\n",
      "lr: 0.0001\n",
      "epoch 38 - train loss 0.0150 - val loss 0.0145\n",
      "lr: 1e-05\n",
      "epoch 39 - train loss 0.0148 - val loss 0.0143\n",
      "lr: 1e-05\n",
      "epoch 40 - train loss 0.0147 - val loss 0.0143\n",
      "lr: 1e-05\n",
      "epoch 41 - train loss 0.0147 - val loss 0.0143\n",
      "lr: 1e-05\n",
      "epoch 42 - train loss 0.0147 - val loss 0.0143\n",
      "lr: 1e-05\n",
      "epoch 43 - train loss 0.0147 - val loss 0.0143\n",
      "lr: 1e-05\n",
      "epoch 44 - train loss 0.0147 - val loss 0.0142\n",
      "lr: 1e-05\n",
      "epoch 45 - train loss 0.0147 - val loss 0.0143\n",
      "lr: 1.0000000000000002e-06\n",
      "epoch 46 - train loss 0.0147 - val loss 0.0143\n",
      "lr: 1.0000000000000002e-06\n",
      "epoch 47 - train loss 0.0147 - val loss 0.0142\n",
      "lr: 1.0000000000000002e-06\n",
      "epoch 48 - train loss 0.0147 - val loss 0.0143\n",
      "lr: 1.0000000000000002e-06\n",
      "epoch 49 - train loss 0.0147 - val loss 0.0142\n"
     ]
    }
   ],
   "source": [
    "# Training\n",
    "\n",
    "epochs = 50\n",
    "batch_size = 32\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = GraphNet().to(device)\n",
    "#data = data_list.to(device)\n",
    "trainLoader = DataLoader(trainDataset, batch_size=batch_size)\n",
    "valLoader = DataLoader(valDataset, batch_size=batch_size)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=5e-4)\n",
    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=5, threshold=1e-4, threshold_mode='abs')\n",
    "\n",
    "train_loss_history = []\n",
    "val_loss_history = []\n",
    "model.train()\n",
    "for epoch in range(epochs):\n",
    "    batchloss = []\n",
    "    for sample in trainLoader:\n",
    "        optimizer.zero_grad()\n",
    "        sample.to(device)\n",
    "        out = model(sample)\n",
    "#         weight = [w_true if l > 0.9 else w_false for l in sample.edge_label] # weigh edges\n",
    "#         loss = F.binary_cross_entropy(out, sample.edge_label, weight=torch.tensor(weight))\n",
    "        bce_loss = F.binary_cross_entropy(out, sample.edge_label)\n",
    "        loss = focal_loss(bce_loss, sample.edge_label, 2, 0.25)\n",
    "#         print(f\"out {out}\")\n",
    "#         print(f\"label {sample.edge_label}\")\n",
    "#         print(f\"loss {loss}\")\n",
    "        batchloss.append(loss.item())\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    for param_group in optimizer.param_groups:\n",
    "        print(f\"lr: {param_group['lr']}\")\n",
    "    train_loss_history.append(np.mean(batchloss))\n",
    "\n",
    "    with torch.set_grad_enabled( False ):\n",
    "        batchloss = []\n",
    "        for sample in valLoader:\n",
    "            sample.to(device)\n",
    "            out = model(sample)\n",
    "            #val_loss = F.binary_cross_entropy_with_logits(out, sample.edge_label)\n",
    "            val_bce = F.binary_cross_entropy(out, sample.edge_label)\n",
    "            val_loss = focal_loss(val_bce, sample.edge_label, 2, 0.25)\n",
    "            batchloss.append(val_loss.item())\n",
    "            \n",
    "    val_loss_history.append(np.mean(batchloss))\n",
    "    scheduler.step(val_loss_history[-1])\n",
    "    print(f\"epoch {epoch} - train loss {train_loss_history[-1]:.4f} - val loss {val_loss_history[-1]:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53344cfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#from torch_geometric.graphgym import params_count\n",
    "#print(f\"{params_count(model)} parameters in model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1332ee81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f0ea2d7fcd0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xaxis = range(1, epochs+1)\n",
    "plt.plot(xaxis, train_loss_history, label='train')\n",
    "plt.plot(xaxis, val_loss_history, label='val')\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "#plt.xticks(range(epochs), range(1, epochs+1))\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "19843531",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save model so as not to repeat the training\n",
    "PATH = \"model/trackster_graphconv_improved_truth.pt\"\n",
    "torch.save(model.state_dict(), PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd0d85b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load model\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model_test = GraphNet()\n",
    "model_test.load_state_dict(torch.load(\"/eos/user/w/wredjeb/SWAN_projects/GraphSC/HackathonLinking/FirstModel/model.pt\")[\"model_state_dict\"])\n",
    "model_test.eval()\n",
    "model_test.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9bb5f18e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42369"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(p.numel() for p in model.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9cab8bb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_and_get_data(data_list, ev):\n",
    "    data_list_ev = data_list[ev]\n",
    "    x_np = data_list_ev[0]\n",
    "    x_coord_slice = x_np[:, [0,1,2]]\n",
    "    x_rest_slice = x_np[:, [9,10,11]]\n",
    "    \n",
    "    mean = []\n",
    "    std = []\n",
    "    scaler=StandardScaler()\n",
    "    scaler.fit(x_coord_slice)\n",
    "    x_coord_norm = scaler.transform(x_coord_slice)\n",
    "    mean.append(scaler.mean_)\n",
    "    std.append(scaler.scale_)\n",
    "    \n",
    "    mean.append(np.zeros(6)) # for the unnormalized features\n",
    "    std.append(np.ones(6))\n",
    "    \n",
    "    scaler.fit(x_rest_slice)\n",
    "    x_rest_norm = scaler.transform(x_rest_slice)\n",
    "    mean.append(scaler.mean_)\n",
    "    std.append(scaler.scale_)\n",
    "    \n",
    "    mean = np.concatenate(mean, axis=-1)\n",
    "    std = np.concatenate(std, axis=-1)\n",
    "    \n",
    "    x_ev = torch.from_numpy(np.concatenate((x_coord_norm, x_np[:,[3,4,5,6,7,8]], x_rest_norm), axis=1))\n",
    "    edge_label = torch.from_numpy(data_list_ev[1])\n",
    "    edge_index = torch.from_numpy(data_list_ev[2])\n",
    "    data = Data(x=x_ev, num_nodes=torch.tensor(x_ev.shape[0]), edge_index=edge_index, edge_label=edge_label)\n",
    "    return data, mean, std\n",
    "\n",
    "testData = []\n",
    "for ev in range(len(testDataset)):\n",
    "    data, mean, std = normalize_and_get_data(testDataset, ev)\n",
    "    testData.append(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "95170e98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loaded\n",
      "Accuracy in test data 81.3122 %\n",
      "Confusion matrix [[ 436886  357267]\n",
      " [ 319428 2475940]]\n"
     ]
    }
   ],
   "source": [
    "#testDataset = torch.load(\"/eos/user/w/wredjeb/SWAN_projects/GraphSC/HackathonLinking/dataProcessed/dataTest.pt\")\n",
    "classification_threshold = 0.6\n",
    "def getAccuracy(y_true, y_prob):\n",
    "    assert y_true.ndim == 1 and y_true.size() == y_prob.size()\n",
    "    y_prob = y_prob > classification_threshold\n",
    "    return (y_true == y_prob).sum().item() / y_true.size(0)\n",
    "\n",
    "testLoader = DataLoader(testData, batch_size=batch_size)\n",
    "print(\"loaded\")\n",
    "\n",
    "predictions = []\n",
    "truth = []\n",
    "accuracies = []\n",
    "\n",
    "for sample in testLoader:\n",
    "    sample.to(device)\n",
    "    out = model(sample)\n",
    "    acc = getAccuracy(sample.edge_label, out)\n",
    "    accuracies.append(acc)\n",
    "    y_test = out > classification_threshold\n",
    "    predictions.append(y_test.cpu().numpy())\n",
    "    truth.append(sample.edge_label.cpu().numpy())\n",
    "    \n",
    "cf_matrix = confusion_matrix(np.concatenate(truth), np.concatenate(predictions))\n",
    "#cf_matrix = confusion_matrix(sample.edge_label.detach().numpy(), y_test.detach().numpy())\n",
    "print(f\"Accuracy in test data {np.mean(accuracies)*100:.4f} %\")\n",
    "print(f\"Confusion matrix {cf_matrix}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f295f5d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.1217115  0.09953055]\n",
      " [0.08898903 0.68976891]]\n",
      "\n",
      "Accuracy : 81.1480%\n",
      "Precision : 87.3900\n",
      "Recall : 88.5730% -> positive edges correctly classified\n",
      "Correctly classifying 55.0128% of all negative edges\n"
     ]
    }
   ],
   "source": [
    "tn, fp, fn, tp = cf_matrix.ravel()\n",
    "tot = tn+fp+fn+tp\n",
    "# normalized to total edges in test dataset\n",
    "print(f\"{cf_matrix/tot}\\n\")\n",
    "print(f\"Accuracy : {(tp+tn)/tot*100:.4f}%\")\n",
    "print(f\"Precision : {tp/(tp+fp)*100:.4f}\")\n",
    "print(f\"Recall : {tp/(tp+fn)*100:.4f}% -> positive edges correctly classified\")\n",
    "print(f\"Correctly classifying {tn/(tn+fp)*100:.4f}% of all negative edges\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "31da276e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TN: 0.1217115041254808, FP: 0.09953055017647201, FN: 0.0889890322413492, TP: 0.689768913456698\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f0ea8511340>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 540x540 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(f\"TN: {tn/tot}, FP: {fp/tot}, FN: {fn/tot}, TP: {tp/tot}\")\n",
    "fig, px = plt.subplots(figsize=(7.5, 7.5))\n",
    "px.set_xlabel(\"predicted\")\n",
    "px.set_ylabel(\"true\")\n",
    "cax = px.matshow(cf_matrix/(tn+fp+fn+tp))\n",
    "fig.colorbar(cax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebd8ee7f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}