{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Lorentz-Equivariant GNN\n", "\n", "Now we will look at graph neural networks using the PyTorch Geometric library: . See {cite:p}`PyTorchGeometric` for more details." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# For Colab\n", "!pip install torch_geometric\n", "!pip install torch_sparse\n", "!pip install torch_scatter" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torch_geometric\n", "\n", "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", "from tqdm.notebook import tqdm\n", "import numpy as np\n", "\n", "local = False" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# For Colab\n", "\n", "!pip install wget\n", "import wget\n", "\n", "!pip install -U PyYAML\n", "!pip install uproot\n", "!pip install awkward\n", "!pip install mplhep" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import yaml\n", "import os.path\n", "\n", "# WGET for colab\n", "if not os.path.exists(\"definitions_lorentz.yml\"):\n", " url = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/definitions_lorentz.yml\"\n", " definitionsFile = wget.download(url)\n", "\n", "with open(\"definitions_lorentz.yml\") as file:\n", " # The FullLoader parameter handles the conversion from YAML\n", " # scalar values to Python the dictionary format\n", " definitions = yaml.load(file, Loader=yaml.FullLoader)\n", "\n", "features = definitions[\"features\"]\n", "spectators = definitions[\"spectators\"]\n", "labels = definitions[\"labels\"]\n", "\n", "nfeatures = definitions[\"nfeatures\"]\n", "nspectators = definitions[\"nspectators\"]\n", "nlabels = definitions[\"nlabels\"]\n", "ntracks = definitions[\"ntracks\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Graph datasets\n", "Here we have to define the graph dataset. We do this in a separate class following this example: https://pytorch-geometric.readthedocs.io/en/latest/notes/create_dataset.html#creating-larger-datasets\n", "\n", "Formally, a graph is represented by a triplet $\\mathcal G = (\\mathbf{u}, V, E)$, consisting of a graph-level, or *global*, feature vector $\\mathbf{u}$, a set of $N^v$ nodes $V$, and a set of $N^e$ edges $E$.\n", "The nodes are given by $V = \\{\\mathbf{v}_i\\}_{i=1:N^v}$, where $\\mathbf{v}_i$ represents the $i$th node's attributes.\n", "The edges connect pairs of nodes and are given by $E = \\{\\left(\\mathbf{e}_k, r_k, s_k\\right)\\}_{k=1:N^e}$, where $\\mathbf{e}_k$ represents the $k$th edge's attributes, and $r_k$ and $s_k$ are the indices of the \"receiver\" and \n", "\"sender\" nodes, respectively, connected by the $k$th edge (from the sender node to the receiver node).\n", "The receiver and sender index vectors are an alternative way of encoding the directed adjacency matrix.\n", "\n", "\"attributes\"" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Processing...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "51eb09799508446ab490fb88420cc6d3", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/8000 [00:00\n", "\n", "We will define an interaction network model similar to Ref. {cite:p}`Moreno:2019neq`, but just modeling the particle-particle interactions. It will take as input all of the tracks (with 48 features) without truncating or zero-padding. Another modification is the use of batch normalization {cite:p}`bn` layers to improve the stability of the training." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import torch.nn as nn\n", "import torch.nn.functional as F\n", "import torch_geometric.transforms as T\n", "from torch_geometric.nn import EdgeConv, global_mean_pool\n", "from torch.nn import Sequential as Seq, Linear as Lin, ReLU, BatchNorm1d\n", "from torch_scatter import scatter_mean\n", "from torch_geometric.nn import MetaLayer\n", "\n", "hidden = 16\n", "outputs = 2\n", "\n", "\n", "class LorentzEdgeBlock(torch.nn.Module):\n", " def __init__(self):\n", " super(LorentzEdgeBlock, self).__init__()\n", " self.edge_mlp = Seq(Lin(4, hidden), ReLU(), Lin(hidden, hidden))\n", " self.minkowski = torch.from_numpy(\n", " np.array(\n", " [\n", " [-1.0, 0.0, 0.0, 0.0],\n", " [0.0, 1.0, 0.0, 0.0],\n", " [0.0, 0.0, 1.0, 0.0],\n", " [0.0, 0.0, 0.0, 1.0],\n", " ],\n", " dtype=np.float32,\n", " )\n", " )\n", "\n", " def psi(self, x):\n", " return torch.sign(x) * torch.log(torch.abs(x) + 1)\n", "\n", " def innerprod(self, x1, x2):\n", " return torch.sum(\n", " torch.mul(torch.matmul(x1, self.minkowski), x2), 1, keepdim=True\n", " )\n", "\n", " def forward(self, src, dest, edge_attr, u, batch):\n", " out = torch.cat(\n", " [\n", " self.innerprod(src, src),\n", " self.innerprod(src, dest),\n", " self.psi(self.innerprod(dest, dest)),\n", " self.psi(self.innerprod(src - dest, src - dest)),\n", " ],\n", " dim=1,\n", " )\n", " return self.edge_mlp(out)\n", "\n", "\n", "class LorentzNodeBlock(torch.nn.Module):\n", " def __init__(self):\n", " super(LorentzNodeBlock, self).__init__()\n", " self.node_mlp_1 = Seq(Lin(1 + hidden, hidden), ReLU(), Lin(hidden, hidden))\n", " self.node_mlp_2 = Seq(Lin(1 + hidden, hidden), ReLU(), Lin(hidden, hidden))\n", " self.minkowski = torch.from_numpy(\n", " np.array(\n", " [\n", " [-1.0, 0.0, 0.0, 0.0],\n", " [0.0, 1.0, 0.0, 0.0],\n", " [0.0, 0.0, 1.0, 0.0],\n", " [0.0, 0.0, 0.0, 1.0],\n", " ],\n", " dtype=np.float32,\n", " )\n", " )\n", "\n", " def innerprod(self, x1, x2):\n", " return torch.sum(\n", " torch.mul(torch.matmul(x1, self.minkowski), x2), 1, keepdim=True\n", " )\n", "\n", " def forward(self, x, edge_index, edge_attr, u, batch):\n", " row, col = edge_index\n", " out = torch.cat([self.innerprod(x[row], x[row]), edge_attr], dim=1)\n", " out = self.node_mlp_1(out)\n", " out = scatter_mean(out, col, dim=0, dim_size=x.size(0))\n", " out = torch.cat([self.innerprod(x, x), out], dim=1)\n", " return self.node_mlp_2(out)\n", "\n", "\n", "class GlobalBlock(torch.nn.Module):\n", " def __init__(self):\n", " super(GlobalBlock, self).__init__()\n", " self.global_mlp = Seq(Lin(hidden, hidden), ReLU(), Lin(hidden, outputs))\n", "\n", " def forward(self, x, edge_index, edge_attr, u, batch):\n", " out = scatter_mean(x, batch, dim=0)\n", " return self.global_mlp(out)\n", "\n", "\n", "class LorentzInteractionNetwork(torch.nn.Module):\n", " def __init__(self):\n", " super(LorentzInteractionNetwork, self).__init__()\n", " self.lorentzinteractionnetwork = MetaLayer(\n", " LorentzEdgeBlock(), LorentzNodeBlock(), GlobalBlock()\n", " )\n", "\n", " def forward(self, x, edge_index, batch):\n", "\n", " x, edge_attr, u = self.lorentzinteractionnetwork(\n", " x, edge_index, None, None, batch\n", " )\n", " return u\n", "\n", "\n", "model = LorentzInteractionNetwork().to(device)\n", "optimizer = torch.optim.Adam(model.parameters(), lr=1e-6)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define training loop" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "@torch.no_grad()\n", "def test(model, loader, total, batch_size, leave=False):\n", " model.eval()\n", "\n", " xentropy = nn.CrossEntropyLoss(reduction=\"mean\")\n", "\n", " sum_loss = 0.0\n", " t = tqdm(enumerate(loader), total=total / batch_size, leave=leave)\n", " for i, data in t:\n", " data = data.to(device)\n", " y = torch.argmax(data.y, dim=1)\n", " batch_output = model(data.x, data.edge_index, data.batch)\n", " batch_loss_item = xentropy(batch_output, y).item()\n", " sum_loss += batch_loss_item\n", " t.set_description(\"loss = %.5f\" % (batch_loss_item))\n", " t.refresh() # to show immediately the update\n", "\n", " return sum_loss / (i + 1)\n", "\n", "\n", "def train(model, optimizer, loader, total, batch_size, leave=False):\n", " model.train()\n", "\n", " xentropy = nn.CrossEntropyLoss(reduction=\"mean\")\n", "\n", " sum_loss = 0.0\n", " t = tqdm(enumerate(loader), total=total / batch_size, leave=leave)\n", " for i, data in t:\n", " data = data.to(device)\n", " y = torch.argmax(data.y, dim=1)\n", " optimizer.zero_grad()\n", " batch_output = model(data.x, data.edge_index, data.batch)\n", " batch_loss = xentropy(batch_output, y)\n", " batch_loss.backward()\n", " batch_loss_item = batch_loss.item()\n", " t.set_description(\"loss = %.5f\" % batch_loss_item)\n", " t.refresh() # to show immediately the update\n", " sum_loss += batch_loss_item\n", " optimizer.step()\n", "\n", " return sum_loss / (i + 1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define training, validation, testing data generators" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7484\n", "5988\n", "1496\n", "1887\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/wmccorma/miniconda3/envs/ml-iaifi/lib/python3.9/site-packages/torch_geometric/deprecation.py:12: UserWarning: 'data.DataListLoader' is deprecated, use 'loader.DataListLoader' instead\n", " warnings.warn(out)\n" ] } ], "source": [ "from torch_geometric.data import Data, DataListLoader, Batch\n", "from torch.utils.data import random_split\n", "\n", "\n", "def collate(items):\n", " l = sum(items, [])\n", " return Batch.from_data_list(l)\n", "\n", "\n", "torch.manual_seed(0)\n", "valid_frac = 0.20\n", "full_length = len(graph_dataset)\n", "valid_num = int(valid_frac * full_length)\n", "batch_size = 32\n", "\n", "train_dataset, valid_dataset = random_split(\n", " graph_dataset, [full_length - valid_num, valid_num]\n", ")\n", "\n", "train_loader = DataListLoader(\n", " train_dataset, batch_size=batch_size, pin_memory=True, shuffle=True\n", ")\n", "train_loader.collate_fn = collate\n", "valid_loader = DataListLoader(\n", " valid_dataset, batch_size=batch_size, pin_memory=True, shuffle=False\n", ")\n", "valid_loader.collate_fn = collate\n", "test_loader = DataListLoader(\n", " test_dataset, batch_size=batch_size, pin_memory=True, shuffle=False\n", ")\n", "test_loader.collate_fn = collate\n", "\n", "\n", "train_samples = len(train_dataset)\n", "valid_samples = len(valid_dataset)\n", "test_samples = len(test_dataset)\n", "print(full_length)\n", "print(train_samples)\n", "print(valid_samples)\n", "print(test_samples)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Train" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4218389d3f8f473689e0b7f5acdf982e", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/2 [00:00= patience:\n", " print(\"Early stopping after %i stale epochs\" % patience)\n", " break" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Evaluate on testing data" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6d13d8453de64f0e866ef3be894b6b90", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/58.96875 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import roc_curve, auc\n", "import matplotlib.pyplot as plt\n", "import mplhep as hep\n", "\n", "plt.style.use(hep.style.ROOT)\n", "# create ROC curves\n", "fpr_lorentz, tpr_lorentz, threshold_lorentz = roc_curve(y_test[:, 1], -y_predict[:, 1])\n", "with open(\"lorentz_roc.npy\", \"wb\") as f:\n", " np.save(f, fpr_lorentz)\n", " np.save(f, tpr_lorentz)\n", " np.save(f, threshold_lorentz)\n", "\n", "\n", "For colab:\n", "if not os.path.exists(\"deepset_roc.py\"):\n", " urlROC = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/deepset_roc.npy\"\n", " rocFile = wget.download(urlROC) \n", " \n", "with open(\"deepset_roc.npy\", \"rb\") as f:\n", " fpr_deepset = np.load(f)\n", " tpr_deepset = np.load(f)\n", " threshold_deepset = np.load(f)\n", "\n", "# plot ROC curves\n", "plt.figure()\n", "plt.plot(\n", " tpr_deepset,\n", " fpr_deepset,\n", " lw=2.5,\n", " label=\"DeepSet, AUC = {:.1f}%\".format(auc(fpr_deepset, tpr_deepset) * 100),\n", ")\n", "plt.plot(\n", " tpr_lorentz,\n", " fpr_lorentz,\n", " lw=2.5,\n", " label=\"Lorentz GNN, AUC = {:.1f}%\".format(auc(fpr_lorentz, tpr_lorentz) * 100),\n", ")\n", "plt.xlabel(r\"True positive rate\")\n", "plt.ylabel(r\"False positive rate\")\n", "plt.ylim(0.001, 1)\n", "plt.xlim(0, 1)\n", "plt.grid(True)\n", "plt.legend(loc=\"upper left\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import roc_curve, auc\n", "import matplotlib.pyplot as plt\n", "import mplhep as hep\n", "\n", "plt.style.use(hep.style.ROOT)\n", "# create ROC curves\n", "pt_split = 5.0\n", "fpr_lorentz_lowb, tpr_lorentz_lowb, threshold_lorentz_lowb = roc_curve(\n", " y_test[track_pt <= pt_split, 1], -y_predict[track_pt <= pt_split, 1]\n", ")\n", "fpr_lorentz_highb, tpr_lorentz_highb, threshold_lorentz_highb = roc_curve(\n", " y_test[track_pt > pt_split, 1], -y_predict[track_pt > pt_split, 1]\n", ")\n", "\n", "# plot ROC curves\n", "plt.figure()\n", "plt.plot(\n", " tpr_lorentz_lowb,\n", " fpr_lorentz_lowb,\n", " lw=2.5,\n", " label=\"Lorentz GNN (low pT), AUC = {:.1f}%\".format(\n", " auc(fpr_lorentz_lowb, tpr_lorentz_lowb) * 100\n", " ),\n", ")\n", "plt.plot(\n", " tpr_lorentz_highb,\n", " fpr_lorentz_highb,\n", " lw=2.5,\n", " label=\"Lorentz GNN (high pT), AUC = {:.1f}%\".format(\n", " auc(fpr_lorentz_highb, tpr_lorentz_highb) * 100\n", " ),\n", ")\n", "plt.xlabel(r\"True positive rate\")\n", "plt.ylabel(r\"False positive rate\")\n", "plt.ylim(0.001, 1)\n", "plt.xlim(0, 1)\n", "plt.grid(True)\n", "plt.legend(loc=\"upper left\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.13" } }, "nbformat": 4, "nbformat_minor": 2 }