{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "24b92c4c",
   "metadata": {},
   "source": [
    "# AGC Training Demonstration\n",
    "________\n",
    "\n",
    "This notebook demonstrates a workflow for training a BDT with MLFlow logging and model storage at a coffea-casa analysis facility. The ML task shown here is simple signal/background classification, which was chosen for this demonstration so that we can focus on the technical aspects of the workflow. As such, the task and the features used are not necessarily well-motivated from a physics standpoint. This is a precursor to a talk at CHEP 2023, which will demonstrate both training and inference at coffea-casa analysis facility in the AGC context, using a BDT which predicts parton association of the jet in an event in order to provide more sophisticated event variables for the ttbar cross-section measurement. To avoid dealing with background cross-sections, the background samples are restricted to wjets.\n",
    "\n",
    "The steps in this notebook are as follows:\n",
    "1. Process ROOT files into feature and label columns using coffea + dask\n",
    "2. Prepare columns for training\n",
    "    - Separate dataset into training and testing samples (even and odd event numbers)\n",
    "    - Preprocess features using `sklearn` PowerTransformer\n",
    "3. Train BDTs for each event sample and perform hyperparameter optimization\n",
    "    - Perform hyperparameter optimization by random sample method, using n-fold cross-validation\n",
    "    - Use distributed dask to parallelize\n",
    "    - Log training results for each trial in MLFlow\n",
    "    - Log models for each trial in MLFlow\n",
    "4. Test and register models\n",
    "    - Test each model against the appropriate test sample (even/odd event numbers)\n",
    "    - Register best model in MLFlow model repository\n",
    "    - Generate NVIDIA Triton model config file and move to Triton inference server (this last step will eventually become more automated using the triton-mlflow plugin)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58232012-8ecb-40bb-bcd1-9cc60f38746a",
   "metadata": {},
   "source": [
    "___\n",
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2130f252",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.8/site-packages/requests/__init__.py:102: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (5.0.0)/charset_normalizer (2.0.9) doesn't match a supported version!\n",
      "  warnings.warn(\"urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported \"\n"
     ]
    }
   ],
   "source": [
    "import awkward as ak\n",
    "import hist\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import uproot\n",
    "import time\n",
    "import os\n",
    "\n",
    "# initial coffea processing\n",
    "from coffea import processor\n",
    "from coffea.processor import servicex\n",
    "from coffea.nanoevents import NanoAODSchema\n",
    "\n",
    "# for training/hyperparameter ioptimization\n",
    "from dask.distributed import Client, LocalCluster\n",
    "from sklearn.preprocessing import PowerTransformer\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score\n",
    "from sklearn.model_selection import ParameterSampler, train_test_split, KFold, cross_validate\n",
    "import mlflow\n",
    "from mlflow.models.signature import infer_signature\n",
    "from mlflow.tracking import MlflowClient\n",
    "from xgboost import XGBClassifier\n",
    "\n",
    "import utils  # contains code for bookkeeping and cosmetics, as well as some boilerplate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a8695ae-6e0f-4f86-8815-720f664c56d4",
   "metadata": {},
   "source": [
    "___\n",
    "### Configuration\n",
    "\n",
    "The configuration options below are separated into two categories: those used for processing the feature set, and those used for ML."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b547996c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "### FILE PROCESSING OPTIONS\n",
    "\n",
    "# input files per process (ttbar and wjets)\n",
    "N_FILES_MAX_PER_SAMPLE = 1\n",
    "\n",
    "# enable Dask (essentially whether to use DaskExecutor or FuturesExecutor with coffea)\n",
    "USE_DASK_PROCESSING = True\n",
    "\n",
    "# analysis facility: set to \"coffea_casa\" for coffea-casa environments, \"EAF\" for FNAL, \"local\" for local setups\n",
    "AF = \"coffea_casa\"\n",
    "\n",
    "# chunk size to use for file processing\n",
    "CHUNKSIZE = 250_000\n",
    "\n",
    "# \"ssl-dev\" allows for the switch to local data on /data\n",
    "AF_NAME = \"coffea_casa\"  # \"ssl-dev\" allows for the switch to local data on /data\n",
    "\n",
    "# scaling for local setups with FuturesExecutor\n",
    "NUM_CORES = 8\n",
    "\n",
    "\n",
    "### MACHINE LEARNING OPTIONS\n",
    "\n",
    "# enable Dask (whether to use dask for hyperparameter optimization)\n",
    "USE_DASK_ML = True\n",
    "\n",
    "# enable MLFlow logging (to store metrics and models of hyperparameter optimization trials)\n",
    "USE_MLFLOW = True\n",
    "\n",
    "# enable MLFlow model logging/registering\n",
    "MODEL_LOGGING = False\n",
    "\n",
    "# number of folds for cross-validation\n",
    "N_FOLD = 5\n",
    "\n",
    "# number of trials (per model) for hyperparameter optimization. Total number of trials will be 2*N_TRIALS\n",
    "N_TRIALS = 20\n",
    "\n",
    "# number of events to use for training (choose smaller number, i.e. 10000, for quick demo)\n",
    "N_TRAIN = 10000\n",
    "\n",
    "# name to use for saving model to triton server\n",
    "MODEL_NAME = \"sigbkg_bdt\"\n",
    "\n",
    "# if True, write over previous versions of model in triton directory\n",
    "WRITE_OVER = True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8674317-8ecd-402c-a1fe-d5de1074705e",
   "metadata": {},
   "source": [
    "___\n",
    "### Defining the `coffea` Processor\n",
    "\n",
    "This processor returns columns associated with the features and labels we will use to train a BDT to distinguish signal from background events. `coffea`'s column accumulator is utilized. The cuts here are much looser than those used in the AGC ttbar notebook in order to provide ample discrimination power for demonstration purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ce9f9967",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# function to create column accumulator from list\n",
    "def col_accumulator(a):\n",
    "    return processor.column_accumulator(np.array(a))\n",
    "\n",
    "# coffea processor\n",
    "class ProcessFeatures(processor.ProcessorABC):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "    def process(self, events):\n",
    "        \n",
    "        process = events.metadata[\"process\"]  # \"ttbar\" or \"wjets\"\n",
    "        \n",
    "        electrons = events.Electron\n",
    "        muons = events.Muon\n",
    "        jets = events.Jet\n",
    "        even = (events.event%2==0) # whether the event number is even\n",
    "\n",
    "        # single lepton requirement\n",
    "        event_filters = ((ak.count(electrons.pt, axis=1) + ak.count(muons.pt, axis=1)) == 1)\n",
    "        # at least four jets\n",
    "        event_filters = event_filters & (ak.count(jets.pt, axis=1) >= 4)\n",
    "        # at least one b-tagged jet (\"tag\" means score above threshold)\n",
    "        B_TAG_THRESHOLD = 0.5\n",
    "        event_filters = event_filters & (ak.sum(jets.btagCSVV2 >= B_TAG_THRESHOLD, axis=1) >= 1)\n",
    "\n",
    "        # apply event filters\n",
    "        electrons = electrons[event_filters]\n",
    "        muons = muons[event_filters]\n",
    "        jets = jets[event_filters]\n",
    "        even = even[event_filters]\n",
    "        \n",
    "        \n",
    "        ### CALCULATE FEATURES\n",
    "        \n",
    "        ## calculate aplanarity and aphericity from sphericity tensor of all jets in event\n",
    "        \n",
    "        # sum of jet momentum\n",
    "        sum_p = ak.sum(jets.p**2, axis=-1) \n",
    "\n",
    "        # off-diagonal elements\n",
    "        Sxy =  np.divide(ak.sum(np.multiply(jets.px, jets.py), axis=-1), sum_p)\n",
    "        Sxz =  np.divide(ak.sum(np.multiply(jets.px, jets.pz), axis=-1), sum_p)\n",
    "        Syz =  np.divide(ak.sum(np.multiply(jets.py, jets.pz), axis=-1), sum_p)\n",
    "        \n",
    "        # diagonal elements\n",
    "        Sxx =  np.divide(ak.sum(jets.px**2, axis=-1), sum_p)\n",
    "        Syy =  np.divide(ak.sum(jets.py**2, axis=-1), sum_p)\n",
    "        Szz =  np.divide(ak.sum(jets.pz**2, axis=-1), sum_p)\n",
    "\n",
    "        # combine elements into sphericity tensor\n",
    "        flat = np.stack((Sxx,Sxy,Sxz,Sxy,Syy,Syz,Sxz,Syz,Szz),axis=1).to_numpy()\n",
    "        sphericity_tensor = flat.reshape((flat.shape[0],3,3))\n",
    "\n",
    "        # find eigenvalues then calculate features\n",
    "        eigenvalues = ak.sort(np.linalg.eigvals(sphericity_tensor),axis=-1)\n",
    "        aplanarity = (3/2)*eigenvalues[...,0]\n",
    "        sphericity = (3/2)*(eigenvalues[...,0]+eigenvalues[...,1])\n",
    "        \n",
    "        ## calculate lepton eta and phi (should be one value per event due to single-lepton requirement\n",
    "        lepton_eta = (ak.sum(electrons.eta,axis=-1) + ak.sum(muons.eta,axis=-1))\n",
    "        lepton_phi = (ak.sum(electrons.phi,axis=-1) + ak.sum(muons.phi,axis=-1))\n",
    "        \n",
    "        ## populate array of features\n",
    "        features = np.zeros((len(jets),10))\n",
    "        features[:,0] = ak.num(jets) # number of jets in each event\n",
    "        features[:,1] = ak.sum(jets.pt, axis=-1) # event HT\n",
    "        features[:,2] = (ak.sum(electrons.pt,axis=-1) + ak.sum(muons.pt,axis=-1))  # lepton pt\n",
    "        features[:,3] = jets.nConstituents[...,0] # leading jet number of constituents\n",
    "        features[:,4] = ak.sum(jets.nConstituents,axis=-1) # total event number of constituents\n",
    "        features[:,5] = jets.pt[...,0] # leading jet pT\n",
    "        features[:,6] = aplanarity # aplanarity\n",
    "        features[:,7] = sphericity # sphericity\n",
    "        features[:,8] = np.sqrt((lepton_eta-jets.eta[...,0])**2 + \n",
    "                                (lepton_phi-jets.phi[...,0])**2) # delta R between leading jet and lepton\n",
    "        features[:,9] = np.sqrt((jets.eta[...,1]-jets.eta[...,0])**2 + \n",
    "                                (jets.phi[...,1]-jets.phi[...,0])**2) # delta R between two leading jets\n",
    "        \n",
    "        ### calculate labels (1 for ttbar, 0 for wjets)\n",
    "        if process=='ttbar':\n",
    "            labels = np.ones(len(jets))\n",
    "        else:\n",
    "            labels = np.zeros(len(jets))\n",
    "        \n",
    "\n",
    "        output = {\"nevents\": {events.metadata[\"dataset\"]: len(jets)}, \n",
    "                  \"features\": col_accumulator(features),\n",
    "                  \"labels\": col_accumulator(labels),\n",
    "                  \"even\": col_accumulator(even),}\n",
    "\n",
    "        return output\n",
    "\n",
    "    def postprocess(self, accumulator):\n",
    "        return accumulator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f586fab7-16cf-492b-9e00-bf8fb856bf87",
   "metadata": {},
   "source": [
    "___\n",
    "### \"Fileset\" construction and metadata\n",
    "\n",
    "Here, we gather all the required information about the files we want to process: paths to the files and asociated metadata."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "29341dd9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ttbar__nominal': {'files': ['https://xrootd-local.unl.edu:1094//store/user/AGC/nanoAOD/TT_TuneCUETP8M1_13TeV-powheg-pythia8/cmsopendata2015_ttbar_19980_PU25nsData2015v1_76X_mcRun2_asymptotic_v12_ext3-v1_00000_0000.root'],\n",
       "  'metadata': {'process': 'ttbar',\n",
       "   'variation': 'nominal',\n",
       "   'nevts': 1334428,\n",
       "   'xsec': 729.84}},\n",
       " 'wjets__nominal': {'files': ['https://xrootd-local.unl.edu:1094//store/user/AGC/nanoAOD/WJetsToLNu_TuneCUETP8M1_13TeV-amcatnloFXFX-pythia8/cmsopendata2015_wjets_20547_PU25nsData2015v1_76X_mcRun2_asymptotic_v12_ext2-v1_10000_0000.root'],\n",
       "  'metadata': {'process': 'wjets',\n",
       "   'variation': 'nominal',\n",
       "   'nevts': 1249076,\n",
       "   'xsec': 15487.164}}}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileset = utils.construct_fileset(N_FILES_MAX_PER_SAMPLE, \n",
    "                                  use_xcache=False, \n",
    "                                  af_name=AF_NAME)  # local files on /data for ssl-dev\n",
    "\n",
    "# get rid of all processes except ttbar (signal) and wjets (background)\n",
    "processes = list(fileset.keys())\n",
    "for process in processes:\n",
    "    if ((process!=\"ttbar__nominal\") & (process!=\"wjets__nominal\")):\n",
    "        fileset.pop(process)\n",
    "fileset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ff864b1-9b18-4fdf-a001-9b7f6e9e673e",
   "metadata": {},
   "source": [
    "___\n",
    "### Process Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "78fce979",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.8/site-packages/distributed/client.py:1288: VersionMismatchWarning: Mismatched versions found\n",
      "\n",
      "+---------+----------------+----------------+----------------+\n",
      "| Package | client         | scheduler      | workers        |\n",
      "+---------+----------------+----------------+----------------+\n",
      "| python  | 3.8.16.final.0 | 3.8.16.final.0 | 3.8.15.final.0 |\n",
      "+---------+----------------+----------------+----------------+\n",
      "  warnings.warn(version_module.VersionMismatchWarning(msg[0][\"warning\"]))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[########################################] | 100% Completed | 28.1s\r"
     ]
    }
   ],
   "source": [
    "NanoAODSchema.warn_missing_crossrefs = False # silences warnings about branches we will not use here\n",
    "\n",
    "if USE_DASK_PROCESSING:\n",
    "    executor = processor.DaskExecutor(client=utils.get_client(AF))\n",
    "else:\n",
    "    executor = processor.FuturesExecutor(workers=NUM_CORES)\n",
    "\n",
    "run = processor.Runner(executor=executor, schema=NanoAODSchema, savemetrics=True, metadata_cache={}, \n",
    "                       chunksize=CHUNKSIZE, maxchunks=1)\n",
    "filemeta = run.preprocess(fileset, treename=\"Events\")  # pre-processing\n",
    "all_columns, metrics = run(fileset, \"Events\", processor_instance=ProcessFeatures())  # processing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be8f321a-940a-4e25-86f0-e5889331ad86",
   "metadata": {},
   "source": [
    "___\n",
    "### Inspecting the Features\n",
    "\n",
    "Let's look at the features we will use for training, comparing signal to background distributions. Note that some of the features we use would need to be appropriately calibrated to use in an actual analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9f17abd8-74ed-40db-9ea8-73341c8bf627",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# grab the numpy arrays from the column_accumulator objects\n",
    "features = all_columns[\"features\"].value\n",
    "labels = all_columns[\"labels\"].value\n",
    "even = all_columns[\"even\"].value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "70f32c49-ecd0-43e3-b678-c1af245fd4a5",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial Sig/Bkg Ratio =  6.3710530291584835\n",
      "Final Sig/Bkg Ratio =  1.0\n"
     ]
    }
   ],
   "source": [
    "### balance signal and background samples\n",
    "\n",
    "# separate into signal and background regions\n",
    "features_signal = features[labels==1]\n",
    "features_background = features[labels==0]\n",
    "even_signal = even[labels==1]\n",
    "even_background = even[labels==0]\n",
    "\n",
    "sb_ratio = len(features_signal)/len(features_background)\n",
    "print(\"Initial Sig/Bkg Ratio = \", sb_ratio)\n",
    "\n",
    "if len(features_signal)>len(features_background):\n",
    "    features_signal = features_signal[:len(features_background)]\n",
    "    even_signal = even_signal[:len(features_background)]\n",
    "    \n",
    "if len(features_background)>len(features_signal):\n",
    "    features_background = features_background[:len(features_signal)]\n",
    "    even_background = even_background[:len(features_signal)]\n",
    "\n",
    "sb_ratio = len(features_signal)/len(features_background)\n",
    "print(\"Final Sig/Bkg Ratio = \", sb_ratio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b8f12ad9-b2b4-4bfd-9f3f-833b90dbf54d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x1600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "### FIRST FOUR FEATURES\n",
    "\n",
    "# define histogram\n",
    "h = hist.Hist(\n",
    "    hist.axis.Regular(11, 4, 15, name=\"njet\", label=\"Number of Jets\", flow=False),\n",
    "    hist.axis.Regular(50, 0, 1000, name=\"ht\", label=\"$H_T$\", flow=True),\n",
    "    hist.axis.Regular(50, 0, 200, name=\"leptonpt\", label=\"Lepton $p_T$\", flow=False),\n",
    "    hist.axis.Regular(50, 0, 100, name=\"ljnconst\", label=\"Leading Jet Number of Constituents\", flow=False),\n",
    "    hist.axis.StrCategory([\"Signal\", \"Background\"], name=\"truthlabel\", label=\"Truth Label\"),\n",
    ")\n",
    "\n",
    "# fill histogram\n",
    "h.fill(njet = features_signal[:,0], ht = features_signal[:,1], \n",
    "       leptonpt = features_signal[:,2], ljnconst = features_signal[:,3], \n",
    "       truthlabel=\"Signal\")\n",
    "h.fill(njet = features_background[:,0], ht = features_background[:,1], \n",
    "       leptonpt = features_background[:,2], ljnconst = features_background[:,3], \n",
    "       truthlabel=\"Background\")\n",
    "\n",
    "# make plots\n",
    "fig,axs = plt.subplots(4,1,figsize=(8,16))\n",
    "\n",
    "h.project(\"njet\",\"truthlabel\").plot(density=True, ax=axs[0])\n",
    "axs[0].legend()\n",
    "h.project(\"ht\",\"truthlabel\").plot(density=True, ax=axs[1])\n",
    "axs[1].legend()\n",
    "h.project(\"leptonpt\",\"truthlabel\").plot(density=True, ax=axs[2])\n",
    "axs[2].legend()\n",
    "h.project(\"ljnconst\",\"truthlabel\").plot(density=True, ax=axs[3])\n",
    "axs[3].legend()\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0faafb50-e784-4939-94fa-d680abd6cc3e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x1600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "### NEXT FOUR FEATURES\n",
    "\n",
    "# define histogram\n",
    "h = hist.Hist(\n",
    "    hist.axis.Regular(50, 0, 300, name=\"totalnconst\", label=\"Sum of Number of Constituents\", flow=False),\n",
    "    hist.axis.Regular(50, 0, 300, name=\"ljpt\", label=\"Leading Jet $p_T$\", flow=False),\n",
    "    hist.axis.Regular(50, 0, 0.5, name=\"aplanarity\", label=\"Aplanarity\", flow=False),\n",
    "    hist.axis.Regular(50, 0, 0.9, name=\"sphericity\", label=\"Sphericity\", flow=False),\n",
    "    hist.axis.StrCategory([\"Signal\", \"Background\"], name=\"truthlabel\", label=\"Truth Label\"),\n",
    ")\n",
    "\n",
    "# fill histogram\n",
    "h.fill(totalnconst = features_signal[:,4], ljpt = features_signal[:,5], \n",
    "       aplanarity = features_signal[:,6], sphericity = features_signal[:,7],\n",
    "       truthlabel=\"Signal\")\n",
    "h.fill(totalnconst = features_background[:,4], ljpt = features_background[:,5], \n",
    "       aplanarity = features_background[:,6], sphericity = features_background[:,7],\n",
    "       truthlabel=\"Background\")\n",
    "\n",
    "fig,axs = plt.subplots(4,1,figsize=(8,16))\n",
    "\n",
    "h.project(\"totalnconst\",\"truthlabel\").plot(density=True, ax=axs[0])\n",
    "axs[0].legend()\n",
    "h.project(\"ljpt\",\"truthlabel\").plot(density=True, ax=axs[1])\n",
    "axs[1].legend()\n",
    "h.project(\"aplanarity\",\"truthlabel\").plot(density=True, ax=axs[2])\n",
    "axs[2].legend()\n",
    "h.project(\"sphericity\",\"truthlabel\").plot(density=True, ax=axs[3])\n",
    "axs[3].legend()\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d6247a1c-a231-464f-afc6-f9d47f95882d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "### LAST TWO FEATURES\n",
    "\n",
    "# define histogram\n",
    "h = hist.Hist(\n",
    "    hist.axis.Regular(50, 0, 8, name=\"ljlepdeltar\", label=\"$\\Delta R$ Between Leading Jet and Lepton\", flow=False),\n",
    "    hist.axis.Regular(50, 0, 8, name=\"twoljdeltar\", label=\"$\\Delta R$ Between Two Leading Jets\", flow=False),\n",
    "    hist.axis.StrCategory([\"Signal\", \"Background\"], name=\"truthlabel\", label=\"Truth Label\"),\n",
    ")\n",
    "\n",
    "# fill histogram\n",
    "h.fill(ljlepdeltar = features_signal[:,8], twoljdeltar = features_signal[:,9], \n",
    "       truthlabel=\"Signal\")\n",
    "h.fill(ljlepdeltar = features_background[:,8], twoljdeltar = features_background[:,9], \n",
    "       truthlabel=\"Background\")\n",
    "\n",
    "fig,axs = plt.subplots(2,1,figsize=(8,8))\n",
    "\n",
    "h.project(\"ljlepdeltar\",\"truthlabel\").plot(density=True, ax=axs[0])\n",
    "axs[0].legend()\n",
    "h.project(\"twoljdeltar\",\"truthlabel\").plot(density=True, ax=axs[1])\n",
    "axs[1].legend()\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3782415a-23fc-4c3e-ac2a-f0b3c12831f0",
   "metadata": {},
   "source": [
    "___\n",
    "### Preprocess and Split Events into Train/Test/Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d20ccfe7-fe4a-4a14-9102-d1e61fc96efe",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# re-combine events\n",
    "features = np.concatenate((features_signal, features_background))\n",
    "even = np.concatenate((even_signal, even_background))\n",
    "labels = np.concatenate((np.ones(len(even_signal)), np.zeros(len(even_background))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9d7b20bd-76e6-4005-b351-0f51d8620f23",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "% Signal for Even-Numbered Events =  49.70423176095859\n",
      "% Signal for Odd-Numbered Events =  50.293453724604966\n"
     ]
    }
   ],
   "source": [
    "# separate dataset into even and odd features\n",
    "features_even = features[even]\n",
    "labels_even = labels[even]\n",
    "\n",
    "features_odd = features[np.invert(even)]\n",
    "labels_odd = labels[np.invert(even)]\n",
    "\n",
    "\n",
    "# shuffle events\n",
    "shuffle_ind_even = list(range(len(labels_even)))\n",
    "np.random.shuffle(shuffle_ind_even)\n",
    "features_even = features_even[shuffle_ind_even]\n",
    "labels_even = labels_even[shuffle_ind_even]\n",
    "\n",
    "shuffle_ind_odd = list(range(len(labels_odd)))\n",
    "np.random.shuffle(shuffle_ind_odd)\n",
    "features_odd = features_odd[shuffle_ind_odd]\n",
    "labels_odd = labels_odd[shuffle_ind_odd]\n",
    "\n",
    "print(\"% Signal for Even-Numbered Events = \", 100*np.average(labels_even))\n",
    "print(\"% Signal for Odd-Numbered Events = \", 100*np.average(labels_odd))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1b7ee366-d729-455d-956a-e3d9d6726ddd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# preprocess features so that they are more Gaussian-like\n",
    "power = PowerTransformer(method='yeo-johnson', standardize=True) #define preprocessor\n",
    "\n",
    "features_odd = power.fit_transform(features_odd)\n",
    "features_even = power.fit_transform(features_even)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2248f7c2-78a4-49d7-b47b-cbce6e42cc66",
   "metadata": {},
   "source": [
    "___\n",
    "### Set up MLFlow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "0a5f4f15-7757-446f-bcfa-612e5d7b67dc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# function to provide necessary environment variables to workers\n",
    "def initialize_mlflow(): \n",
    "    \n",
    "    os.system(\"pip install boto3\")\n",
    "\n",
    "    os.environ['MLFLOW_TRACKING_URI'] = \"https://mlflow.software-dev.ncsa.cloud\"\n",
    "    os.environ['MLFLOW_S3_ENDPOINT_URL'] = \"https://mlflow-minio-api.software-dev.ncsa.cloud\"\n",
    "    os.environ['AWS_ACCESS_KEY_ID'] = \"bengal1\"\n",
    "    os.environ['AWS_SECRET_ACCESS_KEY'] = \"leftfoot1\"\n",
    "    \n",
    "    mlflow.set_tracking_uri('https://mlflow.software-dev.ncsa.cloud') \n",
    "    mlflow.set_experiment(\"agc-training-demo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0ac30d5d-22e3-49d7-a904-37e9441c2858",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "experiment_id =  15\n"
     ]
    }
   ],
   "source": [
    "# set up trials\n",
    "\n",
    "if USE_MLFLOW:\n",
    "    mlflow.set_tracking_uri('https://mlflow.software-dev.ncsa.cloud') \n",
    "    mlflow.set_experiment(\"agc-training-demo\") # this will create the experiment if it does not yet exist\n",
    "\n",
    "    # grab experiment\n",
    "    current_experiment=dict(mlflow.get_experiment_by_name(\"agc-training-demo\"))\n",
    "    experiment_id=current_experiment['experiment_id']\n",
    "    print(\"experiment_id = \", experiment_id)\n",
    "\n",
    "    # create runs ahead of time (avoids conflicts when parallelizing mlflow logging)\n",
    "    run_id_list=[]\n",
    "    for n in range(N_TRIALS*2):\n",
    "        run = MlflowClient().create_run(experiment_id=experiment_id, run_name=f\"run-{n}\")\n",
    "        run_id_list.append(run.info.run_id)\n",
    "\n",
    "    #after running the above lines, you should be able to see the runs at https://mlflow.software-dev.ncsa.cloud/#/experiments/10/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "163eb5e4-6913-43a5-b567-adfae7828969",
   "metadata": {},
   "outputs": [],
   "source": [
    "# make directory to save models for triton to\n",
    "if not os.path.isdir(f\"/mnt/{MODEL_NAME}\"):\n",
    "    os.mkdir(f\"/mnt/{MODEL_NAME}\")\n",
    "!ls /mnt/"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "597900cf-b61e-477f-b5b7-c5eba81f9eca",
   "metadata": {},
   "source": [
    "___\n",
    "### Training/Hyperparameter Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "9a44e10b-0841-441f-80bf-eca39a79d81d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example of Trial Parameters: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'reg_lambda': 0.25,\n",
       " 'reg_alpha': 0.25,\n",
       " 'n_estimators': 502,\n",
       " 'min_child_weight': 736.8421052631578,\n",
       " 'max_depth': 8,\n",
       " 'learning_rate': 1e-05,\n",
       " 'gamma': 0.29763514416313164,\n",
       " 'booster': 'gbtree',\n",
       " 'trial_num': 0,\n",
       " 'parity': 'even',\n",
       " 'run_id': '094907b6d9e1454b9b57338fa0af720f'}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate N_TRIALS random samples from parameter space \n",
    "sampler = ParameterSampler(\n",
    "    {\n",
    "        'max_depth': np.arange(2, 50, 2, dtype=int), # maximum tree depth\n",
    "        'n_estimators': np.arange(2, 700, 20, dtype=int), # number of boosting rounds\n",
    "        'learning_rate': np.logspace(-5, 1, 10), # boosted learning rate\n",
    "        'min_child_weight': np.linspace(0, 1000, 20), # minimum weight needed in child\n",
    "        'reg_lambda': [0, 0.25, 0.5, 0.75, 1], # L2 weight regularization\n",
    "        'reg_alpha': [0, 0.25, 0.5, 0.75, 1], # L1 weight regularization\n",
    "        'gamma': np.logspace(-4, 2, 20), # minimum loss reduction to make split in tree\n",
    "        'booster': ['gbtree'], # which booster to use\n",
    "    },\n",
    "    n_iter = N_TRIALS, # number of trials to perform\n",
    "    random_state=1,\n",
    ") \n",
    "\n",
    "samples_even = list(sampler)\n",
    "samples_odd = list(sampler)\n",
    "\n",
    "# add additional info to each trial\n",
    "for i in range(N_TRIALS):\n",
    "    samples_even[i]['trial_num'] = i\n",
    "    samples_even[i]['parity'] = 'even' # categorizes this trial as for even event numbers\n",
    "    \n",
    "    samples_odd[i]['trial_num'] = i\n",
    "    samples_odd[i]['parity'] = 'odd' # categorizes this trial as for odd event numbers\n",
    "    \n",
    "    if USE_MLFLOW: \n",
    "        samples_even[i]['run_id'] = run_id_list[i]\n",
    "        samples_odd[i]['run_id'] = run_id_list[i+N_TRIALS]\n",
    "    \n",
    "print(\"Example of Trial Parameters: \")\n",
    "samples_even[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "1ed91e33-db32-4d62-bc6a-f0ca8e43f87c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def fit_model(params, features, labels, cv, mlflowclient=None, use_mlflow=True, model_logging=True): \n",
    "    \n",
    "    trial_num = params[\"trial_num\"]\n",
    "    parity = params[\"parity\"]\n",
    "    \n",
    "    if use_mlflow:\n",
    "        run_id = params[\"run_id\"]\n",
    "            \n",
    "        for param, value in params.items(): \n",
    "            mlflowclient.log_param(run_id, param, value) \n",
    "            \n",
    "    # remove parameters that are not used for XGBClassifier\n",
    "    params_copy = params.copy()\n",
    "    params_copy.pop(\"trial_num\")\n",
    "    params_copy.pop(\"run_id\")\n",
    "    params_copy.pop(\"parity\")\n",
    "            \n",
    "    # initialize model with current trial paramters\n",
    "    model = XGBClassifier(random_state=5, \n",
    "                          nthread=-1,\n",
    "                          **params_copy) \n",
    "\n",
    "    # perform n-fold cross-validation\n",
    "    result = cross_validate(model, features, labels, \n",
    "                            scoring=['roc_auc','accuracy','precision','f1','recall'], \n",
    "                            cv=cv, n_jobs=-1, \n",
    "                            return_train_score=True, return_estimator=True)\n",
    "    \n",
    "    trial_metrics = {\n",
    "        \"avg_train_roc_auc\": result['train_roc_auc'].mean(), \n",
    "        \"avg_train_accuracy\": result['train_accuracy'].mean(), \n",
    "        \"avg_train_precision\": result['train_precision'].mean(), \n",
    "        \"avg_train_f1\": result['train_f1'].mean(), \n",
    "        \"avg_train_recall\": result['train_recall'].mean(), \n",
    "        \"avg_test_roc_auc\": result['test_roc_auc'].mean(), \n",
    "        \"avg_test_accuracy\": result['test_accuracy'].mean(), \n",
    "        \"avg_test_precision\": result['test_precision'].mean(), \n",
    "        \"avg_test_f1\": result['test_f1'].mean(), \n",
    "        \"avg_test_recall\": result['test_recall'].mean(), \n",
    "        \"avg_fit_time\": result['fit_time'].mean(),\n",
    "        \"avg_score_time\": result['score_time'].mean(),\n",
    "    }\n",
    "    \n",
    "    if use_mlflow:\n",
    "        \n",
    "        for metric, value in trial_metrics.items():\n",
    "            # log timing metrics\n",
    "            mlflowclient.log_metric(run_id, metric, value)\n",
    "\n",
    "        # manually end run\n",
    "        mlflowclient.set_terminated(run_id)\n",
    "            \n",
    "    # fit model with all events\n",
    "    model.fit(features,labels)\n",
    "\n",
    "    # log model in mlflow\n",
    "    if model_logging and use_mlflow:\n",
    "        signature = infer_signature(features, model.predict(features))\n",
    "        with mlflow.start_run(run_id=run_id, nested=True) as run:\n",
    "            mlflow.xgboost.log_model(model, \"model\", signature=signature)\n",
    "    \n",
    "    if model_logging:\n",
    "        return {'score': result['test_roc_auc'].mean()}\n",
    "    \n",
    "    else: # return models as well if we do not log in mlflow\n",
    "        return {'score': result['test_roc_auc'].mean(),\n",
    "                'model': model,\n",
    "                'all_metrics': trial_metrics}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "7eea145e-bec1-46ac-842c-358a9e6dddb1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# folds to use for cross-validation\n",
    "folds = KFold(N_FOLD, random_state=5, shuffle=True)\n",
    "\n",
    "# set mlflowclient\n",
    "mlflowclient = MlflowClient()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c579e34a-c104-49bd-b086-c88625ec6b42",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# set up dask client\n",
    "if USE_DASK_ML:\n",
    "    client = utils.get_client()\n",
    "    client.run(initialize_mlflow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "883d824f-d63e-460a-8dff-0b0cd588eef9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameter optimization took time =  22.939964532852173\n",
      "Highest AUC =  0.9555297656474304\n",
      "Parameters for Model with Highest AUC = \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'reg_lambda': 0.25,\n",
       " 'reg_alpha': 0.75,\n",
       " 'n_estimators': 382,\n",
       " 'min_child_weight': 52.63157894736842,\n",
       " 'max_depth': 20,\n",
       " 'learning_rate': 0.46415888336127725,\n",
       " 'gamma': 0.01623776739188721,\n",
       " 'booster': 'gbtree',\n",
       " 'trial_num': 8,\n",
       " 'parity': 'even',\n",
       " 'run_id': 'ca16dcce8f54489e97029d33c844d4a2'}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## MODEL 1 OPTIMIZATION\n",
    "\n",
    "if USE_DASK_ML:\n",
    "    start_time = time.time() \n",
    "    futures = client.map(fit_model,\n",
    "                         samples_even, \n",
    "                         features=features_even[:N_TRAIN,:], \n",
    "                         labels=labels_even[:N_TRAIN],\n",
    "                         cv=folds,\n",
    "                         mlflowclient=mlflowclient,\n",
    "                         use_mlflow=USE_MLFLOW,\n",
    "                         model_logging=MODEL_LOGGING) \n",
    "    \n",
    "    res = client.gather(futures) \n",
    "    time_elapsed = time.time() - start_time\n",
    "        \n",
    "else:\n",
    "    start_time = time.time() \n",
    "    res = np.zeros(len(samples_even))\n",
    "    for i in range(len(samples_even)):\n",
    "        res[i] = fit_model(samples_even[i], \n",
    "                           features=features_even[:N_TRAIN,:],\n",
    "                           labels=labels_even[:N_TRAIN], \n",
    "                           cv=folds,\n",
    "                           mlflowclient=mlflowclient,\n",
    "                           use_mlflow=USE_MLFLOW,\n",
    "                           model_logging=MODEL_LOGGING)\n",
    "        \n",
    "    time_elapsed = time.time() - start_time\n",
    "    \n",
    "print(\"Hyperparameter optimization took time = \", time_elapsed)\n",
    "\n",
    "scores = [res[i]['score'] for i in range(N_TRIALS)]\n",
    "print(\"Highest AUC = \", max(scores))\n",
    "print(\"Parameters for Model with Highest AUC = \")\n",
    "samples_even[np.argmax(scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "b468c2b8-f341-4fcb-bf2f-0043d2c05b5e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# load best model\n",
    "if MODEL_LOGGING:\n",
    "    best_run_id = samples_even[np.argmax(scores)]['run_id']\n",
    "    best_model_path = f'runs:/{best_run_id}/model'\n",
    "    best_model = mlflow.xgboost.load_model(best_model_path)\n",
    "else:\n",
    "    best_run_id = samples_even[np.argmax(scores)]['run_id']\n",
    "    best_model = res[np.argmax(scores)]['model']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "43c3624d-ccd6-4eda-9469-f4a4e913f9d9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy =  0.9687\n",
      "Train Precision =  0.9723344103392568\n",
      "Train f1 =  0.9685205672332293\n",
      "Train Recall =  0.9647365257463434\n",
      "Train ROC_AUC =  0.9686928785649266\n",
      "\n",
      "Test Accuracy =  0.8906696764484575\n",
      "Test Precision =  0.8886894075403949\n",
      "Test f1 =  0.891022275556889\n",
      "Test Recall =  0.8933674236727327\n",
      "Test ROC_AUC =  0.8906680515442417\n"
     ]
    }
   ],
   "source": [
    "predictions_train = best_model.predict(features_even)\n",
    "predictions_test = best_model.predict(features_odd)\n",
    "\n",
    "print(\"Train Accuracy = \", accuracy_score(predictions_train[:N_TRAIN], labels_even[:N_TRAIN]))\n",
    "print(\"Train Precision = \", precision_score(predictions_train[:N_TRAIN], labels_even[:N_TRAIN]))\n",
    "print(\"Train f1 = \", f1_score(predictions_train[:N_TRAIN], labels_even[:N_TRAIN]))\n",
    "print(\"Train Recall = \", recall_score(predictions_train[:N_TRAIN], labels_even[:N_TRAIN]))\n",
    "print(\"Train ROC_AUC = \", roc_auc_score(predictions_train[:N_TRAIN], labels_even[:N_TRAIN]))\n",
    "print()\n",
    "print(\"Test Accuracy = \", accuracy_score(predictions_test, labels_odd))\n",
    "print(\"Test Precision = \", precision_score(predictions_test, labels_odd))\n",
    "print(\"Test f1 = \", f1_score(predictions_test, labels_odd))\n",
    "print(\"Test Recall = \", recall_score(predictions_test, labels_odd))\n",
    "print(\"Test ROC_AUC = \", roc_auc_score(predictions_test, labels_odd))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "c4a6c55b-3274-486d-b24d-4ea2db801320",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# load best model into model registry\n",
    "if MODEL_LOGGING:\n",
    "    result = mlflow.register_model(best_model_path, \"sig-bkg-bdt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5275e7ec-1130-4a7c-ba52-baf11ecc2087",
   "metadata": {},
   "outputs": [],
   "source": [
    "# save registered model to triton directory\n",
    "if len(os.listdir(f\"/mnt/{MODEL_NAME}\"))==0 or WRITE_OVER:\n",
    "    model_version=1\n",
    "else:\n",
    "    model_version=int(max(next(os.walk(f\"/mnt/{MODEL_NAME}\"))[1]))+1\n",
    "\n",
    "if not WRITE_OVER:\n",
    "    os.mkdir(f\"/mnt/{MODEL_NAME}/{model_version}\")\n",
    "    \n",
    "    \n",
    "print(f\"Saving Model to /mnt/{MODEL_NAME}/{model_version}/xgboost.model\")\n",
    "best_model.save_model(f\"/mnt/{MODEL_NAME}/{model_version}/xgboost.model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "7d508519-625f-448d-af76-249365ba88fa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameter optimization took time =  29.643147945404053\n",
      "Highest AUC =  0.9561495431371775\n",
      "Parameters for Model with Highest AUC = \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'reg_lambda': 0.25,\n",
       " 'reg_alpha': 0.75,\n",
       " 'n_estimators': 382,\n",
       " 'min_child_weight': 52.63157894736842,\n",
       " 'max_depth': 20,\n",
       " 'learning_rate': 0.46415888336127725,\n",
       " 'gamma': 0.01623776739188721,\n",
       " 'booster': 'gbtree',\n",
       " 'trial_num': 8,\n",
       " 'parity': 'odd',\n",
       " 'run_id': '81ee7a5a20b340a7bae11bfeb84e3dbc'}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## MODEL 2 OPTIMIZATION\n",
    "\n",
    "if USE_DASK_ML:\n",
    "    start_time = time.time() \n",
    "    futures = client.map(fit_model,\n",
    "                         samples_odd, \n",
    "                         features=features_odd[:N_TRAIN,:], \n",
    "                         labels=labels_odd[:N_TRAIN],\n",
    "                         cv=folds,\n",
    "                         mlflowclient=mlflowclient,\n",
    "                         use_mlflow=USE_MLFLOW,\n",
    "                         model_logging=MODEL_LOGGING) \n",
    "    \n",
    "    res = client.gather(futures) \n",
    "    time_elapsed = time.time() - start_time\n",
    "        \n",
    "else:\n",
    "    start_time = time.time() \n",
    "    res = np.zeros(len(samples_odd))\n",
    "    for i in range(len(samples_odd)):\n",
    "        res[i] = fit_model(samples_odd[i], \n",
    "                           features=features_odd[:N_TRAIN,:],\n",
    "                           labels=labels_odd[:N_TRAIN], \n",
    "                           cv=folds,\n",
    "                           mlflowclient=mlflowclient,\n",
    "                           use_mlflow=USE_MLFLOW,\n",
    "                           model_logging=MODEL_LOGGING)\n",
    "        \n",
    "    time_elapsed = time.time() - start_time\n",
    "    \n",
    "print(\"Hyperparameter optimization took time = \", time_elapsed)\n",
    "\n",
    "scores = [res[i]['score'] for i in range(N_TRIALS)]\n",
    "print(\"Highest AUC = \", max(scores))\n",
    "print(\"Parameters for Model with Highest AUC = \")\n",
    "samples_odd[np.argmax(scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "44d5cb73-e65d-4275-ba19-871f371f2b73",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# load best model\n",
    "if MODEL_LOGGING:\n",
    "    best_run_id = samples_odd[np.argmax(scores)]['run_id']\n",
    "    best_model_path = f'runs:/{best_run_id}/model'\n",
    "    best_model = mlflow.xgboost.load_model(best_model_path)\n",
    "else:\n",
    "    best_run_id = samples_odd[np.argmax(scores)]['run_id']\n",
    "    best_model = res[np.argmax(scores)]['model']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "5eb501bd-369e-4cd6-98d3-2295b10ec3fe",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy =  0.9708\n",
      "Train Precision =  0.9761003784106752\n",
      "Train f1 =  0.9710719239151973\n",
      "Train Recall =  0.9660950128129312\n",
      "Train ROC_AUC =  0.9708697105875088\n",
      "\n",
      "Test Accuracy =  0.8914758076748066\n",
      "Test Precision =  0.9021971315227342\n",
      "Test f1 =  0.8920570264765784\n",
      "Test Recall =  0.8821423243323885\n",
      "Test ROC_AUC =  0.8916341731179142\n"
     ]
    }
   ],
   "source": [
    "predictions_train = best_model.predict(features_odd)\n",
    "predictions_test = best_model.predict(features_even)\n",
    "\n",
    "print(\"Train Accuracy = \", accuracy_score(predictions_train[:N_TRAIN], labels_odd[:N_TRAIN]))\n",
    "print(\"Train Precision = \", precision_score(predictions_train[:N_TRAIN], labels_odd[:N_TRAIN]))\n",
    "print(\"Train f1 = \", f1_score(predictions_train[:N_TRAIN], labels_odd[:N_TRAIN]))\n",
    "print(\"Train Recall = \", recall_score(predictions_train[:N_TRAIN], labels_odd[:N_TRAIN]))\n",
    "print(\"Train ROC_AUC = \", roc_auc_score(predictions_train[:N_TRAIN], labels_odd[:N_TRAIN]))\n",
    "print()\n",
    "print(\"Test Accuracy = \", accuracy_score(predictions_test, labels_even))\n",
    "print(\"Test Precision = \", precision_score(predictions_test, labels_even))\n",
    "print(\"Test f1 = \", f1_score(predictions_test, labels_even))\n",
    "print(\"Test Recall = \", recall_score(predictions_test, labels_even))\n",
    "print(\"Test ROC_AUC = \", roc_auc_score(predictions_test, labels_even))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "dac8afee-f563-4d49-8613-43ede355bac4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# load best model into model registry\n",
    "if MODEL_LOGGING:\n",
    "    result = mlflow.register_model(best_model_path, \"sig-bkg-bdt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddd079d1-54b7-4ba3-8886-f30523023536",
   "metadata": {},
   "outputs": [],
   "source": [
    "# save registered model to triton directory\n",
    "if len(os.listdir(f\"/mnt/{MODEL_NAME}\"))==0:\n",
    "    model_version=1\n",
    "else:\n",
    "    model_version=int(max(next(os.walk(f\"/mnt/{MODEL_NAME}\"))[1]))+1\n",
    "if WRITE_OVER:\n",
    "    if not os.path.isdir(f\"/mnt/{MODEL_NAME}/{model_version}\"):\n",
    "        os.mkdir(f\"/mnt/{MODEL_NAME}/{model_version}\")\n",
    "    model_version=2\n",
    "    \n",
    "if not WRITE_OVER:\n",
    "    os.mkdir(f\"/mnt/{MODEL_NAME}/{model_version}\")\n",
    "    \n",
    "print(f\"Saving Model to /mnt/{MODEL_NAME}/{model_version}/xgboost.model\")\n",
    "best_model.save_model(f\"/mnt/{MODEL_NAME}/{model_version}/xgboost.model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30d7c971-dbae-49dd-b386-ad91f006b6ea",
   "metadata": {},
   "source": [
    "After running hyperparameter optimization for both models, we can view the results of the trials at [this link](https://mlflow.software-dev.ncsa.cloud/#/experiments/10/s?searchInput=&orderByKey=metrics.%60avg_test_roc_auc%60&orderByAsc=false&startTime=ALL&lifecycleFilter=Active&modelVersionFilter=All%20Runs&showMultiColumns=true&categorizedUncheckedKeys%5Battributes%5D%5B0%5D=&categorizedUncheckedKeys%5Bparams%5D%5B0%5D=&categorizedUncheckedKeys%5Bmetrics%5D%5B0%5D=&categorizedUncheckedKeys%5Btags%5D%5B0%5D=&diffSwitchSelected=false&preSwitchCategorizedUncheckedKeys%5Battributes%5D%5B0%5D=&preSwitchCategorizedUncheckedKeys%5Bparams%5D%5B0%5D=&preSwitchCategorizedUncheckedKeys%5Bmetrics%5D%5B0%5D=&preSwitchCategorizedUncheckedKeys%5Btags%5D%5B0%5D=&postSwitchCategorizedUncheckedKeys%5Battributes%5D%5B0%5D=&postSwitchCategorizedUncheckedKeys%5Bparams%5D%5B0%5D=&postSwitchCategorizedUncheckedKeys%5Bmetrics%5D%5B0%5D=&postSwitchCategorizedUncheckedKeys%5Btags%5D%5B0%5D=). The best models can be seen at the top of the list with links to their associated registered models."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93aa7192-4706-44f9-aecd-a2c3e93004fc",
   "metadata": {},
   "source": [
    "___\n",
    "### Create Triton config file for our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "a8ade1fd-801e-49f3-8f22-f0538939d1ab",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: \"sigbkg_bdt\"\n",
      "backend: \"fil\"\n",
      "max_batch_size: 500000\n",
      "input [\n",
      " {\n",
      "    name: \"input__0\"\n",
      "    data_type: TYPE_FP32\n",
      "    dims: [ 10 ]\n",
      "  }\n",
      "]\n",
      "output [\n",
      " {\n",
      "    name: \"output__0\"\n",
      "    data_type: TYPE_FP32\n",
      "    dims: [ 2 ]\n",
      "  }\n",
      " \n",
      "]\n",
      "instance_group [{ kind: KIND_GPU }]\n",
      "parameters [\n",
      "  {\n",
      "    key: \"model_type\"\n",
      "    value: { string_value: \"xgboost\" }\n",
      "  },\n",
      "  {\n",
      "    key: \"predict_proba\"\n",
      "    value: { string_value: \"true\" }\n",
      "  },\n",
      "  {\n",
      "    key: \"output_class\"\n",
      "    value: { string_value: \"true\" }\n",
      "  },\n",
      "  {\n",
      "    key: \"threshold\"\n",
      "    value: { string_value: \"0.5\" }\n",
      "  },\n",
      "  {\n",
      "    key: \"algo\"\n",
      "    value: { string_value: \"ALGO_AUTO\" }\n",
      "  },\n",
      "  {\n",
      "    key: \"storage_type\"\n",
      "    value: { string_value: \"AUTO\" }\n",
      "  },\n",
      "  {\n",
      "    key: \"blocks_per_sm\"\n",
      "    value: { string_value: \"0\" }\n",
      "  }\n",
      "]\n",
      "\n",
      "dynamic_batching { }\n"
     ]
    }
   ],
   "source": [
    "config_txt = utils.generate_triton_config(MODEL_NAME, features_even.shape[1], predict_proba=True)\n",
    "print(config_txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "dba8851f-b7f9-4073-860d-06e83f183c54",
   "metadata": {},
   "outputs": [],
   "source": [
    "# save config file \n",
    "with open(f'/mnt/{MODEL_NAME}/config.pbtxt', 'w') as the_file:\n",
    "    the_file.write(config_txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b439dde3-f360-4b9d-ad98-91aab151c2cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['3', '2', '4', 'config.pbtxt', '1']\n"
     ]
    }
   ],
   "source": [
    "# print contents of triton server model directory\n",
    "print(os.listdir(f\"/mnt/{MODEL_NAME}\"))"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,py:percent"
  },
  "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.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}