{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "df569247", "metadata": {}, "outputs": [], "source": [ "import json\n", "import math\n", "import random\n", "import os\n", "import pickle as pkl\n", "import time\n", "from typing import Dict, List\n", "\n", "import awkward as ak\n", "import fastjet\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import mplhep as hep\n", "import numpy as np\n", "import sklearn\n", "import sklearn.metrics\n", "import torch\n", "import tqdm\n", "import vector\n", "from torch_geometric.data import Batch, Data\n", "\n", "plt.style.use(hep.style.CMS)\n", "plt.rcParams.update({\"font.size\": 20})" ] }, { "cell_type": "code", "execution_count": 2, "id": "edf87dc8", "metadata": {}, "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2" ] }, { "cell_type": "code", "execution_count": 8, "id": "16ca6a3a", "metadata": {}, "outputs": [], "source": [ "# import relevant functions from mlpf.pyg\n", "import sys\n", "sys.path.append(\"/home/jovyan/particleflow/mlpf/\")\n", "import pyg\n", "sys.path.append(\"/home/jovyan/particleflow/mlpf/pyg/\")\n", "import utils\n", "\n", "from PFDataset import PFDataset, get_interleaved_dataloaders, Collater\n", "\n", "from pyg.mlpf import MLPF\n", "from pyg.utils import X_FEATURES, Y_FEATURES, unpack_predictions\n", "from jet_utils import match_two_jet_collections\n", "\n", "#################################### must update this function to have the proper p4\n", "def unpack_target(y):\n", " ret = {}\n", " ret[\"cls_id\"] = y[..., 0].long()\n", " ret[\"charge\"] = torch.clamp((y[..., 1] + 1).to(dtype=torch.float32), 0, 2) # -1, 0, 1 -> 0, 1, 2\n", "\n", " for i, feat in enumerate(Y_FEATURES):\n", " if i >= 2: # skip the cls and charge as they are defined above\n", " ret[feat] = y[..., i].to(dtype=torch.float32)\n", " ret[\"phi\"] = torch.atan2(ret[\"sin_phi\"], ret[\"cos_phi\"])\n", "\n", " # do some sanity checks\n", " # assert torch.all(ret[\"pt\"] >= 0.0) # pt\n", " # assert torch.all(torch.abs(ret[\"sin_phi\"]) <= 1.0) # sin_phi\n", " # assert torch.all(torch.abs(ret[\"cos_phi\"]) <= 1.0) # cos_phi\n", " # assert torch.all(ret[\"energy\"] >= 0.0) # energy\n", "\n", " # note ~ momentum = [\"pt\", \"eta\", \"sin_phi\", \"cos_phi\", \"energy\"]\n", " ret[\"momentum\"] = y[..., 2:7].to(dtype=torch.float32)\n", " ret[\"p4\"] = torch.cat(\n", " [ret[\"pt\"].unsqueeze(-1), ret[\"eta\"].unsqueeze(-1), ret[\"phi\"].unsqueeze(-1), ret[\"energy\"].unsqueeze(-1)], axis=-1\n", " )\n", "\n", " ret[\"genjet_idx\"] = y[..., -1].long()\n", "\n", " return ret" ] }, { "cell_type": "code", "execution_count": 9, "id": "14875b0a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Will use NVIDIA A100-SXM4-80GB\n" ] } ], "source": [ "# define the global base device\n", "world_size = 1\n", "if torch.cuda.device_count():\n", " rank = 0\n", " device = torch.device(\"cuda:0\")\n", " print(f\"Will use {torch.cuda.get_device_name(device)}\")\n", "else:\n", " rank = \"cpu\"\n", " device = \"cpu\"\n", " print(\"Will use cpu\")" ] }, { "cell_type": "markdown", "id": "3c4aec55", "metadata": {}, "source": [ "# Load the pre-trained MLPF model" ] }, { "cell_type": "code", "execution_count": 17, "id": "1879def6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MLPF(\n", " (nn0_id): Sequential(\n", " (0): Linear(in_features=17, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0.0, inplace=False)\n", " (4): Linear(in_features=512, out_features=512, bias=True)\n", " )\n", " (nn0_reg): Sequential(\n", " (0): Linear(in_features=17, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0.0, inplace=False)\n", " (4): Linear(in_features=512, out_features=512, bias=True)\n", " )\n", " (conv_id): ModuleList(\n", " (0-2): 3 x SelfAttentionLayer(\n", " (mha): MultiheadAttention(\n", " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", " )\n", " (norm0): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (seq): Sequential(\n", " (0): Linear(in_features=512, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): Linear(in_features=512, out_features=512, bias=True)\n", " (3): ReLU()\n", " )\n", " (dropout): Dropout(p=0.0, inplace=False)\n", " )\n", " )\n", " (conv_reg): ModuleList(\n", " (0-2): 3 x SelfAttentionLayer(\n", " (mha): MultiheadAttention(\n", " (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)\n", " )\n", " (norm0): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (seq): Sequential(\n", " (0): Linear(in_features=512, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): Linear(in_features=512, out_features=512, bias=True)\n", " (3): ReLU()\n", " )\n", " (dropout): Dropout(p=0.0, inplace=False)\n", " )\n", " )\n", " (nn_id): Sequential(\n", " (0): Linear(in_features=529, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0.0, inplace=False)\n", " (4): Linear(in_features=512, out_features=6, bias=True)\n", " )\n", " (nn_pt): RegressionOutput(\n", " (nn): Sequential(\n", " (0): Linear(in_features=535, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0.0, inplace=False)\n", " (4): Linear(in_features=512, out_features=2, bias=True)\n", " )\n", " )\n", " (nn_eta): RegressionOutput(\n", " (nn): Sequential(\n", " (0): Linear(in_features=535, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0.0, inplace=False)\n", " (4): Linear(in_features=512, out_features=2, bias=True)\n", " )\n", " )\n", " (nn_sin_phi): RegressionOutput(\n", " (nn): Sequential(\n", " (0): Linear(in_features=535, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0.0, inplace=False)\n", " (4): Linear(in_features=512, out_features=2, bias=True)\n", " )\n", " )\n", " (nn_cos_phi): RegressionOutput(\n", " (nn): Sequential(\n", " (0): Linear(in_features=535, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0.0, inplace=False)\n", " (4): Linear(in_features=512, out_features=2, bias=True)\n", " )\n", " )\n", " (nn_energy): RegressionOutput(\n", " (nn): Sequential(\n", " (0): Linear(in_features=535, out_features=512, bias=True)\n", " (1): ReLU()\n", " (2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0.0, inplace=False)\n", " (4): Linear(in_features=512, out_features=2, bias=True)\n", " )\n", " )\n", ")\n" ] } ], "source": [ "def load_checkpoint(checkpoint, model, optimizer=None):\n", " if isinstance(model, torch.nn.parallel.DistributedDataParallel):\n", " model.module.load_state_dict(checkpoint[\"model_state_dict\"])\n", " else:\n", " model.load_state_dict(checkpoint[\"model_state_dict\"])\n", " if optimizer:\n", " optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n", " return model, optimizer\n", " else:\n", " return model\n", " \n", " \n", "loaddir = \"/pfvol/experiments/MLPF_clic_backbone_pyg-clic_20240429_101112_971749\"\n", "\n", "with open(f\"{loaddir}/model_kwargs.pkl\", \"rb\") as f:\n", " mlpf_kwargs = pkl.load(f)\n", "\n", "mlpf_kwargs[\"attention_type\"] = \"flash\"\n", "\n", "mlpf = MLPF(**mlpf_kwargs).to(torch.device(rank))\n", "checkpoint = torch.load(f\"{loaddir}/best_weights.pth\", map_location=torch.device(rank))\n", "\n", "mlpf = load_checkpoint(checkpoint, mlpf)\n", "mlpf.eval()\n", "\n", "print(mlpf) " ] }, { "cell_type": "markdown", "id": "dde5f191", "metadata": {}, "source": [ "# CLIC dataset" ] }, { "cell_type": "code", "execution_count": 18, "id": "d98c6857", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "clic_edm_qq_pf\t\t cms_pf_qcd_high_pt\t cms_pf_single_proton\r\n", "clic_edm_ttbar_pf\t cms_pf_single_electron cms_pf_single_tau\r\n", "clic_edm_ttbar_pu10_pf\t cms_pf_single_gamma\t cms_pf_sms_t1tttt\r\n", "clic_edm_ww_fullhad_pf\t cms_pf_single_mu\t cms_pf_ttbar\r\n", "clic_edm_zh_tautau_pf\t cms_pf_single_neutron cms_pf_ztt\r\n", "cms_pf_multi_particle_gun cms_pf_single_pi\t delphes_qcd_pf\r\n", "cms_pf_qcd\t\t cms_pf_single_pi0\t delphes_ttbar_pf\r\n" ] } ], "source": [ "! ls /pfvol/tensorflow_datasets/" ] }, { "cell_type": "code", "execution_count": 19, "id": "49d849e9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['type',\n", " 'pt | et',\n", " 'eta',\n", " 'sin_phi',\n", " 'cos_phi',\n", " 'p | energy',\n", " 'chi2 | position.x',\n", " 'ndf | position.y',\n", " 'dEdx | position.z',\n", " 'dEdxError | iTheta',\n", " 'radiusOfInnermostHit | energy_ecal',\n", " 'tanLambda | energy_hcal',\n", " 'D0 | energy_other',\n", " 'omega | num_hits',\n", " 'Z0 | sigma_x',\n", " 'time | sigma_y',\n", " 'Null | sigma_z']" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# we can see the 17th features here (recall type is 1 for tracks and 2 for clusters)\n", "X_FEATURES[\"clic\"]" ] }, { "cell_type": "code", "execution_count": 20, "id": "b3781b28", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['cls_id', 'charge', 'pt', 'eta', 'sin_phi', 'cos_phi', 'energy']" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# we can see the 8 gen features per pf element here (notice the jet_index which may be useful)\n", "Y_FEATURES" ] }, { "cell_type": "markdown", "id": "d602e8e2", "metadata": {}, "source": [ "# Get the dataset (Events)" ] }, { "cell_type": "code", "execution_count": 24, "id": "dfc6b930", "metadata": {}, "outputs": [], "source": [ "data_dir = \"/home/jovyan/particleflow/tensorflow_datasets/\"\n", "sample = \"clic_edm_ttbar_pf\"\n", "\n", "dataset_train = PFDataset(data_dir, f\"{sample}:1.5.0\", \"train\", num_samples=10_000)\n", "\n", "batch_size = 100\n", "\n", "train_loader = torch.utils.data.DataLoader(\n", " dataset_train.ds,\n", " batch_size=batch_size,\n", " collate_fn=Collater([\"X\", \"ygen\", \"ycand\"]),\n", " pin_memory=True,\n", " drop_last=True,\n", ")" ] }, { "cell_type": "code", "execution_count": 25, "id": "abf11cbc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([100, 246, 17])\n" ] } ], "source": [ "for batch in train_loader:\n", " batch = batch.to(rank, non_blocking=True)\n", " break\n", "print(batch.X.shape) " ] }, { "cell_type": "markdown", "id": "883675d2", "metadata": {}, "source": [ "# Pre-processing (Events -> Jets)" ] }, { "cell_type": "code", "execution_count": 48, "id": "f8b7ad0b", "metadata": {}, "outputs": [], "source": [ "freeze_backbone = True" ] }, { "cell_type": "code", "execution_count": 53, "id": "d22f4bdf", "metadata": {}, "outputs": [], "source": [ "############################### set up forward hooks to retrive the latent representations of MLPF\n", "latent_reps = {}\n", "def get_activations(name):\n", " def hook(mlpf, input, output):\n", " latent_reps[name] = output\n", "\n", " return hook\n", "\n", "mlpf.conv_reg[0].dropout.register_forward_hook(get_activations(\"conv_reg0\"))\n", "mlpf.conv_reg[1].dropout.register_forward_hook(get_activations(\"conv_reg1\"))\n", "mlpf.conv_reg[2].dropout.register_forward_hook(get_activations(\"conv_reg2\"))\n", "mlpf.nn_id.register_forward_hook(get_activations(\"nn_id\")) \n", "###############################\n", "\n", "def get_latent_reps(batch, latent_reps):\n", " for layer in latent_reps:\n", " if \"conv\" in layer:\n", " latent_reps[layer] *= batch.mask.unsqueeze(-1)\n", "\n", " latentX = torch.cat(\n", " [\n", " batch.X.to(rank),\n", " latent_reps[\"conv_reg0\"],\n", " latent_reps[\"conv_reg1\"],\n", " latent_reps[\"conv_reg2\"],\n", " latent_reps[\"nn_id\"],\n", " ],\n", " axis=-1,\n", " )\n", " return latentX" ] }, { "cell_type": "code", "execution_count": 54, "id": "1bf42610", "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running MLPF inference on batch 0\n" ] } ], "source": [ "sample_to_lab = {\n", " \"clic_edm_ttbar_pf\": 1,\n", " \"clic_edm_qq_pf\": 0, \n", "}\n", "\n", "####################### Config\n", "jetdef = fastjet.JetDefinition(fastjet.ee_genkt_algorithm, 0.7, -1.0)\n", "jet_ptcut = 15.0\n", "jet_match_dr = 0.1\n", "\n", "save_every_X_batch = 3 # will save to disk every \"X\" batches\n", "\n", "######################## Build the dataset\n", "jet_dataset = [] # will save on disk and reinitialize at the end of the loop\n", "saving_i = 0 # will just increment with every save\n", "\n", "for ibatch, batch in enumerate(train_loader):\n", "\n", " # run the MLPF model in inference mode to get the MLPF cands / latent representations \n", " print(f\"Running MLPF inference on batch {ibatch}\")\n", " batch = batch.to(rank, non_blocking=True)\n", "# with torch.no_grad():\n", " with torch.autocast(device_type=\"cuda\", dtype=torch.bfloat16, enabled=True):\n", " ymlpf = mlpf(batch.X, batch.mask)\n", " ymlpf = unpack_predictions(ymlpf)\n", " \n", " # get the latent representations\n", " ymlpf[\"latentX\"] = get_latent_reps(batch, latent_reps)\n", "\n", "# for k, v in ymlpf.items():\n", "# ymlpf[k] = v.detach().cpu()\n", "\n", "# msk_ymlpf = ymlpf[\"cls_id\"] != 0\n", "# ymlpf[\"p4\"] = ymlpf[\"p4\"] * msk_ymlpf.unsqueeze(-1)\n", "\n", "# jets_coll = {}\n", "# ####################### get the reco jet collection\n", "# vec = vector.awk(\n", "# ak.zip(\n", "# {\n", "# \"pt\": ymlpf[\"p4\"][:, :, 0].to(\"cpu\"),\n", "# \"eta\": ymlpf[\"p4\"][:, :, 1].to(\"cpu\"),\n", "# \"phi\": ymlpf[\"p4\"][:, :, 2].to(\"cpu\"),\n", "# \"e\": ymlpf[\"p4\"][:, :, 3].to(\"cpu\"),\n", "# }\n", "# )\n", "# )\n", "# cluster = fastjet.ClusterSequence(vec.to_xyzt(), jetdef)\n", "# jets_coll[\"reco\"] = cluster.inclusive_jets(min_pt=jet_ptcut)\n", " \n", "# # get the constituents to mask the MLPF candidates and build the input for the downstream \n", "# reco_constituents = cluster.constituent_index(min_pt=jet_ptcut)\n", "# ####################### \n", " \n", "# ####################### get the gen jet collection\n", "# ygen = unpack_target(batch.ygen) \n", "# vec = vector.awk(\n", "# ak.zip(\n", "# {\n", "# \"pt\": ygen[\"p4\"][:, :, 0].to(\"cpu\"),\n", "# \"eta\": ygen[\"p4\"][:, :, 1].to(\"cpu\"),\n", "# \"phi\": ygen[\"p4\"][:, :, 2].to(\"cpu\"),\n", "# \"e\": ygen[\"p4\"][:, :, 3].to(\"cpu\"),\n", "# }\n", "# )\n", "# )\n", "# cluster = fastjet.ClusterSequence(vec.to_xyzt(), jetdef)\n", "# jets_coll[\"gen\"] = cluster.inclusive_jets(min_pt=jet_ptcut) \n", "# #######################\n", " \n", "# matched_jets = match_two_jet_collections(jets_coll, \"reco\", \"gen\", jet_match_dr)\n", " \n", "# # build the big jet list\n", "# for iev in tqdm.tqdm(range(len(matched_jets[\"gen\"]))):\n", " \n", "# num_matched_jets = len(matched_jets[\"gen\"][iev]) # number of gen jets matched to reco\n", " \n", "# jets_per_event = []\n", "# for j in range(num_matched_jets):\n", " \n", "# # get the actual indices of the matched jets\n", "# igenjet = matched_jets[\"gen\"][iev][j]\n", "# irecojet = matched_jets[\"reco\"][iev][j]\n", "\n", "# # build a mask tensor that will select the particles that belong to the gen jet \n", "# msk_indices = reco_constituents[iev][irecojet].to_numpy()\n", "\n", "# if len(msk_indices)<3:\n", "# # don't save jets with very few particles\n", "# continue\n", "\n", "# jets_per_event += [\n", "\n", "# Data(\n", "# # Target for jet tagging\n", "# gen_jet_label=torch.tensor(sample_to_lab[sample]).unsqueeze(0).to(dtype=torch.float32),\n", "\n", "# # Target for jet p4 regression \n", "# gen_jet_pt=torch.tensor(jets_coll[\"gen\"][iev][igenjet].pt, dtype=torch.float32).unsqueeze(0),\n", "# gen_jet_eta=torch.tensor(jets_coll[\"gen\"][iev][igenjet].eta, dtype=torch.float32).unsqueeze(0),\n", "# gen_jet_phi=torch.tensor(jets_coll[\"gen\"][iev][igenjet].phi, dtype=torch.float32).unsqueeze(0),\n", "# gen_jet_energy=torch.tensor(jets_coll[\"gen\"][iev][igenjet].energy, dtype=torch.float32).unsqueeze(0),\n", " \n", "# # could be part of the target\n", "# reco_jet_pt=torch.tensor(jets_coll[\"reco\"][iev][irecojet].pt, dtype=torch.float32).unsqueeze(0),\n", "# reco_jet_eta=torch.tensor(jets_coll[\"reco\"][iev][irecojet].eta, dtype=torch.float32).unsqueeze(0),\n", "# reco_jet_phi=torch.tensor(jets_coll[\"reco\"][iev][irecojet].phi, dtype=torch.float32).unsqueeze(0),\n", "# reco_jet_energy=torch.tensor(jets_coll[\"reco\"][iev][irecojet].energy, dtype=torch.float32).unsqueeze(0),\n", " \n", "# # Input\n", "# mlpfcands_momentum=ymlpf[\"momentum\"][iev][msk_indices],\n", "# mlpfcands_pid=ymlpf[\"cls_id_onehot\"][iev][msk_indices],\n", "# mlpfcands_charge=ymlpf[\"charge\"][iev][msk_indices],\n", "# mlpfcands_latentX=ymlpf[\"latentX\"][iev][msk_indices],\n", "# )\n", "# ]\n", "\n", "# # break # per jet \n", " \n", "# # random.shuffle(jets_per_event)\n", "# jet_dataset += jets_per_event\n", "\n", "# break # per event\n", "\n", "# # random.shuffle(jet_dataset)\n", "# if (ibatch % (save_every_X_batch-1) == 0) and (ibatch != 0):\n", "# print(f\"saving at iteration {ibatch} on disk /pfvol/jetdataset/{sample}/train/{saving_i}.pt\")\n", "# torch.save(jet_dataset, f\"/pfvol/jetdataset/{sample}/train/{saving_i}.pt\")\n", "# saving_i += 1\n", "# jet_dataset = []\n", " break # per batch" ] }, { "cell_type": "code", "execution_count": 56, "id": "71bfbe1d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([[[ 1.0000e+00, 4.0499e+00, 9.5381e-01, ..., -5.0312e+00,\n", " -4.0625e-01, -5.9766e-01],\n", " [ 1.0000e+00, 1.8992e+01, 6.8335e-02, ..., -6.7500e+00,\n", " 2.4414e-01, 1.2500e+00],\n", " [ 1.0000e+00, 4.8831e+00, 1.2232e-01, ..., -5.4688e+00,\n", " -2.0469e+00, 6.9375e+00],\n", " ...,\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00]],\n", "\n", " [[ 1.0000e+00, 5.2279e+01, 2.1137e-01, ..., -6.8125e+00,\n", " -1.6875e+00, 1.1597e-03],\n", " [ 1.0000e+00, 1.2576e+01, -3.7162e-02, ..., -6.2812e+00,\n", " 2.4219e+00, -2.2500e+00],\n", " [ 1.0000e+00, 8.7163e+00, -6.4841e-02, ..., -7.1250e+00,\n", " 3.0781e+00, 6.9922e-01],\n", " ...,\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00]],\n", "\n", " [[ 1.0000e+00, 1.2418e+01, -1.5321e-02, ..., -7.7188e+00,\n", " 1.7031e+00, 2.3594e+00],\n", " [ 1.0000e+00, 1.5101e+01, -3.2354e-02, ..., -8.1875e+00,\n", " 1.3594e+00, 5.6250e+00],\n", " [ 1.0000e+00, 2.4137e+01, 8.7432e-01, ..., -6.5312e+00,\n", " -7.1484e-01, 7.3750e+00],\n", " ...,\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00]],\n", "\n", " ...,\n", "\n", " [[ 1.0000e+00, 2.7388e+01, 1.2865e+00, ..., -4.1250e+00,\n", " 5.6250e+00, -4.6875e+00],\n", " [ 1.0000e+00, 2.1186e+01, 1.8190e-01, ..., -6.2812e+00,\n", " 6.7500e+00, -2.5938e+00],\n", " [ 1.0000e+00, 1.5213e+01, -4.2097e-01, ..., -5.9688e+00,\n", " 1.8848e-01, -7.4219e-01],\n", " ...,\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00]],\n", "\n", " [[ 1.0000e+00, 1.1207e+01, -7.9346e-01, ..., -6.0000e+00,\n", " 1.4688e+00, -1.1016e+00],\n", " [ 1.0000e+00, 6.9457e+00, 9.0808e-02, ..., -7.4375e+00,\n", " 1.6953e+00, 7.5781e-01],\n", " [ 1.0000e+00, 6.7352e+00, -5.3468e-01, ..., -7.6875e+00,\n", " 1.0703e+00, 2.6094e+00],\n", " ...,\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00]],\n", "\n", " [[ 1.0000e+00, 1.4524e+01, -4.8954e-01, ..., -7.2188e+00,\n", " 6.3438e+00, -2.3594e+00],\n", " [ 1.0000e+00, 1.0940e+01, -6.0876e-01, ..., -6.5938e+00,\n", " 4.4062e+00, -3.7500e+00],\n", " [ 1.0000e+00, 1.0282e+01, -6.9122e-01, ..., -7.3438e+00,\n", " 8.2031e-01, 7.6953e-01],\n", " ...,\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00],\n", " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -2.3125e+00,\n", " -5.4688e+00, -7.5625e+00]]], device='cuda:0')" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ymlpf[\"latentX\"].detach()" ] }, { "cell_type": "code", "execution_count": 45, "id": "956e9d8b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ymlpf[\"cls_id_onehot\"].requires_grad" ] }, { "cell_type": "code", "execution_count": 46, "id": "ce0911a4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ymlpf[\"latentX\"].requires_grad" ] }, { "cell_type": "code", "execution_count": null, "id": "03aa548e", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "fe1dd2af", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "891aa275", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "b1383441", "metadata": {}, "outputs": [], "source": [ "print(len(reco_constituents[0][0]))\n", "print(len(reco_constituents[0][1]))\n", "print(len(reco_constituents[0][2]))\n", "print(len(reco_constituents[0][3]))\n", "print(len(reco_constituents[0][4]))" ] }, { "cell_type": "code", "execution_count": 77, "id": "8e4d08ad", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
{reco: [0, 1, 2, 3, 4],\n",
       " gen: [0, 1, 2, 3, 4]}\n",
       "-----------------------\n",
       "type: {\n",
       "    reco: var * int64,\n",
       "    gen: var * int64\n",
       "}
" ], "text/plain": [ "" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matched_jets[0]" ] }, { "cell_type": "code", "execution_count": 70, "id": "b3b4d823", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n", "18\n", "29\n", "32\n", "143\n" ] } ], "source": [ "print(len(reco_constituents[0][0]))\n", "print(len(reco_constituents[0][1]))\n", "print(len(reco_constituents[0][2]))\n", "print(len(reco_constituents[0][3]))\n", "print(len(reco_constituents[0][4]))" ] }, { "cell_type": "code", "execution_count": 72, "id": "3fda2809", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
{reco: [0, 1, 2, 3],\n",
       " gen: [0, 1, 2, 3]}\n",
       "----------------------\n",
       "type: {\n",
       "    reco: var * int64,\n",
       "    gen: var * int64\n",
       "}
" ], "text/plain": [ "" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matched_jets[0]" ] }, { "cell_type": "markdown", "id": "543e188a", "metadata": {}, "source": [ "# Load the dataset" ] }, { "cell_type": "code", "execution_count": 33, "id": "b92d8c4b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "97M\t/pfvol/jetdataset/clic_edm_ttbar_pf/train/0.pt\r\n" ] } ], "source": [ "! du -sh /pfvol/jetdataset/clic_edm_ttbar_pf/train/0.pt" ] }, { "cell_type": "code", "execution_count": 5, "id": "1a97f4e5", "metadata": {}, "outputs": [], "source": [ "# load one of the train files\n", "jet_dataset = torch.load(\"/pfvol/jetdataset/clic_edm_ttbar_pf/train/0.pt\")" ] }, { "cell_type": "code", "execution_count": 6, "id": "0ad26b72", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "19821" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(jet_dataset)" ] }, { "cell_type": "code", "execution_count": 11, "id": "756bed70", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Jet # 0\n", "keys ['mlpfcands_pid', 'gen_jet_eta', 'gen_jet_phi', 'mlpfcands_charge', 'gen_jet_energy', 'gen_jet_pt', 'reco_jet_energy', 'mlpfcands_momentum', 'gen_jet_label', 'reco_jet_pt', 'reco_jet_phi', 'mlpfcands_latentX', 'reco_jet_eta']\n", "--------------------------\n", " gen jet pt: 41.288578033447266\n", " reco jet pt: 41.34593963623047\n", "--------------------------\n", " mlpfcands_momentum: torch.Size([18, 5]) - 18 particles with 5 p4 features (pt, eta, sphi, cphi, energy)\n", " mlpfcands_pid: torch.Size([18, 6]) - 18 particles with 6 PID features\n", " mlpfcands_charge: torch.Size([18, 3]) - 18 particles with 3 charge features\n", " mlpfcands_latentX: torch.Size([18, 791]) - 18 particles with 791 latent features\n" ] } ], "source": [ "# inspect one jet\n", "ijet = 0\n", "\n", "print(f\"Jet # {ijet}\")\n", "print(f\"keys {jet_dataset[ijet].keys()}\")\n", "print(\"--------------------------\")\n", "print(\" gen jet pt:\", jet_dataset[ijet][\"gen_jet_pt\"].item())\n", "print(\" reco jet pt:\", jet_dataset[ijet][\"reco_jet_pt\"].item())\n", "print(\"--------------------------\")\n", "print(\" mlpfcands_momentum:\", jet_dataset[0][\"mlpfcands_momentum\"].shape, f\"- {jet_dataset[0]['mlpfcands_momentum'].shape[0]} particles with 5 p4 features (pt, eta, sphi, cphi, energy)\")\n", "print(\" mlpfcands_pid:\", jet_dataset[0][\"mlpfcands_pid\"].shape, f\"- {jet_dataset[0]['mlpfcands_momentum'].shape[0]} particles with 6 PID features\")\n", "print(\" mlpfcands_charge:\", jet_dataset[0][\"mlpfcands_charge\"].shape, f\"- {jet_dataset[0]['mlpfcands_momentum'].shape[0]} particles with 3 charge features\")\n", "print(\" mlpfcands_latentX:\", jet_dataset[0][\"mlpfcands_latentX\"].shape, f\"- {jet_dataset[0]['mlpfcands_momentum'].shape[0]} particles with 791 latent features\")" ] }, { "cell_type": "markdown", "id": "09d976c1", "metadata": {}, "source": [ "# Build a DataLoader" ] }, { "cell_type": "code", "execution_count": 21, "id": "7b5708a8", "metadata": {}, "outputs": [], "source": [ "# Define your custom collate function to add a batch key\n", "def collate_fn(data_list):\n", " batch = Batch.from_data_list(data_list)\n", " \n", " batch_list = []\n", " for ijet, jet in enumerate(data_list):\n", " num_MLPFcands = len(jet[\"mlpfcands_momentum\"]) # number of MLPFcands\n", " batch_list += [ijet] * num_MLPFcands\n", "\n", " batch.batch = torch.tensor(batch_list)\n", " \n", " return batch" ] }, { "cell_type": "code", "execution_count": 52, "id": "f6ae14a4", "metadata": {}, "outputs": [], "source": [ "jetloader = torch.utils.data.DataLoader(jet_dataset, batch_size=5, collate_fn=collate_fn)" ] }, { "cell_type": "code", "execution_count": 53, "id": "b2c8511b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['gen_jet_eta',\n", " 'reco_jet_pt',\n", " 'mlpfcands_pid',\n", " 'gen_jet_phi',\n", " 'gen_jet_energy',\n", " 'batch',\n", " 'reco_jet_energy',\n", " 'gen_jet_label',\n", " 'reco_jet_eta',\n", " 'reco_jet_phi',\n", " 'gen_jet_pt',\n", " 'mlpfcands_charge',\n", " 'mlpfcands_momentum',\n", " 'mlpfcands_latentX']" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "for batch in jetloader:\n", " break\n", "batch.keys()" ] }, { "cell_type": "code", "execution_count": 48, "id": "62ac64c4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "gen_jet_eta\n", "reco_jet_pt\n", "gen_jet_phi\n", "gen_jet_energy\n", "reco_jet_energy\n", "gen_jet_label\n", "reco_jet_eta\n", "reco_jet_phi\n", "gen_jet_pt\n" ] } ], "source": [ "for key in batch.keys():\n", " if \"jet\" in key:\n", " print(key)" ] }, { "cell_type": "code", "execution_count": 47, "id": "5c076f88", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mlpfcands_pid\n", "mlpfcands_charge\n", "mlpfcands_momentum\n", "mlpfcands_latentX\n" ] } ], "source": [ "for key in batch.keys():\n", " if \"mlpf\" in key:\n", " print(key)" ] }, { "cell_type": "code", "execution_count": 24, "id": "8e4821fa", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([38.7100, 16.4567, 31.4733, 45.9380, 66.5003])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "batch[\"gen_jet_pt\"]" ] }, { "cell_type": "code", "execution_count": 25, "id": "33dab9e0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([36.2084, 15.6482, 41.6876, 48.7271, 80.7797])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "batch[\"reco_jet_pt\"]" ] }, { "cell_type": "code", "execution_count": 49, "id": "acb9b0c5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "torch.Size([154, 5])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "batch[\"mlpfcands_momentum\"].shape # 154 particles per jet; 5 p4 info (pt, eta, sphi, cphi, e)" ] }, { "cell_type": "code", "execution_count": 51, "id": "8fd812b8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "torch.Size([154, 791])" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "batch[\"mlpfcands_latentX\"].shape # 154 particles per jet; 791 latent features" ] }, { "cell_type": "code", "execution_count": 27, "id": "7f399a0d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,\n", " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,\n", " 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", " 4, 4, 4, 4, 4, 4, 4, 4, 4, 4])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "batch[\"batch\"] # indices to which jet the particles belong" ] }, { "cell_type": "markdown", "id": "2ec70de5", "metadata": {}, "source": [ "# Quick validation" ] }, { "cell_type": "code", "execution_count": 28, "id": "e784ee72", "metadata": {}, "outputs": [], "source": [ "genjets, recojets = {}, {}\n", "for x in [\"pt\", \"eta\", \"phi\", \"energy\"]:\n", " genjets[x], recojets[x] = [], []\n", " \n", "for batch in jetloader:\n", " \n", " for x in [\"pt\", \"eta\", \"phi\", \"energy\"]:\n", " genjets[x] += batch[f\"gen_jet_{x}\"].tolist()\n", " recojets[x] += batch[f\"reco_jet_{x}\"].tolist()" ] }, { "cell_type": "code", "execution_count": 29, "id": "859396a0", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(figsize=(10,10), nrows=2, ncols=2)\n", "\n", "bins = np.linspace(15,130,40)\n", "axes[0,0].hist2d(genjets[\"pt\"], recojets[\"pt\"], bins) #row=0, col=0\n", "axes[0,0].set_title(\"pt\")\n", "\n", "bins = np.linspace(-1.8,1.8,40)\n", "axes[0,1].hist2d(genjets[\"eta\"], recojets[\"eta\"], bins) #row=1, col=0\n", "axes[0,1].set_title(\"eta\");\n", "\n", "bins = np.linspace(-3.14,3.14,40)\n", "axes[1,0].hist2d(genjets[\"phi\"], recojets[\"phi\"], bins) #row=1, col=0\n", "axes[1,0].set_title(\"phi\");\n", "\n", "bins = np.linspace(15,130,40)\n", "axes[1,1].hist2d(genjets[\"energy\"], recojets[\"energy\"], bins) #row=1, col=0\n", "axes[1,1].set_title(\"energy\");\n", "\n", "fig.text(0.5, 0, 'Gen Jet', ha='center')\n", "fig.text(0, 0.5, 'Reco Jet', va='center', rotation='vertical')\n", "\n", "plt.tight_layout()" ] }, { "cell_type": "markdown", "id": "e9baced1", "metadata": {}, "source": [ "# Setup the downstream task" ] }, { "cell_type": "code", "execution_count": 30, "id": "89613a90", "metadata": {}, "outputs": [], "source": [ "import torch.nn as nn\n", "from torch_geometric.nn.pool import global_add_pool\n", "\n", "\n", "def ffn(input_dim, output_dim, width, act, dropout):\n", " return nn.Sequential(\n", " nn.Linear(input_dim, width),\n", " act(),\n", " torch.nn.LayerNorm(width),\n", " nn.Dropout(dropout),\n", " nn.Linear(width, output_dim),\n", " )\n", "\n", "class JetRegressor(nn.Module):\n", " def __init__(\n", " self,\n", " input_dim=14,\n", " embedding_dim=64,\n", " output_dim=1,\n", " width=256,\n", " dropout=0,\n", " ):\n", " super(JetRegressor, self).__init__()\n", "\n", " \"\"\"\n", " Takes as input either (1) the MLPF candidates OR (2) the latent representations of the MLPF candidates,\n", " and runs an MLP to predict an output per jet: \"ptcorr\"; which will enter the loss as follows:\n", " pred_jetpt = ptcorr * reco_pt\n", "\n", " LOSS = Huber(true_jetpt, pred_jetpt)\n", "\n", " \"\"\"\n", "\n", " self.act = nn.ELU\n", " self.nn1 = ffn(input_dim, embedding_dim, width, self.act, dropout)\n", " self.nn2 = ffn(embedding_dim, output_dim, width, self.act, dropout)\n", "\n", " # @torch.compile\n", " def forward(self, X, batch):\n", "\n", " embeddings = self.nn1(X)\n", " \n", "# pooled_embeddings = embeddings.sum(axis=1) # recall ~ [Batch, Particles, Features]\n", " \n", " pooled_embeddings = global_add_pool(embeddings, batch)\n", "\n", " return self.nn2(pooled_embeddings)" ] }, { "cell_type": "code", "execution_count": 31, "id": "2e2e9af7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "JetRegressor(\n", " (nn1): Sequential(\n", " (0): Linear(in_features=791, out_features=256, bias=True)\n", " (1): ELU(alpha=1.0)\n", " (2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0, inplace=False)\n", " (4): Linear(in_features=256, out_features=64, bias=True)\n", " )\n", " (nn2): Sequential(\n", " (0): Linear(in_features=64, out_features=256, bias=True)\n", " (1): ELU(alpha=1.0)\n", " (2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", " (3): Dropout(p=0, inplace=False)\n", " (4): Linear(in_features=256, out_features=1, bias=True)\n", " )\n", ")" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run_with_latentX = True\n", "\n", "if run_with_latentX:\n", " input_dim = 791\n", "else:\n", " input_dim = 14 \n", " \n", "model = JetRegressor(input_dim).to(rank)\n", "model.train()" ] }, { "cell_type": "code", "execution_count": 32, "id": "1143a728", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(0.0532, device='cuda:0', grad_fn=)\n" ] } ], "source": [ "for batch in jetloader:\n", "\n", " batch = batch.to(rank)\n", "\n", " if run_with_latentX:\n", " X = batch[\"mlpfcands_latentX\"]\n", " else:\n", " X = torch.cat([batch[\"mlpfcands_momentum\"], batch[\"mlpfcands_pid\"], batch[\"mlpfcands_charge\"]], axis=-1)\n", " \n", " ptcorr = model(X, batch.batch).squeeze(1)\n", " \n", " target = torch.log(batch[\"gen_jet_pt\"] / batch[\"reco_jet_pt\"])\n", "\n", " loss = torch.nn.functional.huber_loss(target, ptcorr)\n", " \n", " break\n", "print(loss)" ] }, { "cell_type": "code", "execution_count": null, "id": "926cebd1", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "0f7325ed", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "94fe4139", "metadata": {}, "source": [ "########\n" ] }, { "cell_type": "code", "execution_count": null, "id": "8cea34d3", "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.10.12" } }, "nbformat": 4, "nbformat_minor": 5 }