{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deep Sets\n",
    "===============================================================\n",
    "\n",
    "We will start by looking at Deep Sets networks using PyTorch. The architecture is based on the following paper: [DeepSets](https://papers.nips.cc/paper/2017/file/f22e4747da1aa27e363d86d40ff442fe-Paper.pdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\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"
   ]
  },
  {
   "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\n",
    "!pip install torch_scatter"
   ]
  },
  {
   "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": [
    "## Dataset loader\n",
    "Here we have to define the dataset loader. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "682c0adf1652494bba5d58f420efd3b6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/10000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/wmccorma/IAIFI_Summer_School_2022/iaifi-summer-school-PATRICK/book/DeepSetsDataset.py:116: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at  /Users/distiller/project/conda/conda-bld/pytorch_1646756029501/work/torch/csrc/utils/tensor_new.cpp:210.)\n",
      "  x = torch.tensor(\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "93a8257180df4482acc5eb1e7e38f03e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# If in colab\n",
    "if not os.path.exists(\"GraphDataset.py\"):\n",
    "    urlDSD = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/DeepSetsDataset.py\"\n",
    "    DSD = wget.download(urlDSD)\n",
    "if not os.path.exists(\"utils.py\"):\n",
    "    urlUtils = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/utils.py\"\n",
    "    utils = wget.download(urlUtils)\n",
    "\n",
    "from DeepSetsDataset import DeepSetsDataset\n",
    "\n",
    "# For colab\n",
    "import os.path\n",
    "\n",
    "if not os.path.exists(\"ntuple_merged_90.root\"):\n",
    "    urlFILE = \"http://opendata.cern.ch/eos/opendata/cms/datascience/HiggsToBBNtupleProducerTool/HiggsToBBNTuple_HiggsToBB_QCD_RunII_13TeV_MC/train/ntuple_merged_90.root\"\n",
    "    dataFILE = wget.download(urlFILE)\n",
    "train_files = [\"ntuple_merged_90.root\"]\n",
    "\n",
    "##Locally with XRootD\n",
    "# train_files = ['root://eospublic.cern.ch//eos/opendata/cms/datascience/HiggsToBBNtupleProducerTool/HiggsToBBNTuple_HiggsToBB_QCD_RunII_13TeV_MC/train/ntuple_merged_90.root']\n",
    "# test_files = ['root://eospublic.cern.ch//eos/opendata/cms/datascience/HiggsToBBNtupleProducerTool/HiggsToBBNTuple_HiggsToBB_QCD_RunII_13TeV_MC/test/ntuple_merged_1.root']\n",
    "\n",
    "train_generator = DeepSetsDataset(\n",
    "    features,\n",
    "    labels,\n",
    "    spectators,\n",
    "    start_event=0,\n",
    "    stop_event=10000,\n",
    "    npad=ntracks,\n",
    "    file_names=train_files,\n",
    ")\n",
    "train_generator.process()\n",
    "\n",
    "test_generator = DeepSetsDataset(\n",
    "    features,\n",
    "    labels,\n",
    "    spectators,\n",
    "    start_event=10001,\n",
    "    stop_event=14001,\n",
    "    npad=ntracks,\n",
    "    file_names=train_files,\n",
    ")\n",
    "test_generator.process()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deep Sets Network\n",
    "\n",
    "Deep Sets models are designed to be explicitly permutation invariant. At their core they are composed of two networks, $\\phi$ and $\\rho$, such that the total network $f$ is given by\n",
    "\n",
    "$\n",
    "\\begin{align}\n",
    "    f &= \\rho\\left(\\Sigma_{\\mathbf{x}_i\\in\\mathcal{X}}\\phi(\\mathbf{x}_i)\\right)\n",
    "  \\label{eq:deepsets-functions}\n",
    "\\end{align}\n",
    "$\n",
    "\n",
    "where $\\mathbf{x}_i$ are the features for the i-th element in the input sequence $\\mathcal{X}$.\n",
    "\n",
    "We will define a DeepSets model that will take as input up to 60 of the tracks (with 48 features) with zero-padding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DeepSets(\n",
      "  (phi): Sequential(\n",
      "    (0): Conv1d(6, 64, kernel_size=(1,), stride=(1,))\n",
      "    (1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (2): ReLU()\n",
      "    (3): Conv1d(64, 32, kernel_size=(1,), stride=(1,))\n",
      "    (4): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (5): ReLU()\n",
      "    (6): Conv1d(32, 16, kernel_size=(1,), stride=(1,))\n",
      "    (7): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (8): ReLU()\n",
      "  )\n",
      "  (rho): Sequential(\n",
      "    (0): Linear(in_features=16, out_features=50, bias=True)\n",
      "    (1): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (2): ReLU()\n",
      "    (3): Linear(in_features=50, out_features=2, bias=True)\n",
      "    (4): Sigmoid()\n",
      "  )\n",
      ")\n",
      "----------\n",
      "{'phi.0.weight': torch.Size([64, 6, 1]), 'phi.0.bias': torch.Size([64]), 'phi.1.weight': torch.Size([64]), 'phi.1.bias': torch.Size([64]), 'phi.1.running_mean': torch.Size([64]), 'phi.1.running_var': torch.Size([64]), 'phi.1.num_batches_tracked': torch.Size([]), 'phi.3.weight': torch.Size([32, 64, 1]), 'phi.3.bias': torch.Size([32]), 'phi.4.weight': torch.Size([32]), 'phi.4.bias': torch.Size([32]), 'phi.4.running_mean': torch.Size([32]), 'phi.4.running_var': torch.Size([32]), 'phi.4.num_batches_tracked': torch.Size([]), 'phi.6.weight': torch.Size([16, 32, 1]), 'phi.6.bias': torch.Size([16]), 'phi.7.weight': torch.Size([16]), 'phi.7.bias': torch.Size([16]), 'phi.7.running_mean': torch.Size([16]), 'phi.7.running_var': torch.Size([16]), 'phi.7.num_batches_tracked': torch.Size([]), 'rho.0.weight': torch.Size([50, 16]), 'rho.0.bias': torch.Size([50]), 'rho.1.weight': torch.Size([50]), 'rho.1.bias': torch.Size([50]), 'rho.1.running_mean': torch.Size([50]), 'rho.1.running_var': torch.Size([50]), 'rho.1.num_batches_tracked': torch.Size([]), 'rho.3.weight': torch.Size([2, 50]), 'rho.3.bias': torch.Size([2])}\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.nn import (\n",
    "    Sequential as Seq,\n",
    "    Linear as Lin,\n",
    "    ReLU,\n",
    "    BatchNorm1d,\n",
    "    AvgPool1d,\n",
    "    Sigmoid,\n",
    "    Conv1d,\n",
    ")\n",
    "from torch_scatter import scatter_mean\n",
    "\n",
    "# ntracks = 60\n",
    "inputs = 6\n",
    "hidden1 = 64\n",
    "hidden2 = 32\n",
    "hidden3 = 16\n",
    "classify1 = 50\n",
    "outputs = 2\n",
    "\n",
    "\n",
    "class DeepSets(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super(DeepSets, self).__init__()\n",
    "        self.phi = Seq(\n",
    "            Conv1d(inputs, hidden1, 1),\n",
    "            BatchNorm1d(hidden1),\n",
    "            ReLU(),\n",
    "            Conv1d(hidden1, hidden2, 1),\n",
    "            BatchNorm1d(hidden2),\n",
    "            ReLU(),\n",
    "            Conv1d(hidden2, hidden3, 1),\n",
    "            BatchNorm1d(hidden3),\n",
    "            ReLU(),\n",
    "        )\n",
    "        self.rho = Seq(\n",
    "            Lin(hidden3, classify1),\n",
    "            BatchNorm1d(classify1),\n",
    "            ReLU(),\n",
    "            Lin(classify1, outputs),\n",
    "            Sigmoid(),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.phi(x)\n",
    "        out = scatter_mean(out, torch.LongTensor(np.zeros(ntracks)), dim=-1)\n",
    "        return self.rho(torch.squeeze(out))\n",
    "\n",
    "\n",
    "model = DeepSets()\n",
    "print(model)\n",
    "print(\"----------\")\n",
    "print({l: model.state_dict()[l].shape for l in model.state_dict()})\n",
    "\n",
    "model = DeepSets().to(device)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define training loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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",
    "        x = data[0].to(device)\n",
    "        y = data[1].to(device)\n",
    "        y = torch.argmax(y, dim=1)\n",
    "        batch_output = model(x)\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",
    "        x = data[0].to(device)\n",
    "        y = data[1].to(device)\n",
    "        y = torch.argmax(y, dim=1)\n",
    "        optimizer.zero_grad()\n",
    "        batch_output = model(x)\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": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import ConcatDataset\n",
    "\n",
    "train_generator_data = ConcatDataset(train_generator.datas)\n",
    "test_generator_data = ConcatDataset(test_generator.datas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9387\n",
      "7510\n",
      "1877\n",
      "3751\n"
     ]
    }
   ],
   "source": [
    "from torch.utils.data import random_split, DataLoader\n",
    "\n",
    "torch.manual_seed(0)\n",
    "valid_frac = 0.20\n",
    "train_length = len(train_generator_data)\n",
    "valid_num = int(valid_frac * train_length)\n",
    "batch_size = 32\n",
    "\n",
    "train_dataset, valid_dataset = random_split(\n",
    "    train_generator_data, [train_length - valid_num, valid_num]\n",
    ")\n",
    "\n",
    "\n",
    "def collate(items):\n",
    "    l = sum(items, [])\n",
    "    return Batch.from_data_list(l)\n",
    "\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "# train_loader.collate_fn = collate\n",
    "valid_loader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False)\n",
    "# valid_loader.collate_fn = collate\n",
    "test_loader = DataLoader(test_generator_data, batch_size=batch_size, shuffle=False)\n",
    "# test_loader.collate_fn = collate\n",
    "\n",
    "train_samples = len(train_dataset)\n",
    "valid_samples = len(valid_dataset)\n",
    "test_samples = len(test_generator_data)\n",
    "print(train_length)\n",
    "print(train_samples)\n",
    "print(valid_samples)\n",
    "print(test_samples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bcab3e1a533049d09e55fbb827736ba5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/30 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/234.6875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/58.65625 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 00, Training Loss:   0.4502\n",
      "           Validation Loss: 0.4461\n",
      "New best model saved to: deepsets_best.pth\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/234.6875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/58.65625 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 01, Training Loss:   0.4396\n",
      "           Validation Loss: 0.4470\n",
      "Stale epoch\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/234.6875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/58.65625 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 02, Training Loss:   0.4404\n",
      "           Validation Loss: 0.4452\n",
      "New best model saved to: deepsets_best.pth\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/234.6875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/58.65625 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 03, Training Loss:   0.4397\n",
      "           Validation Loss: 0.4475\n",
      "Stale epoch\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/234.6875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/58.65625 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 04, Training Loss:   0.4396\n",
      "           Validation Loss: 0.4489\n",
      "Stale epoch\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/234.6875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/58.65625 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 05, Training Loss:   0.4397\n",
      "           Validation Loss: 0.4465\n",
      "Stale epoch\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/234.6875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/58.65625 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 06, Training Loss:   0.4392\n",
      "           Validation Loss: 0.4467\n",
      "Stale epoch\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/234.6875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/58.65625 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 07, Training Loss:   0.4392\n",
      "           Validation Loss: 0.4489\n",
      "Stale epoch\n",
      "Early stopping after 5 stale epochs\n"
     ]
    }
   ],
   "source": [
    "import os.path as osp\n",
    "\n",
    "n_epochs = 30\n",
    "stale_epochs = 0\n",
    "best_valid_loss = 99999\n",
    "patience = 5\n",
    "t = tqdm(range(0, n_epochs))\n",
    "\n",
    "for epoch in t:\n",
    "    loss = train(\n",
    "        model,\n",
    "        optimizer,\n",
    "        train_loader,\n",
    "        train_samples,\n",
    "        batch_size,\n",
    "        leave=bool(epoch == n_epochs - 1),\n",
    "    )\n",
    "    valid_loss = test(\n",
    "        model,\n",
    "        valid_loader,\n",
    "        valid_samples,\n",
    "        batch_size,\n",
    "        leave=bool(epoch == n_epochs - 1),\n",
    "    )\n",
    "    print(\"Epoch: {:02d}, Training Loss:   {:.4f}\".format(epoch, loss))\n",
    "    print(\"           Validation Loss: {:.4f}\".format(valid_loss))\n",
    "\n",
    "    if valid_loss < best_valid_loss:\n",
    "        best_valid_loss = valid_loss\n",
    "        modpath = osp.join(\"deepsets_best.pth\")\n",
    "        print(\"New best model saved to:\", modpath)\n",
    "        torch.save(model.state_dict(), modpath)\n",
    "        stale_epochs = 0\n",
    "    else:\n",
    "        print(\"Stale epoch\")\n",
    "        stale_epochs += 1\n",
    "    if stale_epochs >= 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": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "08ae3357d440459fb733b72cac7c5476",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/117.21875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# In case you need to load the model from a pth file\n",
    "# Trained on 4 vectors (as above in notebook)\n",
    "# urlPTH = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/deepsets_best_4vec.pth\"\n",
    "# pthFile = wget.download(urlPTH)\n",
    "# model.load_state_dict(torch.load(\"deepsets_best_4vec.pth\"))\n",
    "# Trained on all possible inputs (a different configuration)\n",
    "# urlPTH = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/deepsets_best_AllTraining.pth\"\n",
    "# pthFile = wget.download(urlPTH)\n",
    "# model.load_state_dict(torch.load(\"deepsets_best_AllTraining.pth\"))\n",
    "\n",
    "model.eval()\n",
    "t = tqdm(enumerate(test_loader), total=test_samples / batch_size)\n",
    "y_test = []\n",
    "y_predict = []\n",
    "track_pt = []\n",
    "for i, data in t:\n",
    "    x = data[0].to(device)\n",
    "    y = data[1].to(device)\n",
    "    track_pt.append(x[:, 0, 0].numpy())\n",
    "    batch_output = model(x)\n",
    "    y_predict.append(batch_output.detach().cpu().numpy())\n",
    "    y_test.append(y.cpu().numpy())\n",
    "track_pt = np.concatenate(track_pt)\n",
    "y_test = np.concatenate(y_test)\n",
    "y_predict = np.concatenate(y_predict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# For Colab\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "_, bins, _ = plt.hist(\n",
    "    track_pt[y_test[:, 1] == 1], bins=50, label=\"sig\", histtype=\"step\"\n",
    ")\n",
    "_, bins, _ = plt.hist(\n",
    "    track_pt[y_test[:, 1] == 0], bins=bins, label=\"bkg\", histtype=\"step\"\n",
    ")\n",
    "plt.legend()\n",
    "plt.semilogy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "from sklearn.metrics import roc_curve, auc\n",
    "import mplhep as hep\n",
    "\n",
    "plt.style.use(hep.style.ROOT)\n",
    "# create ROC curves\n",
    "fpr_deepset, tpr_deepset, threshold_deepset = roc_curve(y_test[:, 1], y_predict[:, 1])\n",
    "with open(\"deepset_roc.npy\", \"wb\") as f:\n",
    "    np.save(f, fpr_deepset)\n",
    "    np.save(f, tpr_deepset)\n",
    "    np.save(f, threshold_deepset)\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.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": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "95eb11fb11914c0fa6098a810971e71f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/117.21875 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.eval()\n",
    "t = tqdm(enumerate(test_loader), total=test_samples / batch_size)\n",
    "y_test = []\n",
    "y_predict = []\n",
    "track_pt = []\n",
    "for i, data in t:\n",
    "    x = data[0].to(device)\n",
    "    y = data[1].to(device)\n",
    "    idx = torch.randperm(x.size(2))\n",
    "    x = x[:, :, idx]\n",
    "    track_pt.append(x[:, 0, 0].numpy())\n",
    "    batch_output = model(x)\n",
    "    y_predict.append(batch_output.detach().cpu().numpy())\n",
    "    y_test.append(y.cpu().numpy())\n",
    "track_pt = np.concatenate(track_pt)\n",
    "y_test = np.concatenate(y_test)\n",
    "y_predict = np.concatenate(y_predict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "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_deepset_perm, tpr_deepset_perm, threshold_deepset_perm = roc_curve(\n",
    "    y_test[:, 1], y_predict[:, 1]\n",
    ")\n",
    "with open(\"deepset_perm_roc.npy\", \"wb\") as f:\n",
    "    np.save(f, fpr_deepset)\n",
    "    np.save(f, tpr_deepset)\n",
    "    np.save(f, threshold_deepset)\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_deepset_perm,\n",
    "    fpr_deepset_perm,\n",
    "    lw=2.5,\n",
    "    label=\"DeepSet (Permuted), AUC = {:.1f}%\".format(\n",
    "        auc(fpr_deepset_perm, tpr_deepset_perm) * 100\n",
    "    ),\n",
    "    linestyle=\"dashed\",\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": 15,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "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_deepset_lowb, tpr_deepset_lowb, threshold_deepset_lowb = roc_curve(\n",
    "    y_test[track_pt <= pt_split, 1], y_predict[track_pt <= pt_split, 1]\n",
    ")\n",
    "fpr_deepset_highb, tpr_deepset_highb, threshold_deepset_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_deepset_lowb,\n",
    "    fpr_deepset_lowb,\n",
    "    lw=2.5,\n",
    "    label=\"DeepSet (low pT), AUC = {:.1f}%\".format(\n",
    "        auc(fpr_deepset_lowb, tpr_deepset_lowb) * 100\n",
    "    ),\n",
    ")\n",
    "plt.plot(\n",
    "    tpr_deepset_highb,\n",
    "    fpr_deepset_highb,\n",
    "    lw=2.5,\n",
    "    label=\"DeepSet (high pT), AUC = {:.1f}%\".format(\n",
    "        auc(fpr_deepset_highb, tpr_deepset_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": "markdown",
   "metadata": {},
   "source": [
    "If you finish this notebook, you can go back and retrain with different inputs.  Replace the code above:\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",
    "with\n",
    "```\n",
    "# WGET for colab\n",
    "if not os.path.exists(\"definitions.yml\"):\n",
    "    url = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/definitions.yml\"\n",
    "    definitionsFile = wget.download(url)\n",
    "\n",
    "with open(\"definitions.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",
    "```"
   ]
  },
  {
   "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
}