binary_classifier_client.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2cd74d65-2b7e-48b7-a7ec-cd0ba4fc748d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "import uproot\n",
    "import hist\n",
    "import awkward as ak\n",
    "\n",
    "import tritonclient.grpc as grpcclient\n",
    "from tritonclient.utils import InferenceServerException\n",
    "\n",
    "from coffea import processor\n",
    "from coffea.nanoevents.schemas.base import BaseSchema, zip_forms\n",
    "from coffea.nanoevents.methods import base"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5bcce89-f41e-4db2-8b07-e305595350a2",
   "metadata": {},
   "source": [
    "# DEMO: First steps using Triton inference server at coffea-casa facility\n",
    "__________\n",
    "\n",
    "To demonstrate the current functionality of inference with Triton at the coffea-casa OD facility, a simple example was developed. Toy \"events\", each with four randomly generated observables, were created from signal and background classes. The comparison of background and signal distributions can be seen below:\n",
    "![alt text](images/toydata_truth.png \"Histograms of Toy Data Variables\")\n",
    "\n",
    "This data was used to train a simple neural network in PyTorch to classify an event as either signal or background, when given the four input variables. The architecture of this network is shown below. With this simple model architecture, the network achieves around 97\\% accuracy.\n",
    "![alt text](images/binary_classifier.png \"Neural Network Architecture\")\n",
    "\n",
    "In order to use this PyTorch model for inference in the Triton server, there are a few steps that need to be taken.\n",
    "\n",
    "1. The model needs to be a ScriptModule (torch.jit.ScriptModule). This is an analog to torch.nn.Module and is a wrapper around C++. For simple models, such as the one used in this example, this can be done by the command `model = torch.jit.script(model)`.\n",
    "2. Save the model using `torch.jit.save`\n",
    "3. Create a directory for your model. For this facility, the directory should be placed in `/mnt`. The structure of the directory must be the following:\n",
    "```text\n",
    "        binary_classifier/\n",
    "        ├── 1\n",
    "        │   └── model.pt\n",
    "        └── config.pbtxt\n",
    "```\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The subdirectory `1` indicates the model version. You can have multiple versions. `1` contains the model file, which must be named `model.pt`, if using PyTorch.\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;You must also create the config file. The structure of the config file used in this example is printed below. Variable names must be of the form `var__i`, where `i` is an integer. The name of the model in the config file much match the name of the model directory.\n",
    "    \n",
    "    \n",
    "```\n",
    "name: \"binary_classifier\"\n",
    "platform: \"pytorch_libtorch\"\n",
    "max_batch_size: 0\n",
    "input [\n",
    "  {\n",
    "    name: \"x__0\"\n",
    "    data_type: TYPE_FP32\n",
    "    dims: [ -1, 4 ]\n",
    "  }\n",
    "]\n",
    "output [\n",
    "  {\n",
    "    name: \"logits__0\"\n",
    "    data_type: TYPE_FP32\n",
    "    dims: [ -1, 1  ]\n",
    "  }\n",
    "]\n",
    "\n",
    "dynamic_batching {}\n",
    "```\n",
    "4. You can check if the model is loaded by running `curl agc-triton-inference-server:8000/v2/models/{model_name}/config`. Let's check if our model is loaded:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "edfdc106-7e6e-4d07-9668-efc7cd38cf29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "curl: /opt/conda/lib/libcurl.so.4: no version information available (required by curl)\n",
      "*   Trying 192.168.41.89:8000...\n",
      "* Connected to agc-triton-inference-server (192.168.41.89) port 8000 (#0)\n",
      "> GET /v2/models/binary_classifier/config HTTP/1.1\n",
      "> Host: agc-triton-inference-server:8000\n",
      "> User-Agent: curl/7.68.0\n",
      "> Accept: */*\n",
      "> \n",
      "* Mark bundle as not supporting multiuse\n",
      "< HTTP/1.1 200 OK\n",
      "< Content-Type: application/json\n",
      "< Content-Length: 1077\n",
      "< \n",
      "{\"name\":\"binary_classifier\",\"platform\":\"pytorch_libtorch\",\"backend\":\"pytorch\",\"version_policy\":{\"latest\":{\"num_versions\":1}},\"max_batch_size\":0,\"input\":[{\"name\":\"x__0\",\"data_type\":\"TYPE_FP32\",\"format\":\"FORMAT_NONE\",\"dims\":[-1,4],\"is_shape_tensor\":false,\"allow_ragged_batch\":false,\"optional\":false}],\"output\":[{\"name\":\"logits__0\",\"data_type\":\"TYPE_FP32\",\"dims\":[-1,1],\"label_filename\":\"\",\"is_shape_tensor\":false}],\"batch_input\":[],\"batch_output\":[],\"optimization\":{\"priority\":\"PRIORITY_DEFAULT\",\"input_pinned_memory\":{\"enable\":true},\"output_pinned_memory\":{\"enable\":true},\"gather_kernel_buffer_threshold\":0,\"eager_batching\":false},\"dynamic_batching\":{\"preferred_batch_size\":[],\"max_queue_delay_microseconds\":0,\"preserve_ordering\":false,\"priority_levels\":0,\"default_priority_level\":0,\"priority_queue_policy\":{}},\"instance_group\":[{\"name\":\"binary_classifier\",\"kind\":\"KIND_GPU\",\"count\":1,\"gpus\":[0],\"secondary_devices\":[],\"profile\":[],\"passive\":false,\"host_policy\":\"\"}],\"default_model_filename\":\"model.pt\",\"cc_model_filenames\":{* Connection #0 to host agc-triton-inference-server left intact\n",
      "},\"metric_tags\":{},\"parameters\":{},\"model_warmup\":[]}"
     ]
    }
   ],
   "source": [
    "!curl -v agc-triton-inference-server:8000/v2/models/binary_classifier/config"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c1f19c6-7685-4bc6-a59f-9e4290ee393a",
   "metadata": {},
   "source": [
    "________\n",
    "If you see `{\"error\":\"Request for unknown model: 'binary_classifier' has no available versions\"}`, the model needs to be loaded. You can load or unload models from the inference server using the following commands:\n",
    "\n",
    "* Note: Loading/unloading models in this way may not work at the moment, so be careful!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "af980843-47b4-47c3-91b2-86033f0dab96",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!curl -v -X POST agc-triton-inference-server:8000/v2/repository/models/binary_classifier/unload\n",
    "#!curl -v -X POST agc-triton-inference-server:8000/v2/repository/models/binary_classifier/load"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b99f684f-f3a5-472b-a9be-8f3fd3f059e6",
   "metadata": {},
   "source": [
    "Now that we know the model is loaded, we can start setting up to perform inference!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3a78a21d-daf6-4884-afca-9c6c65d36e23",
   "metadata": {},
   "outputs": [],
   "source": [
    "# options for triton inference server\n",
    "verbose     = False # enable verbose output for grpcclient\n",
    "url         = \"agc-triton-inference-server:8001\" # url of inference server. use 8001 for grpcclient and 8000 for httpclient\n",
    "model_name  = \"binary_classifier\" # name of ML model to use (make sure it is loaded properly)\n",
    "model_vers  = \"\" # specify model version if necessary\n",
    "\n",
    "# options for coffea\n",
    "num_cores   = 4 # scaling for setup with FuturesExecutor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70a8cd85-9524-4031-aa8e-b584666cdbc0",
   "metadata": {},
   "source": [
    "## Defining coffea processor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "744c9564-9157-4fcb-ac90-474f570a7b77",
   "metadata": {},
   "outputs": [],
   "source": [
    "processor_base = processor.ProcessorABC\n",
    "\n",
    "class SigBkgInference(processor_base):\n",
    "    \n",
    "    def __init__(self, model_name, model_vers, url, verbose):\n",
    "        \n",
    "        # histogram to store event variables and inference results\n",
    "        self.hist = (hist.Hist.new.Reg(50, -7, 7, name=\"var0\", label=\"Variable 0\")\n",
    "                     .Reg(50, -45, 5, name=\"var1\", label=\"Variable 1\")\n",
    "                     .Reg(50, 0, 15, name=\"var2\", label=\"Variable 2\")\n",
    "                     .IntCat(range(2), name=\"classification\", label=\"ML Classification (Sig/Bkg)\")\n",
    "                     .Weight())\n",
    "        \n",
    "        # model information\n",
    "        self.model_name = model_name\n",
    "        self.model_vers = model_vers\n",
    "        self.url = url\n",
    "        self.verbose = verbose\n",
    "        \n",
    "    def process(self, events):\n",
    "        \n",
    "        histogram = self.hist.copy()\n",
    "        \n",
    "        # concatenate event variables (for input into neural network)\n",
    "        features = np.vstack((events.var0, \n",
    "                              events.var1, \n",
    "                              events.var2, \n",
    "                              events.var3)).to_numpy().T.astype(np.float32)\n",
    "        \n",
    "        # create gRPC client (communicates with inference server)\n",
    "        triton_client = grpcclient.InferenceServerClient(url=self.url, verbose=self.verbose)\n",
    "        \n",
    "        # get model info\n",
    "        model_metadata = triton_client.get_model_metadata(self.model_name, self.model_vers)\n",
    "        input_name = model_metadata.inputs[0].name\n",
    "        dtype = model_metadata.inputs[0].datatype\n",
    "        output_name = model_metadata.outputs[0].name\n",
    "        \n",
    "        # configure and set inputs\n",
    "        client = grpcclient\n",
    "        inpt = [client.InferInput(input_name, features.shape, dtype)]\n",
    "        inpt[0].set_data_from_numpy(features)\n",
    "        \n",
    "        # configure output\n",
    "        output = client.InferRequestedOutput(output_name)\n",
    "        \n",
    "        # inference request (uses dynamic batching)\n",
    "        results = triton_client.infer(model_name=self.model_name, \n",
    "                                      inputs=inpt, \n",
    "                                      outputs=[output]).as_numpy(output_name)\n",
    "        \n",
    "        # round results to nearest integer and reshape\n",
    "        classification = np.round(results).T[0].astype(int).tolist()\n",
    "        \n",
    "        triton_client.close() # close client\n",
    "        \n",
    "        # fill histogram\n",
    "        histogram.fill(var0=events.var0, \n",
    "                       var1=events.var1, \n",
    "                       var2=events.var2, \n",
    "                       classification=classification)\n",
    "            \n",
    "        output = {\"nevents\": {events.metadata[\"dataset\"]: features.shape[0]}, \n",
    "                  \"hist\": histogram}\n",
    "\n",
    "        return output\n",
    "\n",
    "    def postprocess(self, accumulator):\n",
    "        return accumulator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "551946c9-584f-4ea6-bbcb-e67e2741da08",
   "metadata": {},
   "source": [
    "## Defining schema to load toy data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5bc83ee1-d699-43d8-b283-a0b6ee78ed02",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ToySchema(BaseSchema):\n",
    "    \n",
    "    def _build_collections(self, branch_forms):\n",
    "        names = [\"var0\", \"var1\", \"var2\", \"var3\"]\n",
    "        \n",
    "        output = {}\n",
    "        for name in names:\n",
    "            output[name] = branch_forms[name]\n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f93efbb2-ec2c-4da7-bc9b-1c949ee5ab6e",
   "metadata": {},
   "source": [
    "## Process events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d4ef92e8-02ac-4173-9d31-ebc6a32082eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# paths to files\n",
    "fileset = {'process0': {'files': ['data/testdata0.root',\n",
    "                                  'data/testdata1.root',\n",
    "                                  'data/testdata2.root',\n",
    "                                  'data/testdata3.root',\n",
    "                                  'data/testdata4.root',\n",
    "                                  'data/testdata5.root',\n",
    "                                  'data/testdata6.root',\n",
    "                                  'data/testdata7.root',\n",
    "                                  'data/testdata8.root',\n",
    "                                  'data/testdata9.root'],\n",
    "                        'nevts': 10*20000}\n",
    "          }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0df5d82d-1f7e-4d1d-a379-8e5d40998be8",
   "metadata": {},
   "outputs": [],
   "source": [
    "executor = processor.FuturesExecutor(workers=num_cores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2b212c1d-c2be-4aa4-afc6-947de6dbc6e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "run = processor.Runner(executor=executor, \n",
    "                       schema=ToySchema, \n",
    "                       savemetrics=True, \n",
    "                       metadata_cache={}, \n",
    "                       chunksize=500_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a12333aa-427b-40bd-a1f5-7dd3e0074e30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": [
       "\u001b[?25l"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "de09c67d168b4be6976107ed504d889a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n",
       "\u001b[?25h"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "filemeta = run.preprocess(fileset, treename=\"events\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1e0bb224-6732-46fa-8144-1a576ed1f673",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
      ],
      "text/plain": [
       "\u001b[?25l"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "363e6877264c40a78c472bec0747c3f9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\n",
       "\u001b[?25h"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_histograms, metrics = run(fileset, \n",
    "                              \"events\", \n",
    "                              processor_instance=SigBkgInference(model_name, \n",
    "                                                                 model_vers, \n",
    "                                                                 url, \n",
    "                                                                 verbose)\n",
    "                             )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0a04a755-3f74-4ebb-8fe6-7c16a17b1b9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "04736c6e-4411-48a6-ae32-2c0414bf52bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hist(\n",
       "  Regular(50, -7, 7, name='var0', label='Variable 0'),\n",
       "  Regular(50, -45, 5, name='var1', label='Variable 1'),\n",
       "  Regular(50, 0, 15, name='var2', label='Variable 2'),\n",
       "  IntCategory([0, 1], name='classification', label='ML Classification (Sig/Bkg)'),\n",
       "  storage=Weight()) # Sum: WeightedSum(value=199932, variance=199932) (WeightedSum(value=200000, variance=200000) with flow)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_histograms['hist']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e08c1544-2928-460f-bd9d-ca33418a20e9",
   "metadata": {},
   "source": [
    "## Now we can histogram the variables by predicted class! (Signal or Background)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "220b6869-49be-448d-a347-dbfa0d8786e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_histograms['hist'].project(\"classification\", \"var0\").plot(density=True)\n",
    "plt.legend([\"Predicted as Signal\",\"Predicted as Background\"])\n",
    "plt.ylabel(\"Density\")\n",
    "plt.show()\n",
    "all_histograms['hist'].project(\"classification\", \"var1\").plot(density=True)\n",
    "plt.legend([\"Predicted as Signal\",\"Predicted as Background\"])\n",
    "plt.ylabel(\"Density\")\n",
    "plt.show()\n",
    "all_histograms['hist'].project(\"classification\", \"var2\").plot(density=True)\n",
    "plt.legend([\"Predicted as Signal\",\"Predicted as Background\"])\n",
    "plt.ylabel(\"Density\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69a61e06-d8b2-4f09-a755-81fabb1a6eac",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e550c03-0bba-4be2-905e-43b1ef188f1b",
   "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.8.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}