diff --git a/notebooks/ssl-VICreg.ipynb b/notebooks/ssl-VICreg.ipynb new file mode 100644 index 000000000..f8ce4a4c2 --- /dev/null +++ b/notebooks/ssl-VICreg.ipynb @@ -0,0 +1,2266 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":219: RuntimeWarning: scipy._lib.messagestream.MessageStream size changed, may indicate binary incompatibility. Expected 56 from C header, got 64 from PyObject\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torchvision.transforms as tr\n", + "\n", + "import torch_geometric\n", + "from torch_geometric.nn import global_mean_pool\n", + "from torch_geometric.data import Batch\n", + "\n", + "from typing import Optional, Union\n", + "\n", + "from torch import Tensor\n", + "from torch.nn import Linear\n", + "from torch_geometric.nn.conv import MessagePassing, GravNetConv\n", + "from torch_geometric.typing import OptTensor, PairOptTensor, PairTensor\n", + "from torch_scatter import scatter\n", + "\n", + "from tqdm.notebook import tqdm\n", + "\n", + "import numpy as np\n", + "\n", + "import json\n", + "import math\n", + "import os\n", + "import time\n", + "\n", + "import sklearn\n", + "import sklearn.metrics\n", + "\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import mplhep as hep\n", + "plt.style.use(hep.style.CMS)\n", + "plt.rcParams.update({'font.size': 20})" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# VICreg loss function\n", + "def criterion(x, y, device='cuda', lmbd = 5e-3, u = 1, v= 1, epsilon = 1e-3):\n", + " bs = x.size(0)\n", + " emb = x.size(1)\n", + "\n", + " std_x = torch.sqrt(x.var(dim=0) + epsilon)\n", + " std_y = torch.sqrt(y.var(dim=0) + epsilon)\n", + " var_loss = torch.mean(F.relu(1 - std_x)) + torch.mean(F.relu(1 - std_y))\n", + "\n", + " invar_loss = F.mse_loss(x, y)\n", + "\n", + " xNorm = (x - x.mean(0)) / x.std(0)\n", + " yNorm = (y - y.mean(0)) / y.std(0)\n", + " crossCorMat = (xNorm.T@yNorm) / bs\n", + " cross_loss = (crossCorMat*lmbd - torch.eye(emb, device=torch.device(device))*lmbd).pow(2).sum()\n", + "\n", + " loss = u*var_loss + v*invar_loss + cross_loss\n", + "\n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CLIC" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "# load the clic dataset\n", + "import glob\n", + "all_files = glob.glob(f\"../data/clic/data_*\")\n", + "\n", + "data = []\n", + "for f in all_files:\n", + " data += torch.load(f\"{f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num of clic events 7260\n" + ] + } + ], + "source": [ + "print(f\"num of clic events {len(data)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A single event: Batch(x=[135, 8], ygen=[135, 5], ygen_id=[135], ycand=[135, 5], ycand_id=[135], batch=[135], ptr=[2])\n" + ] + } + ], + "source": [ + "loader = torch_geometric.loader.DataLoader(data, batch_size=1)\n", + "for batch in loader:\n", + " print(f\"A single event: {batch}\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# function that takes an event~Batch() and splits it into two Batch() objects representing the tracks/clusters\n", + "def distinguish_PFelements(batch):\n", + " \n", + " track_id = 0\n", + " cluster_id = 1\n", + "\n", + " tracks = Batch(x = batch.x[batch.x[:,0]==track_id][:,1:].float(), # remove the first input feature which is not needed anymore\n", + " ygen = batch.ygen[batch.x[:,0]==track_id],\n", + " ygen_id = batch.ygen_id[batch.x[:,0]==track_id],\n", + " ycand = batch.ycand[batch.x[:,0]==track_id],\n", + " ycand_id = batch.ycand_id[batch.x[:,0]==track_id],\n", + " batch = batch.batch[batch.x[:,0]==track_id],\n", + " )\n", + " clusters = Batch(x = batch.x[batch.x[:,0]==cluster_id][:,1:].float(), # remove the first input feature which is not needed anymore\n", + " ygen = batch.ygen[batch.x[:,0]==cluster_id],\n", + " ygen_id = batch.ygen_id[batch.x[:,0]==cluster_id],\n", + " ycand = batch.ycand[batch.x[:,0]==cluster_id],\n", + " ycand_id = batch.ycand_id[batch.x[:,0]==cluster_id],\n", + " batch = batch.batch[batch.x[:,0]==cluster_id], \n", + " )\n", + " \n", + " return tracks, clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "event: Batch(x=[135, 8], ygen=[135, 5], ygen_id=[135], ycand=[135, 5], ycand_id=[135], batch=[135], ptr=[2])\n", + "tracks: Batch(x=[43, 7], ygen=[43, 5], ygen_id=[43], ycand=[43, 5], ycand_id=[43], batch=[43])\n", + "clusters: Batch(x=[92, 7], ygen=[92, 5], ygen_id=[92], ycand=[92, 5], ycand_id=[92], batch=[92])\n" + ] + } + ], + "source": [ + "tracks, clusters = distinguish_PFelements(batch)\n", + "\n", + "print(f\"event: {batch}\")\n", + "print(f\"tracks: {tracks}\")\n", + "print(f\"clusters: {clusters}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ENCODER" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# define the Encoder that learns latent representations of tracks and clusters \n", + "# these representations will be used by MLPF which is the downstream task\n", + "class Encoder(nn.Module):\n", + "\n", + " def __init__(\n", + " self,\n", + " input_dim=7,\n", + " output_dim=34,\n", + " ):\n", + " super(Encoder, self).__init__()\n", + "\n", + " self.act = nn.ReLU\n", + "# self.act = nn.ELU\n", + "\n", + " # (1) embedding\n", + " self.nn1 = nn.Sequential(\n", + " nn.Linear(input_dim, 126),\n", + " self.act(),\n", + " nn.Linear(126, 126),\n", + " self.act(),\n", + " nn.Linear(126, output_dim),\n", + " )\n", + " self.nn2 = nn.Sequential(\n", + " nn.Linear(input_dim, 126),\n", + " self.act(),\n", + " nn.Linear(126, 126),\n", + " self.act(),\n", + " nn.Linear(126, output_dim),\n", + " )\n", + " \n", + "\n", + " def forward(self, tracks, clusters):\n", + " \n", + " embedding_tracks = self.nn1(tracks.x.float())\n", + " embedding_clusters = self.nn2(clusters.x.float())\n", + " \n", + " return embedding_tracks, embedding_clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss is: 2564.7265625\n" + ] + } + ], + "source": [ + "encoder = Encoder()\n", + "tracks, clusters = distinguish_PFelements(batch)\n", + "\n", + "# make forward pass\n", + "embedding_tracks, embedding_clusters = encoder(tracks, clusters)\n", + "\n", + "# make global pooling\n", + "out_tracks = global_mean_pool(embedding_tracks, tracks.batch) \n", + "out_clusters = global_mean_pool(embedding_clusters, clusters.batch)\n", + "\n", + "# compute the loss between the two latent representations\n", + "loss = criterion(out_tracks, out_clusters, device='cpu')\n", + "print('loss is: ', loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# train the encoder\n", + "def train_encoder(encoder, data, batch_size, lr, epochs):\n", + "\n", + " data_train = data[:1000]\n", + " data_val = data[4000:5000]\n", + " data_test = data[5000:]\n", + "\n", + " train_loader = torch_geometric.loader.DataLoader(data_train, batch_size)\n", + " val_loader = torch_geometric.loader.DataLoader(data_val, batch_size)\n", + " test_loader = torch_geometric.loader.DataLoader(data_test, batch_size)\n", + "\n", + " optimizer = torch.optim.SGD(encoder.parameters(), lr=lr, momentum= 0.9, weight_decay=1.5e-4)\n", + "\n", + " patience = 20\n", + " best_val_loss = 99999.9\n", + " stale_epochs = 0\n", + "\n", + " losses_train = []\n", + " losses_valid = []\n", + "\n", + " for epoch in tqdm(range(epochs)):\n", + " if epoch>10:\n", + " lr *= 10\n", + " loss_train = 0\n", + "\n", + " for batch in tqdm(train_loader):\n", + " # make transformation\n", + " tracks, clusters = distinguish_PFelements(batch)\n", + "\n", + " # make forward pass\n", + " embedding_tracks, embedding_clusters = encoder(tracks, clusters)\n", + "\n", + " # make global pooling\n", + " out_tracks = global_mean_pool(embedding_tracks, tracks.batch) \n", + " out_clusters = global_mean_pool(embedding_clusters, clusters.batch)\n", + "\n", + " # compute loss\n", + " loss = criterion(out_tracks, out_clusters, device='cpu')\n", + " if loss>3000000:\n", + " print(loss)\n", + " break\n", + " \n", + " # update parameters\n", + " for param in encoder.parameters():\n", + " param.grad = None\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " loss_train += loss.detach()\n", + " \n", + " loss_valid = 0\n", + "\n", + " for batch in tqdm(val_loader):\n", + " # make transformation\n", + " tracks, clusters = distinguish_PFelements(batch)\n", + "\n", + " # make forward pass\n", + " embedding_tracks, embedding_clusters = encoder(tracks, clusters)\n", + "\n", + " # make global pooling\n", + " out_tracks = global_mean_pool(embedding_tracks, tracks.batch) \n", + " out_clusters = global_mean_pool(embedding_clusters, clusters.batch)\n", + "\n", + " # compute loss\n", + " loss = criterion(out_tracks, out_clusters, device='cpu')\n", + "\n", + " loss_valid += loss.detach()\n", + "\n", + " print(f\"epoch {epoch} - train: {round(loss_train.item(),3)} - valid: {round(loss_valid.item(), 3)} - stale={stale_epochs}\")\n", + "\n", + " losses_train.append(loss_train/len(train_loader)) \n", + " losses_valid.append(loss_valid/len(val_loader))\n", + "\n", + " # early-stopping\n", + " if losses_valid[epoch] < best_val_loss:\n", + " best_val_loss = losses_valid[epoch]\n", + " stale_epochs = 0\n", + " else:\n", + " stale_epochs += 1\n", + "\n", + " return losses_train, losses_valid" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "44634fe3fa864e7d97ebb7f0c70c8d8f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a8b2c8b62c094f75985e1cc3f946400b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e4a74e29d5e841bd88eb2de134edd592", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 0 - train: 28667.832 - valid: 41.299 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f6159ede49c44686a820102a7f483abb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9e14f9608fc34bc586432834a1c6a802", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 1 - train: 41.194 - valid: 40.981 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6857b56a79784ad086520a800813a565", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c59be48d97c34071940d3a95efe3133f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 2 - train: 40.411 - valid: 40.066 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0ba114309f9443528005fa21ec518ab4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8bfb2857a63340919a01f871e5a0b82b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 3 - train: 39.521 - valid: 39.243 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4fb11f498d224d7585e205cb935d12ce", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "590dd909fc054fd2bc5ebbbc9ce1570a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 4 - train: 38.758 - valid: 38.573 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "60c8a3dad8354053a3b0dac40124eb85", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "20e1eb8698844301854c3fefa5d9e3ec", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 5 - train: 38.129 - valid: 38.013 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "af667075bf8349fe993415989cf190c4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e88c5e5a321c4eeda27bd5cc92f52252", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 6 - train: 37.598 - valid: 37.546 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e9c0a7b6cd8f4a528d4c62981641acad", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a30785bf48a04993b1160d0229c9913b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 7 - train: 37.148 - valid: 37.145 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb6914e3529d40ee9f61ac08e712c23f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7e75ce3680424f2ebff779770a2d6e75", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 8 - train: 36.758 - valid: 36.797 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ee5fcc5547d3474291f531e564e265ba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f0d22c37c3134019b5d61fb0493a1a3b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=20.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 9 - train: 36.416 - valid: 36.49 - stale=0\n", + "\n" + ] + } + ], + "source": [ + "batch_size = 50\n", + "lr = 1e-4\n", + "epochs = 10\n", + "encoder = Encoder()\n", + "losses_train, losses_valid = train_encoder(encoder, data, batch_size, lr, epochs)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(range(len(losses_train[1:])), losses_train[1:], label=\"training\")\n", + "ax.plot(range(len(losses_valid[1:])), losses_valid[1:], label=\"validation\")\n", + "ax.set_xlabel(\"Epochs\")\n", + "ax.set_ylabel(\"Loss\")\n", + "ax.legend(title='ENCODER', loc=\"best\")\n", + "# plt.savefig(f\"{outpath}/training_plots/losses/loss_{epoch}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train MLPF" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "class MLPF(nn.Module):\n", + " def __init__(\n", + " self,\n", + " input_dim=7,\n", + " num_classes=6,\n", + "# output_dim=5,\n", + " num_convs=2,\n", + " k=8,\n", + " ):\n", + " super(MLPF, self).__init__()\n", + "\n", + " # self.act = nn.ReLU\n", + " self.act = nn.ELU\n", + "\n", + "# # (1) embedding\n", + "# self.nn1 = nn.Sequential(\n", + "# nn.Linear(input_dim, 126),\n", + "# self.act(),\n", + "# nn.Linear(126, 126),\n", + "# self.act(),\n", + "# nn.Linear(126, 34),\n", + "# )\n", + "\n", + " self.conv = nn.ModuleList()\n", + " for i in range(num_convs):\n", + " self.conv.append(GravNetConv(input_dim, input_dim, space_dimensions=4, propagate_dimensions=22, k=16))\n", + "\n", + " # classifiying pid\n", + " self.nn2 = nn.Sequential(\n", + " nn.Linear(input_dim, 126),\n", + " self.act(),\n", + " nn.Linear(126, 126),\n", + " self.act(),\n", + " nn.Linear(126, num_classes),\n", + " )\n", + "\n", + "\n", + " def forward(self, batch):\n", + "\n", + " # unfold the Batch object\n", + " input_ = batch.x.float()\n", + " batch = batch.batch\n", + "\n", + " # perform a series of graph convolutions\n", + " for num, conv in enumerate(self.conv):\n", + " embedding = conv(input_, batch)\n", + "\n", + " # predict the pid's\n", + " preds_id = self.nn2(embedding)\n", + "\n", + " # predict the p4's\n", + "# preds_p4 = self.nn3(torch.cat([input_, embedding, preds_id], axis=-1))\n", + "\n", + " return preds_id" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "# combine the learned latent representations back into one Batch() object that will be the input to MLPF\n", + "def combine_PFelements(tracks, clusters):\n", + " \n", + " event = Batch(x = torch.cat([tracks.x, clusters.x]),\n", + " ygen = torch.cat([tracks.ygen, clusters.ygen]),\n", + " ygen_id = torch.cat([tracks.ygen_id, clusters.ygen_id]),\n", + " ycand = torch.cat([tracks.ycand, clusters.ycand]),\n", + " ycand_id = torch.cat([tracks.ycand_id, clusters.ycand_id]),\n", + " batch = torch.cat([tracks.batch, clusters.batch]),\n", + " )\n", + " \n", + " return event" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_weights(target_ids, num_classes):\n", + " \"\"\"\n", + " computes necessary weights to accomodate class imbalance in the loss function\n", + " \"\"\"\n", + "\n", + " vs, cs = torch.unique(target_ids, return_counts=True)\n", + " weights = torch.zeros(num_classes)\n", + " for k, v in zip(vs, cs):\n", + " weights[k] = 1.0 / math.sqrt(float(v))\n", + " # weights[2] = weights[2] * 3 # emphasize nhadrons\n", + " return weights\n", + "\n", + "def train_mlpf(model, with_VICreg, epochs):\n", + " \n", + " lr = 1e-3\n", + " optimizer = torch.optim.SGD(model.parameters(), lr=lr)#, momentum= 0.9, weight_decay=1.5e-4)\n", + "\n", + " patience = 20\n", + " best_val_loss = 99999.9\n", + " stale_epochs = 0\n", + "\n", + " losses_train = []\n", + " losses_valid = []\n", + "\n", + " encoder.eval()\n", + " model.train()\n", + "\n", + " for epoch in tqdm(range(epochs)):\n", + "\n", + " loss_train = 0\n", + "\n", + " for batch in tqdm(train_loader):\n", + " if with_VICreg:\n", + " # make transformation\n", + " tracks, clusters = distinguish_PFelements(batch)\n", + "\n", + " # make encoder forward pass \n", + " embedding_tracks, embedding_clusters = encoder(tracks, clusters)\n", + "\n", + " # use the learnt representation as your input\n", + " tracks.x = embedding_tracks\n", + " clusters.x = embedding_clusters\n", + " event = combine_PFelements(tracks, clusters)\n", + "\n", + " else:\n", + " event = batch\n", + " \n", + " # make mlpf forward pass\n", + " pred_ids_one_hot = model(event)\n", + " pred_ids = torch.argmax(pred_ids_one_hot, axis=1)\n", + " target_ids = event.ygen_id\n", + "\n", + " weights = compute_weights(target_ids, num_classes=6) # to accomodate class imbalance\n", + " loss = torch.nn.functional.cross_entropy(pred_ids_one_hot, target_ids, weight=weights) # for classifying PID\n", + "\n", + " # update parameters\n", + " for param in model.parameters():\n", + " param.grad = None\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " loss_train += loss.detach()\n", + "\n", + " loss_valid = 0\n", + "\n", + " for batch in tqdm(val_loader):\n", + " if with_VICreg: \n", + " # make transformation\n", + " tracks, clusters = distinguish_PFelements(batch)\n", + "\n", + " # make encoder forward pass \n", + " embedding_tracks, embedding_clusters = encoder(tracks, clusters)\n", + "\n", + " # use the learnt representation as your input\n", + " tracks.x = embedding_tracks\n", + " clusters.x = embedding_clusters\n", + " event = combine_PFelements(tracks, clusters)\n", + "\n", + " else:\n", + " event = batch\n", + " \n", + " # make mlpf forward pass\n", + " pred_ids_one_hot = model(event)\n", + " pred_ids = torch.argmax(pred_ids_one_hot, axis=1)\n", + " target_ids = event.ygen_id\n", + "\n", + " weights = compute_weights(target_ids, num_classes=6) # to accomodate class imbalance\n", + " loss = torch.nn.functional.cross_entropy(pred_ids_one_hot, target_ids, weight=weights) # for classifying PID\n", + "\n", + " loss_valid += loss.detach()\n", + "\n", + " print(f\"epoch {epoch} - train: {round(loss_train.item(),3)} - valid: {round(loss_valid.item(), 3)} - stale={stale_epochs}\")\n", + "\n", + " losses_train.append(loss_train/len(train_loader)) \n", + " losses_valid.append(loss_valid/len(val_loader))\n", + "\n", + " # early-stopping\n", + " if losses_valid[epoch] < best_val_loss:\n", + " best_val_loss = losses_valid[epoch]\n", + " stale_epochs = 0\n", + " else:\n", + " stale_epochs += 1\n", + " \n", + " fig, ax = plt.subplots()\n", + " ax.plot(range(len(losses_train[1:])), losses_train[1:], label=\"training\")\n", + " ax.plot(range(len(losses_valid[1:])), losses_valid[1:], label=\"validation\")\n", + " ax.set_xlabel(\"Epochs\")\n", + " ax.set_ylabel(\"Loss\")\n", + " ax.legend(loc=\"best\")\n", + " # plt.savefig(f\"{outpath}/training_plots/losses/loss_{epoch}.pdf\") \n", + " return losses_train, losses_valid" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a9e502dc07e64411aa9bf8513ec878c2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ef34d472f208450f828b2c80b6d5d4dc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1c126660634b4d98873f8a12a1c284ff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 0 - train: 3193.634 - valid: 740.271 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8c9f82c8bfb34a3a9d6e6729998f2f65", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cef00ac52ef449298856b7ab5788ba40", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 1 - train: 2765.493 - valid: 632.045 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fe840ebe5c8e4803a91f403cf297cc54", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c1f7d5a85ccd4448bd1d3c8629ce822c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 2 - train: 2289.135 - valid: 523.715 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a131e1cbffd14fd499bb73fdde563f5c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bdc6d43c50f347b2b078e65a4e837f12", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 3 - train: 2005.196 - valid: 487.104 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6c2edb7274264d26b27201163166c528", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0dc5ace5156e4608bc1f3e131e7983ad", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 4 - train: 1921.538 - valid: 476.155 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf84b91f1f1146d19171ae2e7e949468", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8b54fd22d236435e977384f34c135f75", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 5 - train: 1893.737 - valid: 471.735 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "66db36a662fb4e97b65bc220c3d07418", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ea765317833741109a0ea93f0c3e01e1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 6 - train: 1880.977 - valid: 469.31 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e77510e4fa6e4490b720da78e7e4e233", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "301f4aff2eae41b5b982cbb05358872f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 7 - train: 1873.334 - valid: 467.709 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7d08c7a296974017bcb2e8c387c5925b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9582cdf2fec941e8be126111919d67cd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 8 - train: 1867.919 - valid: 466.504 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0f9f0c967bb14e0bb48bdeb35cc1087b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "63c23563416b4717ab6b22f3d4f63453", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 9 - train: 1863.764 - valid: 465.55 - stale=0\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# train ssl version of MLPF\n", + "model_ssl = MLPF(input_dim=encoder.nn1[-1].out_features)\n", + "losses_train_ssl, losses_valid_ssl = train_mlpf(model_ssl, with_VICreg=True, epochs=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a2fb0ee372cc4cb489b18f437333b3a1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "adb0682691c5411a9a646299b3bcdadc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d6fb47fa713e4c47969d11bdd2a4ca7b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 0 - train: 2298.198 - valid: 463.414 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "686c04e7e0284fa58a9f724148c09d7f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c2e6152af87e41d79e3b62c8663c971a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 1 - train: 1828.671 - valid: 451.828 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d6168d2d9a2746f6a4949142f4187a5f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e2f34653104e49a9b8ce17386105b6ed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 2 - train: 1792.308 - valid: 445.158 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a33e5c790a924dfa9814c59e8b256c34", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "906bb04688c24e308b096b2e790dae60", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 3 - train: 1767.835 - valid: 440.353 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e8693c470e524b0f93bec039e5ba9856", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8626a1006be246e7a88e670d818a105d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 4 - train: 1749.164 - valid: 436.555 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "29b86cb796a24af9a807f88e45bdb877", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f2db90829bec4d869f10f40e349e1521", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 5 - train: 1735.027 - valid: 433.909 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9b7b58a37572493f9c467e254fe23533", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "658bacf953724818a3c504c5283048ab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 6 - train: 1724.229 - valid: 431.72 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "92eb12168c024631ae667daeaa407716", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a95b8b4c5b1347088f2b82f032ea1f3f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 7 - train: 1715.633 - valid: 429.531 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b77d6b9b68884284b55d0d6105fcbfa6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d78ca1adac4d4a2a8183473341f143a4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 8 - train: 1708.568 - valid: 427.856 - stale=0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7946ce9da1064ce6b3d91d1a0ce8ad25", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=2000.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf697dd1d68d43c68f7b72a17745bab0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=500.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "epoch 9 - train: 1702.787 - valid: 426.593 - stale=0\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# train native MLPF\n", + "model = MLPF(input_dim=8)\n", + "losses_train, losses_valid = train_mlpf(model, with_VICreg=False, epochs=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate the SSL against native MLPF" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "def evaluate_mlpf(model, with_VICreg):\n", + " num_classes = 6\n", + " conf_matrix = np.zeros((num_classes, num_classes))\n", + "\n", + " for i, batch in tqdm(enumerate(test_loader)):\n", + " if with_VICreg:\n", + " # make transformation\n", + " tracks, clusters = distinguish_PFelements(batch)\n", + "\n", + " # make encoder forward pass \n", + " embedding_tracks, embedding_clusters = encoder(tracks, clusters)\n", + "\n", + " # use the learnt representation as your input\n", + " tracks.x = embedding_tracks\n", + " clusters.x = embedding_clusters\n", + " event = combine_PFelements(tracks, clusters)\n", + " \n", + " else:\n", + " event = batch\n", + " \n", + " # make mlpf forward pass\n", + " pred_ids_one_hot = model(event)\n", + " pred_ids = torch.argmax(pred_ids_one_hot, axis=1)\n", + " target_ids = event.ygen_id\n", + "\n", + " conf_matrix += sklearn.metrics.confusion_matrix(\n", + " target_ids.detach().cpu(), pred_ids.detach().cpu(), labels=range(num_classes)\n", + " )\n", + " return conf_matrix\n", + "\n", + "CLASS_NAMES_CLIC_LATEX = [\"none\", \"chhad\", \"nhad\", \"$\\gamma$\", \"$e^\\pm$\", \"$\\mu^\\pm$\"]\n", + "\n", + "def plot_conf_matrix(cm, title):\n", + " import itertools\n", + "\n", + " cmap = plt.get_cmap(\"Blues\")\n", + " cm = cm.astype(\"float\") / cm.sum(axis=1)[:, np.newaxis]\n", + " cm[np.isnan(cm)] = 0.0\n", + "\n", + " fig = plt.figure(figsize=(8, 6))\n", + "\n", + " ax = plt.axes()\n", + " plt.imshow(cm, interpolation=\"nearest\", cmap=cmap)\n", + "\n", + " plt.colorbar()\n", + "\n", + " # tick_marks = np.arange(len(target_names))\n", + " # plt.xticks(tick_marks, target_names, rotation=45)\n", + " # plt.yticks(tick_marks, target_names)\n", + "\n", + " thresh = cm.max() / 1.5\n", + " for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n", + " plt.text(\n", + " j,\n", + " i,\n", + " \"{:0.2f}\".format(cm[i, j]),\n", + " horizontalalignment=\"center\",\n", + " color=\"white\" if cm[i, j] > thresh else \"black\",\n", + " )\n", + " plt.title(title)\n", + " plt.ylabel(\"True label\")\n", + "\n", + " plt.xticks(range(len(CLASS_NAMES_CLIC_LATEX)), CLASS_NAMES_CLIC_LATEX, rotation=45)\n", + " plt.yticks(range(len(CLASS_NAMES_CLIC_LATEX)), CLASS_NAMES_CLIC_LATEX)\n", + "\n", + " plt.xlabel(\"Predicted label\")\n", + " # plt.xlabel('Predicted label\\naccuracy={:0.4f}; misclass={:0.4f}'.format(accuracy, misclass))\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb047f3234f745c5a7d0d7a3fe67888a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "conf_matrix = evaluate_mlpf(model, with_VICreg=False)\n", + "plot_conf_matrix(conf_matrix, 'native MLPF')" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5ba1dd8272f44227b9b0da6ed20c8038", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "conf_matrix_ssl = evaluate_mlpf(model_ssl, with_VICreg=True)\n", + "plot_conf_matrix(conf_matrix_ssl, 'ssl MLPF')" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c8c9bfbe5622404a9960e7011a59ecf5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# make confusion matrix of PF for comparison\n", + "num_classes = 6\n", + "conf_matrix_pf = np.zeros((num_classes, num_classes))\n", + "for i, batch in tqdm(enumerate(test_loader)):\n", + "\n", + " # make mlpf forward pass\n", + " target_ids = batch.ygen_id\n", + " pred_ids = batch.ycand_id\n", + " \n", + " conf_matrix_pf += sklearn.metrics.confusion_matrix(\n", + " target_ids.detach().cpu(), pred_ids.detach().cpu(), labels=range(num_classes)\n", + " )\n", + "plot_conf_matrix(conf_matrix_pf, 'PF')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}