{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Running inference tools\n", "\n", "This is a rendered copy of [ml_tools.ipynb](https://github.com/scikit-hep/coffea/blob/master/binder/ml_tools.ipynb). You can optionally run it interactively on [binder at this link](https://mybinder.org/v2/gh/coffeateam/coffea/master?filepath=binder%2Fml_tools.ipynb)\n", "\n", "As machine learning (ML) becomes more popular in HEP analysis, `coffea` also\n", "provide tools to assist with using ML tools within the `coffea` framework. For\n", "training and validation, you would likely need custom data mangling tools to\n", "convert HEP data formats ([NanoAOD][nanoaod], [PFNano][pfnano]) to a format that\n", "best interfaces with the ML tool of choice, as for training and validation, you\n", "typical want to have fine control over what computation is done. For more\n", "advanced use cases of data mangling and data saving, refer to the [awkward array\n", "manual][datamangle] and [uproot][uproot_write]/[parquet][ak_parquet] write\n", "operations for saving intermediate states. The helper tools provided in coffea\n", "focuses on ML inference, where ML tool outputs are used as another variable to\n", "be used in the event/object selection chain.\n", "\n", "[nanoaod]: https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookNanoAOD\n", "[pfnano]: https://github.com/cms-jet/PFNano\n", "[datamangle]: https://awkward-array.org/doc/main/user-guide/how-to-restructure.html\n", "[uproot_write]: https://uproot.readthedocs.io/en/latest/basic.html#writing-ttrees-to-a-file\n", "[ak_parquet]: https://awkward-array.org/doc/main/reference/generated/ak.to_parquet.html\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Why these wrapper tools are needed\n", "\n", "### Warning: This notebook is only relevant if you are using coffea in \"dask\" mode with dask-awkward\n", "\n", "The typical operation of using ML inference tools in the awkward/coffea analysis\n", "tools involves the conversion and padding of awkward array to ML tool containers\n", "(usually something that is `numpy`-compatible), run the inference, then\n", "convert-and-truncate back into the awkward array syntax required for the\n", "analysis chain to continue. With awkward arrays' laziness now being handled\n", "entirely by [`dask`][dask_awkward], the conversion operation of awkward array to\n", "other array types needs to be wrapped in a way that is understandable to `dask`.\n", "The packages in the `ml_tools` package attempts to wrap the common tools used by\n", "the HEP community with a common interface to reduce the verbosity of the code on\n", "the analysis side.\n", "\n", "[dask_awkward]: https://dask-awkward.readthedocs.io/en/stable/gs-limitations.html\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Example using ParticleNet-like jet variable calculation using PyTorch (GNN)\n", "\n", "The example given in this notebook be using [`pytorch`][pytorch] to calculate a\n", "jet-level discriminant using its constituent particles. An example for how to\n", "construct such a `pytorch` network can be found in the docs file, but for\n", "`mltools` in coffea, we only support the [TorchScript][pytorch] format files to\n", "load models to ensure operability when scaling to clusters. Let us first start\n", "by downloading the example ParticleNet model file and a small `PFNano`\n", "compatible file, and a simple function to open the `PFNano` with and without\n", "dask.\n", "\n", "[pytorch]: https://pytorch.org/\n", "[pytorch_jit]: https://pytorch.org/tutorials/beginner/saving_loading_models.html#export-load-model-in-torchscript-format\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "!wget --quiet -O model.pt https://github.com/scikit-hep/coffea/raw/master/tests/samples/triton_models_test/pn_test/1/model.pt\n", "!wget --quiet -O pfnano.root https://github.com/scikit-hep/coffea/raw/master/tests/samples/pfnano.root" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from coffea.nanoevents import NanoEventsFactory\n", "from coffea.nanoevents.schemas import PFNanoAODSchema\n", "\n", "\n", "def open_events():\n", " factory = NanoEventsFactory.from_root(\n", " {\"file:./pfnano.root\": \"Events\"},\n", " schemaclass=PFNanoAODSchema,\n", " mode=\"dask\",\n", " )\n", " return factory.events()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Now we prepare a class to handle inference request by extending the\n", "`mltools.torch_wrapper` class. As the base class cannot know anything about the\n", "data mangling required for the users particular model, we will need to overload\n", "at least the method `prepare_awkward`:\n", "\n", "- The input can be an arbitrary number of awkward arrays or dask awkward array\n", " (but never a mix of dask/non-dask array). In this example, we will be passing\n", " in the event array.\n", "- The output should be single tuple `a` + single dictionary `b`, this is to\n", " ensure that arbitrarily complicated outputs can be passed to the underlying\n", " `pytorch` model instance like `model(*a, **b)`. The contents of `a` and `b`\n", " should be `numpy`-compatible awkward-like arrays: if the inputs are non-dask\n", " awkward arrays, the return should also be non-dask awkward arrays that can be\n", " trivially converted to `numpy` arrays via a `ak.to_numpy` call; if the inputs\n", " are dask awkward arrays, the return should be still be dask awkward arrays\n", " that can be trivially converted via a `to_awkward().to_numpy()` call.\n", "\n", " In this ParticleNet-like example, the model expects the following inputs:\n", "\n", " - A `N` jets x `2` coordinate x `100` constituents \"points\" array,\n", " representing the constituent coordinates.\n", " - A `N` jets x `5` feature x `100` constituents \"features\" array, representing\n", " the constituent features of interest to be used for inference.\n", " - A `N` jets x `1` mask x `100` constituent \"mask\" array, representing whether\n", " a constituent should be masked from the inference request.\n", "\n", " In this case, we will need to flatten the `E` events x `N` jets structure,\n", " then, we will need to stack the constituent attributes of interest via\n", " `ak.concatenate` into a single array.\n", "\n", "After defining this minimum class, we can attempt to run inference using the\n", "`__call__` method defined in the base class.\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2026-03-06 14:17:34.315771: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", "2026-03-06 14:17:34.439321: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", "2026-03-06 14:17:37.242603: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:283: RuntimeWarning: Missing cross-reference index for LowPtElectron_electronIdx => Electron\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:283: RuntimeWarning: Missing cross-reference index for LowPtElectron_genPartIdx => GenPart\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:283: RuntimeWarning: Missing cross-reference index for LowPtElectron_photonIdx => Photon\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:322: RuntimeWarning: Branch Photon_mass already exists but its values will be replaced with 0.0\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:322: RuntimeWarning: Branch Photon_charge already exists but its values will be replaced with 0.0\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/ml_tools/helper.py:175: UserWarning: No format checks were performed on input!\n", " warnings.warn(\"No format checks were performed on input!\")\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Dask awkward results: [[0.0693, -0.0448], [0.0678, -0.0451], ..., [0.0616, ...], [0.0587, -0.0172]]\n" ] } ], "source": [ "from coffea.ml_tools.torch_wrapper import torch_wrapper\n", "import awkward as ak\n", "import dask_awkward\n", "import numpy as np\n", "\n", "\n", "class ParticleNetExample1(torch_wrapper):\n", " def prepare_awkward(self, events):\n", " jets = ak.flatten(events.Jet)\n", "\n", " def pad(arr):\n", " return ak.fill_none(\n", " ak.pad_none(arr, 100, axis=1, clip=True),\n", " 0.0,\n", " )\n", "\n", " # Human readable version of what the inputs are\n", " # Each array is a N jets x 100 constituent array\n", " imap = {\n", " \"points\": {\n", " \"deta\": pad(jets.eta - jets.constituents.pf.eta),\n", " \"dphi\": pad(jets.delta_phi(jets.constituents.pf)),\n", " },\n", " \"features\": {\n", " \"dr\": pad(jets.delta_r(jets.constituents.pf)),\n", " \"lpt\": pad(np.log(jets.constituents.pf.pt)),\n", " \"lptf\": pad(np.log(jets.constituents.pf.pt / jets.pt)),\n", " \"f1\": pad(np.log(np.abs(jets.constituents.pf.d0) + 1)),\n", " \"f2\": pad(np.log(np.abs(jets.constituents.pf.dz) + 1)),\n", " },\n", " \"mask\": {\n", " \"mask\": pad(ak.ones_like(jets.constituents.pf.pt)),\n", " },\n", " }\n", "\n", " # Compacting the array elements into the desired dimension using\n", " # ak.concatenate\n", " retmap = {k: ak.concatenate([x[:, np.newaxis, :] for x in imap[k].values()], axis=1) for k in imap.keys()}\n", "\n", " # Returning everything using a dictionary. Also perform type conversion!\n", " return (), {\n", " \"points\": ak.values_astype(retmap[\"points\"], \"float32\"),\n", " \"features\": ak.values_astype(retmap[\"features\"], \"float32\"),\n", " \"mask\": ak.values_astype(retmap[\"mask\"], \"float16\"),\n", " }\n", "\n", "\n", "# Setting up the model container\n", "pn_example1 = ParticleNetExample1(\"model.pt\")\n", "\n", "# Running on dask_awkward array\n", "dask_events = open_events()\n", "dask_results = pn_example1(dask_events)\n", "print(\"Dask awkward results:\", dask_results.compute()) # Runs file!" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "For each jet in the input to the `torch` model, the model returns a 2-tuple\n", "probability value. Without additional specification, the `torch_wrapper` class\n", "performs a trival conversion of `ak.from_numpy` of the torch model's output. We\n", "can specify that we want to fold this back into nested structure by overloading\n", "the `postprocess_awkward` method of the class.\n", "\n", "For the ParticleNet example we are going perform additional computation for the\n", "conversion back to awkward array formats:\n", "\n", "- Calculate the `softmax` method for the return of each jet (commonly used as\n", " the singular ML inference \"scores\")\n", "- Fold the computed `softmax` array back into nested structure that is\n", " compatible with the original events.Jet array.\n", "\n", "Notice that the inputs of the `postprocess_awkward` method is different from the\n", "`prepare_awkward` method, only by that the first argument is the return array\n", "of the model inference after the trivial `from_numpy` conversion. Notice that\n", "the return_array is a dask array.\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/dask_awkward/lib/structure.py:910: UserWarning: Please ensure that dask.awkward\n", " is partitionwise-compatible with dask.awkward\n", " (e.g. counts comes from a dak.num(array, axis=1)),\n", " otherwise this unflatten operation will fail when computed!\n", " warnings.warn(f\"\"\"Please ensure that {counts}\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[[0.528, 0.528, 0.524, 0.523, 0.521, 0.52, 0.519, 0.519], ..., [0.528, ...]]\n" ] } ], "source": [ "class ParticleNetExample2(ParticleNetExample1):\n", " def postprocess_awkward(self, return_array, events):\n", " softmax = np.exp(return_array)[:, 0] / ak.sum(np.exp(return_array), axis=-1)\n", " njets = ak.count(events.Jet.pt, axis=-1)\n", " return ak.unflatten(softmax, njets)\n", "\n", "\n", "pn_example2 = ParticleNetExample2(\"model.pt\")\n", "\n", "# Running on dask awkward\n", "dask_events = open_events()\n", "dask_jets = dask_events.Jet\n", "dask_jets[\"MLresults\"] = pn_example2(dask_events)\n", "dask_events[\"Jet\"] = dask_jets\n", "print(dask_events.Jet.MLresults.compute())" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Of course, the implementation of the classes above can be written in a single\n", "class. Here is a copy-and-paste implementation of the class with all the\n", "functionality described in the cells above:\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0.528, 0.528, 0.524, 0.523, 0.521, 0.52, 0.519, 0.519], ..., [0.528, ...]]\n", "{'from-uproot-47eb709840fec52fd10150d70953b584': frozenset({'nJetPFCands', 'PFCands_eta', 'Jet_eta', 'JetPFCands_pFCandsIdx', 'PFCands_pt', 'nJet', 'Jet_nConstituents', 'PFCands_dz', 'nPFCands', 'Jet_pt', 'PFCands_d0', 'Jet_phi', 'PFCands_phi'})}\n" ] } ], "source": [ "class ParticleNetExample(torch_wrapper):\n", " def prepare_awkward(self, events):\n", " jets = ak.flatten(events.Jet)\n", "\n", " def pad(arr):\n", " return ak.fill_none(\n", " ak.pad_none(arr, 100, axis=1, clip=True),\n", " 0.0,\n", " )\n", "\n", " # Human readable version of what the inputs are\n", " # Each array is a N jets x 100 constituent array\n", " imap = {\n", " \"points\": {\n", " \"deta\": pad(jets.eta - jets.constituents.pf.eta),\n", " \"dphi\": pad(jets.delta_phi(jets.constituents.pf)),\n", " },\n", " \"features\": {\n", " \"dr\": pad(jets.delta_r(jets.constituents.pf)),\n", " \"lpt\": pad(np.log(jets.constituents.pf.pt)),\n", " \"lptf\": pad(np.log(jets.constituents.pf.pt / jets.pt)),\n", " \"f1\": pad(np.log(np.abs(jets.constituents.pf.d0) + 1)),\n", " \"f2\": pad(np.log(np.abs(jets.constituents.pf.dz) + 1)),\n", " },\n", " \"mask\": {\n", " \"mask\": pad(ak.ones_like(jets.constituents.pf.pt)),\n", " },\n", " }\n", "\n", " # Compacting the array elements into the desired dimension using\n", " # ak.concatenate\n", " retmap = {k: ak.concatenate([x[:, np.newaxis, :] for x in imap[k].values()], axis=1) for k in imap.keys()}\n", "\n", " # Returning everything using a dictionary. Also take care of type\n", " # conversion here.\n", " return (), {\n", " \"points\": ak.values_astype(retmap[\"points\"], \"float32\"),\n", " \"features\": ak.values_astype(retmap[\"features\"], \"float32\"),\n", " \"mask\": ak.values_astype(retmap[\"mask\"], \"float16\"),\n", " }\n", "\n", " def postprocess_awkward(self, return_array, events):\n", " softmax = np.exp(return_array)[:, 0] / ak.sum(np.exp(return_array), axis=-1)\n", " njets = ak.count(events.Jet.pt, axis=-1)\n", " return ak.unflatten(softmax, njets)\n", "\n", "\n", "pn_example = ParticleNetExample(\"model.pt\")\n", "\n", "# Running on dask awkward arrays\n", "dask_events = open_events()\n", "dask_jets = dask_events.Jet\n", "dask_jets[\"MLresults\"] = pn_example(dask_events)\n", "dask_events[\"Jet\"] = dask_jets\n", "print(dask_events.Jet.MLresults.compute())\n", "\n", "print(dask_awkward.necessary_columns(dask_events.Jet.MLresults))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "In particular, analyzers should check that the last line contains only the\n", "branches required for ML inference; if there are many non-required branches,\n", "this may lead the significant performance penalties. \n", "\n", "As per other dask tools, the users can extract how dask is analyzing the\n", "processing the computation routines using the following snippet." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "HighLevelGraph with 60 layers.\n", "\n", " 0. from-uproot-47eb709840fec52fd10150d70953b584\n", " 1. JetPFCands-93ce904d704e6b0eb3c3611bc8012f23\n", " 2. PFCands-a323ca705b8fb497fce02c20c48e0775\n", " 3. Jet-db85a47250c2b4ce6711ac6330a68642\n", " 4. flatten-4889a76665bf011ef8bfe5caf341a473\n", " 5. pt-a7f1f2e39a4683dcbf04ac86cd2b629a\n", " 6. pFCandsIdxG-1b2dc2381cac56c6fea27b4e6f80c7c9\n", " 7. apply-global-index-83c3596bb07c3af7deae8faffbaf988b\n", " 8. pFCandsIdxG-5497ab84ba195cc82f0c9faf0b3f5b45\n", " 9. apply-global-index-f580a120d51d493f2dad8c3d79ffea4d\n", " 10. dz-400ad7809b8ed1f44d54007c37369688\n", " 11. absolute-3e3dc92259671b9b6be671adf0256ce8\n", " 12. add-5ab2ed8482238618983c9440f356e267\n", " 13. log-bd0cfe7adc092da2616ac80138f7e5ac\n", " 14. pad-none-41c06a8d9bf83a4e367ecd8be1f6a263\n", " 15. fill-none-8fe2ee90aff2b5e0e40c2d01f0306ca5\n", " 16. getitem-3179aa4caeebe8231407f172df23f045\n", " 17. d0-e4607a28ac15162b31902690392abc77\n", " 18. absolute-fce9cff24d7e6d8f5c9aa86647211181\n", " 19. add-8c1592b6dc2c04daeff5bd42898ee640\n", " 20. log-e54e48a582a534962b32284866c59225\n", " 21. pad-none-36d2ae59ae6597ba9edf54e44b9d106a\n", " 22. fill-none-c3d089fa8dbf368fd82ec31f9f4dde26\n", " 23. getitem-e32d1fba54f123eefaf9246b21a5284a\n", " 24. pt-864f937fba16a8f51a852a09c6957e8e\n", " 25. ones-like-7d3e18113c42c2f7eb59ae893d2a0848\n", " 26. pad-none-5e44824da2ddf1b91b85a3c965cb5aca\n", " 27. fill-none-d446d0f7ab5d95f9f3db04b9fad75176\n", " 28. getitem-10444e5f75a23991561f8fee4de9d409\n", " 29. concatenate-axisgt0-3ad5a459a18b7b3babf732bee0525611\n", " 30. values-astype-4d50bc83bb403fcdd27a3b65d85c366a\n", " 31. divide-a1b156817cfe4d18ed46c178d8990709\n", " 32. log-4322e4e35c666e9caf144371a660a2c0\n", " 33. pad-none-848d3acd37fcb95a7032c0728e0bc2bd\n", " 34. fill-none-3e8e46a7126043a2048c736586559c88\n", " 35. getitem-a6f40f0490cce2d1b36e08756aa0986f\n", " 36. log-71fa712a521459f78a0a5a52f6c4caeb\n", " 37. pad-none-3b2e4b992e560a86310288d920ee5760\n", " 38. fill-none-6b50927204b3005ce962629607402e99\n", " 39. getitem-bc6f2264e356f598c4c11d4a8924ee49\n", " 40. delta-r-d01755278d68edb56dd7a8864f08c41f\n", " 41. pad-none-a83bf4800e55a6a0f87d78c6a1c20734\n", " 42. fill-none-65a2907dfa66e4d2d622adbc472a0c5c\n", " 43. getitem-a3cd291794ae4faad32e98092256f92b\n", " 44. concatenate-axisgt0-52dbd7f985f805d6e4a04104b92ff501\n", " 45. values-astype-71dfe331418a143b2170cdb31d6f461f\n", " 46. delta-phi-5d132804c871d61779a862ecd457e589\n", " 47. pad-none-d57ed00997cd78d1dc855e97cd994c08\n", " 48. fill-none-70b40e432c084a4f37f17c730ebcb622\n", " 49. getitem-03692ccd8cef35e8e1595dcdf6eae807\n", " 50. eta-eec42bdafe9dfffc8150485b6c12ffba\n", " 51. eta-76779e358379066553c007ca945b02ae\n", " 52. subtract-78dc570ad02bf35a5cb1817f625d77a8\n", " 53. pad-none-39014f00546a913375d0321b8069cb9c\n", " 54. fill-none-9b9efb8edb88e140f552c9088f72b01c\n", " 55. getitem-9ced049f137c1e8e108441c6e69fe162\n", " 56. concatenate-axisgt0-2ff28f8af0e7ac95e5cd1d37eac9ba0d\n", " 57. values-astype-13cbf019732fdb2439111c65f031e111\n", " 58. ParticleNetExample1-124b2dc1-cb2f-4ea7-95ad-65b9e746bbee\n", " 59. numpy-call-ParticleNetExample1-5dd0e5f80a2d9d05623cc83aec76c3d2\n", "\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(dask_results.dask)\n", "dask_results.visualize(optimize_graph=False)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Or a peek at the optimized results:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/ml_tools/helper.py:175: UserWarning: No format checks were performed on input!\n", " warnings.warn(\"No format checks were performed on input!\")\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dask_results.visualize(optimize_graph=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example using ParticleNet-like jet variable calculation using PyTorch (DNN)\n", "\n", "In this example, we will do the same operation as shown above, but using a simple vanilla DNN" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "\n", "\"\"\"\n", "Define the DNN\n", "\"\"\"\n", "class Net(nn.Module):\n", " def __init__(self, input_shape):\n", " super(Net, self).__init__()\n", " self.fc1 = nn.Linear(input_shape, 128)\n", " self.bn1 = nn.BatchNorm1d(128)\n", " self.dropout1 = nn.Dropout(0.2)\n", " self.fc2 = nn.Linear(128, 64)\n", " self.bn2 = nn.BatchNorm1d(64)\n", " self.dropout2 = nn.Dropout(0.2)\n", " self.fc3 = nn.Linear(64, 32)\n", " self.bn3 = nn.BatchNorm1d(32)\n", " self.dropout3 = nn.Dropout(0.2)\n", " self.output = nn.Linear(32, 1)\n", "\n", " def forward(self, features):\n", " x = features\n", " x = self.fc1(x)\n", " x = self.bn1(x)\n", " x = F.tanh(x)\n", " x = self.dropout1(x)\n", "\n", " x = self.fc2(x)\n", " x = self.bn2(x)\n", " x = F.tanh(x)\n", " x = self.dropout2(x)\n", "\n", " x = self.fc3(x)\n", " x = self.bn3(x)\n", " x = F.tanh(x)\n", " x = self.dropout3(x)\n", "\n", " x = self.output(x)\n", " output = F.sigmoid(x)\n", " return output" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "\"\"\"\n", "Initialize and save the DNN. Normally, we would first train the DNN before saving.\n", "\"\"\"\n", "n_feat = 5\n", "dummy_integer = 100\n", "model = Net(n_feat)\n", "model.eval() # put in eval mode for BatchNorm1d and Dropout\n", "input_arr = torch.rand(dummy_integer, n_feat) # intialize a dummy input to generate torch graph for torch.jit to trace\n", "torch.jit.trace(model, input_arr).save(\"test_model.pt\")" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:283: RuntimeWarning: Missing cross-reference index for LowPtElectron_electronIdx => Electron\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:283: RuntimeWarning: Missing cross-reference index for LowPtElectron_genPartIdx => GenPart\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:283: RuntimeWarning: Missing cross-reference index for LowPtElectron_photonIdx => Photon\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:322: RuntimeWarning: Branch Photon_mass already exists but its values will be replaced with 0.0\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/nanoevents/schemas/nanoaod.py:322: RuntimeWarning: Branch Photon_charge already exists but its values will be replaced with 0.0\n", " warnings.warn(\n", "/home/user/.conda/envs/pyhep-dev/lib/python3.13/site-packages/coffea/ml_tools/helper.py:175: UserWarning: No format checks were performed on input!\n", " warnings.warn(\"No format checks were performed on input!\")\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "dask.awkward\n", "coffea DNN output: [[0.575], [0.575], [0.575], [0.575], ..., [0.575], [0.575], [0.575], [0.576]]\n" ] } ], "source": [ "from coffea.ml_tools.torch_wrapper import torch_wrapper\n", "\n", "\n", "def open_events():\n", " factory = NanoEventsFactory.from_root(\n", " {\"file:./pfnano.root\": \"Events\"},\n", " schemaclass=PFNanoAODSchema,\n", " mode=\"dask\",\n", " )\n", " return factory.events()\n", "\n", "\n", "class DNNWrapper(torch_wrapper):\n", " def prepare_awkward(self, arr):\n", " # The input is any awkward array with matching dimension\n", " # Last time we added our input in a dictionary, but with a simple DNN, just add it to a list\n", " return [\n", " ak.values_astype(arr, \"float32\"), # only modification we do is is force float32\n", " ], {}\n", "\n", "\n", "events = open_events()\n", "input = ak.concatenate( # Fold 5 event-level variables into a singular array\n", " [\n", " events.event[:, np.newaxis],\n", " events.MET.sumEt[:, np.newaxis],\n", " events.MET.significance[:, np.newaxis],\n", " events.event[:, np.newaxis],\n", " events.event[:, np.newaxis],\n", " ],\n", " axis=1,\n", ")\n", "dwrap = DNNWrapper(\"test_model.pt\")\n", "output = dwrap(input)\n", "print(output) # This is the lazy evaluated dask array! Use this directly for histogram filling\n", "print(f\"coffea DNN output: {output.compute()}\") # Eagerly evaluated resut" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "normal DNN output: [[0.57533765]\n", " [0.57533765]\n", " [0.57533765]\n", " [0.57533765]\n", " [0.57533765]\n", " [0.57533765]\n", " [0.57533765]\n", " [0.57533765]\n", " [0.57533765]\n", " [0.57593334]]\n" ] } ], "source": [ "\"\"\"\n", "Sanity check that the DNN wrapper is giving the same outputs\n", "\"\"\"\n", "test_input = torch.from_numpy(ak.to_numpy(input.compute())).float()\n", "print(f\"normal DNN output: {model(test_input).detach().numpy()}\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Comments about generalizing to other ML tools\n", "\n", "All ML wrappers provided in the `coffea.mltools` module (`triton_wrapper` for\n", "[triton][triton] server inference, `torch_wrapper` for pytorch,\n", "`xgboost_wrapper` for [xgboost][xgboost] inference, `tf_wrapper` for tensorflow) \n", "follow the same design: analyzers is responsible for providing the model of \n", "interest, along with providing an inherited class that overloads of the following\n", "methods to data type conversion:\n", "\n", "- `prepare_awkward`: converting awkward arrays to `numpy`-compatible awkward\n", " arrays, the output arrays should be in the format of a tuple `a` and a\n", " dictionary `b`, which can be expanded out to the input of the ML tool like\n", " `model(*a, **b)`. Notice some additional trivial conversion, such as the\n", " conversion to available kernels for `pytorch`, converting to a matrix format\n", " for `xgboost`, and slice of array for `triton` is handled automatically by the\n", " respective wrappers.\n", "- `postprocess_awkward` (optional): converting the trivial converted numpy array\n", " results back to the analysis specific format. If this is not provided, then a\n", " simple `ak.from_numpy` conversion results is returned.\n", "\n", "If the ML tool of choice for your analysis has not been implemented by the\n", "`coffea.mltools` modules, consider constructing your own with the provided\n", "`numpy_call_wrapper` base class in `coffea.mltools`. Aside from the functions\n", "listed above, you will also need to provide the `numpy_call` method to perform\n", "any additional data format conversions, and call the ML tool of choice. If you\n", "think your implementation is general, also consider submitting a PR to the\n", "`coffea` repository!\n", "\n", "[triton]: https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver\n", "[xgboost]: https://xgboost.readthedocs.io/en/stable/\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Additional comments on common `prepare_awkward` patterns\n", "\n", "The key requirement of all wrapper classes in `ml_tools` package, is that to convert\n", "awkward arrays into `numpy`-compatible formats using just `awkward` related tools, \n", "which ensures that no eager data conversion is performed on dask arrays. Below are\n", "some common patterns that are useful when defining a user-level class." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Casting multiple fields a collection to be separate axis\n", "\n", "Given our collection of particles of length $N$, our tool is interested in just a \n", "subset of fields is to be represented as an $N\\times M$ array. You can achieve this \n", "using just `ak.concatenate` and dimension expansion with `np.newaxis`." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[60.9, 504, 14.2], [51, 1.23e+03, 35.8], ..., [167, ...], [30.8, 260, 37.6]] 10 * 3 * float32\n" ] } ], "source": [ "events = open_events().compute() # Using eagar array as example\n", "fields_of_interest = [\"MET\", \"TkMET\", \"RawMET\"] # Example of using 3 MET pt values types as a single input \n", "event_np_array = ak.concatenate(\n", " [\n", " events[field].pt[:,np.newaxis] # Expanding length N array to Nx1\n", " for field in fields_of_interest\n", " ],\n", " axis=1,\n", ") # This should now be a Nx3 array\n", "print(event_np_array, event_np_array.type)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fixing collection dimensions\n", "\n", "Many ML inference tools work with fixed dimension inputs, with missing entries \n", "being set to a placeholder values. A common method for achieving this in awkward\n", "is with `pad_none`/`fill_none` calls, for example to pad the number of particles\n", "passed to the inference tool in each event to be a fixed length of 64. Notice\n", "that elements beyond the bad length would be truncated." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1.68e+03, 1.41e+03, 298, 85.9, ..., -1e+03, -1e+03, -1e+03, -1e+03], ...] 10 * 64 * float64\n" ] } ], "source": [ "part_padded = ak.fill_none(\n", " ak.pad_none(events.Jet.pt, 64, axis=1, clip=True),\n", " -1000, # Placeholder value\n", " axis=1,\n", ")\n", "print(part_padded, part_padded.type)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Fixing `None`-able arrays\n", "\n", "When input arrays are computed using certain awkward array methods, arrays may be\n", "reserved to allow for `None` values, even if the actual data cannot contain `None`.\n", "For example, when using `ak.firsts` to extract the leading jet pt of events, because\n", "the awkward function itself has no knowledge of the actual number of jets in each\n", "event, it will need to reserve the return array as potentially containing `None`,\n", "even if the analyzer has enforced via prior event selections or event skimming\n", "such that `None` values are not possible." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5 * ?float32[parameters={\"__doc__\": \"pt\", \"typename\": \"float[]\"}] [1.68e+03, 1.61e+03, 1.68e+03, 1.52e+03, 1.6e+03]\n" ] } ], "source": [ "# Taking the leading jet of the first 5 events\n", "leading_jet = ak.firsts(events.Jet)[:5]\n", "# Notice the none-able type of the array indicated as ?float32, despite all\n", "# values being not None.\n", "print(leading_jet.pt.type, leading_jet.pt) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These arrays are not always compatible with the wrapped tool provided in the \n", "`ml_tools` package. The error that is generated by the wrapped tool when it \n", "encounters a `None`-able array is, unfortunately, also not very descriptive, usually\n", "a long stacktrace that ends with something like:\n", "\n", "```\n", "File \".../site-packages/awkward/_nplikes/array_module.py\", line 85, in frombuffer\n", " return self._module.frombuffer(buffer, dtype=dtype, count=count)\n", "ValueError: buffer is smaller than requested size\n", "```\n", "\n", "To fix such errors, one can either use the `ak.fill_none` method mentioned in the \n", "previous section to enforce the return array never contains `None` values, or use\n", "the `ak.enforce_type` method, which can also be used to cast arrays to a specific \n", "type or floating point precision:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "fill_none: 10 * float64\n", "enforce_type: 10 * float32\n" ] } ], "source": [ "print(\"fill_none:\", ak.fill_none(ak.firsts(events.Jet.pt), -1 ).type)\n", "print(\"enforce_type:\", ak.enforce_type(ak.firsts(events.Jet.pt), \"float32\").type)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Length-zero arrays\n", "\n", "In HEP analysis, a common routine will have you working with length-zero array in\n", "individual chunks (ex. when running the primarily selection workflow for background\n", "events). In these cases, you need to make sure the inference library that you are \n", "using behaves as expected when processing length-zero arrays. Ideally, all the\n", "upstream libraries should handle length-zero arrays correct, but in the edges cases\n", "where your model using a more exotic functions is causing issues, the wrappings in the\n", "`ml_tools` package has some mechanisms that can help handle such situations:\n", "\n", "- `tf_wrapper/tensorflow`: the `skip_length_zero` flag can be passed to the `tf_wrapper` \n", " constructor. When this is set to `True`, when a length-0 array is detected to be the input, \n", " the wrapper will generate a length 0 numpy array instead of attempting to pass the \n", " input for inference.\n", "- `torch_wrapper/pytorch`: as the output format of `pytorch` models is difficult to \n", " implement detect at runtime without additional input, if you need to skip length-zero\n", " inputs, the analysts must provide the shape of the output in the `expected_output_shape` \n", " argument of the `torch_wrapper` constructor. Notice that the shape should be in the\n", " format of the `numpy.array.shape` output of nominal return values, with the first\n", " argument substituted to be a `None` to indicate arbitrary length.\n", "- `triton_wrapper/triton`: Length-zero is handled automatically by the internal batching\n", " process. No additional user input is required.\n", "- `xgboost_wrapper/xgboost`: Length-zero should always be handled by the underlying \n", " `xgboost` library. No additional user input is required." ] } ], "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.13.3" } }, "nbformat": 4, "nbformat_minor": 4 }