05_Event_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "925ec8dc-bc27-46e1-8498-3803fe3d238a",
   "metadata": {},
   "source": [
    "# 5. Event Classification - Classifying Process Events With a Neural Network"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15d5b8ea-4e6a-4bc7-8f01-7dbb76158aa1",
   "metadata": {},
   "source": [
    "In the last notebook a neural network was constructed and trained in keras. \n",
    "\n",
    "We will now use the newly gained insight to build and train a neural network suited for the classification of events that have been selected in the very first notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "81b9272d-6e01-456b-957d-a49ebd6d7b72",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2b80bfff-fcd2-426c-bf95-bc0cf5730673",
   "metadata": {},
   "outputs": [],
   "source": [
    "# open the neural network input vectors\n",
    "nn_input = {}\n",
    "\n",
    "# processes that will be used in training (bgr_Wj is excluded)\n",
    "processes = ['signal', 'bgr_tt', 'bgr_st']\n",
    "\n",
    "for process in processes:\n",
    "    nn_input[process] = np.loadtxt('nn_input_' + process + '.txt', delimiter = ' ')\n",
    "    \n",
    "    # simplify data structure by transposing\n",
    "    nn_input[process] = np.transpose(nn_input[process]).tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c595506-720d-4317-b03e-ce47dd3bcdea",
   "metadata": {},
   "source": [
    "## Neural network and training"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48cc47f6-ac7e-497e-82f0-a30cb7849608",
   "metadata": {},
   "source": [
    "Not only do we want to understand if the event in question is part of the signal or the background, we also want to be able to differentiate the various background processes. Essentially, we are building a *multiclassifier* neural network. This means that the network, instead of returning a binary \"signal\" or \"background\" response, returns an output vector of which each element is associated with the probablility of identifying the events as stemming from the various processes. In our case we have 3 processes that have to be distinguished from one another (the background W + jets is not being considered here, since it's sample size is too small to make any meaningful training with it); an exemplary output vector of the shape (0 0 1) would indicate the ideal case of identifying an event as a single top background event.\n",
    "\n",
    "The process of constructing the neural network is shown in the following two cells and is very much reminiscient of how the exemplary neural network was set up in the third notebook. As to the structure of the network, in total 5 layers will be used where the input layer consists of 10 nodes corresponding to the various physical observables of the selected events, the output layer consists of 3 nodes corresponding to the three processes the events are meant to be classified as. The three hidden layers in between have 512 nodes. They are quite large such that they are capable of picking up on the differentiating nuances in the events. A certain number of hidden layers and their layer sizes directly affects the training duration. Thus the number of layers and layer sizes must be chosen in a way such that the training can be completed in a reasonable time frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b58c7fc1-793d-445a-b7e3-dd6e7b28c30d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer structure of the network:  [10, 512, 512, 512, 3]\n"
     ]
    }
   ],
   "source": [
    "# define structure of the network\n",
    "\n",
    "# dimensions of input, hidden and output layers\n",
    "N0 = len(nn_input['signal'][0])\n",
    "N1 = 512\n",
    "N2 = len(processes)\n",
    "\n",
    "# number of hidden layers\n",
    "layer_count = 3\n",
    "\n",
    "# layer structure of the network\n",
    "layers = [N0]\n",
    "\n",
    "for l in range(layer_count):\n",
    "    layers.append(N1)\n",
    "    \n",
    "layers.append(N2)\n",
    "\n",
    "print(\"Layer structure of the network: \", layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4600db0-5285-4efe-abba-97af3f34ac62",
   "metadata": {},
   "source": [
    "The activation function of the output layer is chosen to be a *softmax* instead of the sigmoid that is being used everywhere else. That is because the softmax function in normalized in a way, such that the ouput is a number between 0 and 1 and can be read as a probability:\n",
    "\n",
    "### $(1) \\,\\,\\, \\sigma(\\vec{z})_{i} = \\frac{e^{z_{i}}}{\\sum{e^{z_{j}}}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e4e4cc96-2cff-416c-931d-93b3e807f512",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-09-12 15:12:02.130770: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2022-09-12 15:12:02.130813: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n",
      "2022-09-12 15:12:04.689589: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory\n",
      "2022-09-12 15:12:04.689629: W tensorflow/stream_executor/cuda/cuda_driver.cc:269] failed call to cuInit: UNKNOWN ERROR (303)\n",
      "2022-09-12 15:12:04.689664: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (batch1361.desy.de): /proc/driver/nvidia/version does not exist\n",
      "2022-09-12 15:12:04.689967: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.initializers import RandomUniform\n",
    "\n",
    "# construct the network in keras\n",
    "net = Sequential()\n",
    "\n",
    "# set the weights initializer\n",
    "initializer = RandomUniform(minval = -1, maxval = 1)\n",
    "\n",
    "# make the first layer with the input shape as an argument\n",
    "net.add(Dense(layers[1], input_shape = (layers[0],), activation = 'sigmoid', \n",
    "              use_bias = True, kernel_initializer = initializer))\n",
    "\n",
    "# make hidden layers\n",
    "for i in range(2, len(layers) - 1):\n",
    "    net.add(Dense(layers[i], activation = 'sigmoid', use_bias = True, kernel_initializer = initializer))\n",
    "\n",
    "# make output layer\n",
    "net.add(Dense(layers[-1], activation = 'softmax', use_bias = True, kernel_initializer = initializer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0002f706-f9aa-42bd-8144-31b1e8ab8a7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# compile the network\n",
    "net.compile(loss = 'categorical_crossentropy', \n",
    "            optimizer = keras.optimizers.SGD(learning_rate = 0.0001), \n",
    "            metrics = ['categorical_accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "804e20c5-525b-4ffa-a725-e6ed9df2f206",
   "metadata": {},
   "source": [
    "As the processes from which the exact training events are made are known, it is very simple to generate the target output which will be used for verification during training. As discussed above the target vectors have three elements (as many elements as processes that are meant to be differentiated) which are 0 except one of them which is 1 corresponding to the process that the event in question originated from. There are as many target vectors being made as there are input vectors and depending on the process they are of the form (1 0 0), (0 1 0) or (0 0 1). Similar to the input vectors the target vectors are stored in a dictionary for the respective processes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6370bd11-32a8-4d54-bce5-fa5dadfa7c59",
   "metadata": {},
   "outputs": [],
   "source": [
    "# making of the target output\n",
    "\n",
    "# target dictionary\n",
    "nn_target = {}\n",
    "\n",
    "# make target data for a particular process\n",
    "def make_target(p, proc):\n",
    "    \n",
    "    vectors = np.zeros((len(nn_input[proc]), len(processes)))\n",
    "    vectors[:, p] = 1\n",
    "    vectors = list(vectors)\n",
    "    \n",
    "    return vectors, len(vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "501a0c84-c243-4f16-903d-0fc97859c22c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "# make target data for all processes\n",
    "for count, process in enumerate(processes):\n",
    "    nn_target[process] = make_target(count, process)[0]\n",
    "\n",
    "print(nn_target['signal'][10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fbf5d3ae-5004-47e1-a423-c0a8c109f6b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of epochs\n",
    "epochs = 200\n",
    "\n",
    "# cost\n",
    "costs = np.empty(epochs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cacdd94c-b285-47e6-92fa-ee26d2858ee8",
   "metadata": {},
   "source": [
    "For the training ideally the same number of events for each process are used during training. This way the network won't focus on a particular process, which could lead to a very biased classification. In our case this can only fullfilled when using less than 4344 events for the processes respectively (number of signal events). There are far more background process events present than there are signal events. In spite of this disparity training can still be performed. For now, a limiter `max_limit` is set for the maximum number of events used from a process. The whole data set is split into training, validation and testing sets where the first 60% of events from each process are used for training, 20% are used for validation during training but not for training and the final 20% is used for testing, which the network is never exposed to during training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7477f107-f92d-44f2-88be-cd6a85636dd5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8606, 10)\n",
      "(8606, 3)\n",
      "(2869, 10)\n",
      "(2869, 3)\n",
      "(2869, 10)\n",
      "(2869, 3)\n"
     ]
    }
   ],
   "source": [
    "# put input and target data all in one array\n",
    "\n",
    "# storage lists for training data\n",
    "nn_input_training = []\n",
    "nn_target_training = []\n",
    "\n",
    "# storage lists for validation data\n",
    "nn_input_validation = []\n",
    "nn_target_validation = []\n",
    "\n",
    "# storage lists for test data\n",
    "nn_input_test = []\n",
    "nn_target_test = []\n",
    "\n",
    "# splitting of data to training, validation and testing\n",
    "full_split = np.array([len(nn_input[process]) for process in processes])\n",
    "\n",
    "# maximum number of events to be used from each process\n",
    "max_limit = 5000\n",
    "\n",
    "for count, i in enumerate(full_split):\n",
    "    if i >= max_limit:\n",
    "        full_split[count] = max_limit\n",
    "\n",
    "training_split = full_split * 6 // 10\n",
    "validation_split = (full_split - training_split) // 2 + training_split\n",
    "test_split = (full_split - training_split) + training_split\n",
    "\n",
    "for count, process in enumerate(processes):\n",
    "    # first 3000 events from each process are used for the training\n",
    "    nn_input_training = nn_input_training + nn_input[process][:training_split[count]]\n",
    "    nn_target_training = nn_target_training + nn_target[process][:training_split[count]]\n",
    "    \n",
    "    # remaining 1344 events are used for validation\n",
    "    nn_input_validation = nn_input_validation + nn_input[process][training_split[count]:validation_split[count]]\n",
    "    nn_target_validation = nn_target_validation + nn_target[process][training_split[count]:validation_split[count]]\n",
    "    \n",
    "    # for testing\n",
    "    nn_input_test = nn_input_test + nn_input[process][validation_split[count]:test_split[count]]\n",
    "    nn_target_test = nn_target_test + nn_target[process][validation_split[count]:test_split[count]]\n",
    "\n",
    "nn_input_training = np.array(nn_input_training)\n",
    "nn_target_training = np.array(nn_target_training)\n",
    "\n",
    "nn_input_validation = np.array(nn_input_validation)\n",
    "nn_target_validation = np.array(nn_target_validation)\n",
    "\n",
    "nn_input_test = np.array(nn_input_test)\n",
    "nn_target_test = np.array(nn_target_test)\n",
    "    \n",
    "print(np.shape(nn_input_training))\n",
    "print(np.shape(nn_target_training))\n",
    "print(np.shape(nn_input_validation))\n",
    "print(np.shape(nn_target_validation))\n",
    "print(np.shape(nn_input_test))\n",
    "print(np.shape(nn_target_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "019a3c36-5e9a-4bb8-bbdf-ca76806e2a4a",
   "metadata": {},
   "source": [
    "Now that all the training and validation data is prepared the network is finally trained. For this the function `fit` is used, which takes training and validation data as arguments, takes the epochs i.e. the number of times the same batch of data should be trained on and most importantly shuffles the input data for training. This is very important to guarantee unbiased training. If this setting was `False` then the network's classification would scew towards the process which was trained on last. Training works best when the data to be classified is fed to the network in a random order, hence the shuffling. Additionally class weights are given for the various processes to make up for the event number disparity by making the network \"pay more attention\" to the classes which are underrepresented. The weights are chosen such that the product of the number of events of a process and its class weight equals the number of events of the process with the most events.\n",
    "\n",
    "The function returns a history object which stores information about the performance of the network and the progression of the training. These metrics (loss, validation loss, categorical accuracy and validation categorical accuracy) can be viewed with the `history` attribute. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f4126838-6789-41ae-a7f8-df62b9c324a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4344 5000 5000]\n",
      "{0: 1.1510128913443831, 1: 1.0, 2: 1.0}\n"
     ]
    }
   ],
   "source": [
    "print(full_split)\n",
    "\n",
    "# class weight dictionary\n",
    "class_weights = {}\n",
    "\n",
    "# calculating class weights\n",
    "for count, number in enumerate(full_split):\n",
    "    class_weights[count] = np.max(full_split) / number\n",
    "    \n",
    "print(class_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "094d2315-fd32-461e-b061-85a6043acfd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# training\n",
    "history = net.fit(x = nn_input_training, y = nn_target_training, epochs = epochs, class_weight = class_weights,\n",
    "                  validation_data = (nn_input_validation, nn_target_validation), shuffle = True, verbose = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d1c3a931-dfea-4158-a78a-66d38f4f7b6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss\n",
      "categorical_accuracy\n",
      "val_loss\n",
      "val_categorical_accuracy\n"
     ]
    }
   ],
   "source": [
    "# print history categories\n",
    "for i in history.history:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f918e9fe-a7bb-4fb2-a710-1b1013fc29a5",
   "metadata": {},
   "source": [
    "The losses and accuracies of training and validation can be plotted and compared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1d5277ac-44e2-4b29-8bd0-3431c28afc89",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lowest loss value:  1.0539062023162842\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmYAAAHCCAYAAABFSQXvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABW2ElEQVR4nO3dd3gU1f4G8Hdma3pvJEiAoNQQIBJEOgYUIRdBRESFCwp41d8FFbCDHQsaK17sPUpHmiKKFKMQBJWmoIQSAikQkpBssmV+f8zuJksKuyGzu0nez/PssztlZ7+TDeb1nDlnBEmSJBARERGRx4meLoCIiIiIZAxmRERERF6CwYyIiIjISzCYEREREXkJBjMiIiIiL8FgRkREROQlGMyIqEX56quv0KVLF+h0OgiCgKKiIk+XVKvNmzdDEARs3rzZ06UQkRsxmBHRJfnwww8hCAK2bdvm6VIu6vDhw5g4cSKio6OxaNEifPLJJ/Dz8/NoTenp6fj44489WgMReQ+1pwsgInKXzZs3w2QyYeHChUhKSvJ0OQDkYJaQkIDbb7/dYf2AAQNQXl4OrVbrocqIyBMYzIioxcjLywMABAcHe7YQJ4iiCL1e7+kyiMjN2JVJRG5x/Phx3HrrrYiIiIBer0f37t3x4Ycf1thv2bJlSElJQVBQEPz8/JCQkIC77rrL5X0uFB8fj0ceeQQA0LZtWwiCgMmTJwMABg0ahEGDBtV4z/z58yEIgsM6QRBwxx13YP369ejRowf0ej0SEhLw+eef13i/0WjEggUL0KVLF+j1ekRERCA1NRVbt261H+vo0aPYtGkTBEGAIAj2Ouq6xmz79u0YOnQo/P394e/vj6FDhyIzM9NhH1v38g8//ICHHnoI0dHR8PHxQWpqKo4cOVLvz4mIPIstZkSkuIKCAvTt2xeFhYW49957ERsbi6+++gr//ve/UVBQgAceeAAAsGnTJowbNw6DBg3CM888A41Gg3/++Qfr16+3H8uZfWqTnp6Ozz77DEuXLsUrr7yC8PBwtG/fvkHns3PnTnz99deYMWMGpk6dinfffRe33XYbevTogU6dOgEALBYLRo8ejXXr1iEtLQ3Tp0+H0WjETz/9hC1btqB///745JNPMGvWLERFReHBBx8EAERFRdX5uVu2bEFqaipatWplD5n/+9//MHjwYGzatAlXX321w/6zZ8+GXq/Hww8/jIKCArz00kuYOHEifvrppwadNxG5gUREdAk++OADCYC0devWOve5//77JQDShg0b7OsqKyulq666StLr9VJBQYEkSZI0c+ZMKTAwUDKZTHUey5l96vLUU09JAKQjR444rB84cKA0cODAGvvPmzdPuvA/kwAklUol/fHHH/Z1p06dkrRarfTAAw/Y13300UcSAGnevHk1jmuxWOyv27RpIw0dOrTGPj/88IMEQPrhhx/s63r16iUFBwdLp06dsq87efKkFBgYKF155ZX2dbbvpG/fvg4/p1deeUUCIO3du7fG5xGRd2BXJhEpbs2aNejatSuGDx9uX6fRaDBr1iwYDAZs2rQJgHzt1/nz57F+/XpIklTrsZzZR2kDBgxA165d7ctRUVHo2LEj/vnnH/u6JUuWIDAw0N4SVt2F3aPOOHXqFHbt2oXbbrvNoVUtJiYGt956K3bu3Gm/hs5m+vTpUKlU9uWBAwcCgEOdRORdGMyISHHZ2dn2Lr7qOnfuDAD2657+85//oHPnzhg1ahRiYmIwYcIEfPHFFzAajfb3OLOP0tq0aVNjXUhICM6cOWNfPnz4MBISEhrtAv7s7GwAQMeOHWtsu/DnWFedISEhAOBQJxF5FwYzIvIaERER+PXXX/HNN9/glltuwd69e3HLLbcgJSUFZWVlTu/jqrpasMxmc63rq7dCVeepFry6NJU6iagKgxkRKS4+Ph4HDx6ssf7AgQMA5FGSNmq1GsOGDcPLL7+MP/74A2+99RZ2796NJUuWuLSPK0JCQmq9A4CtlaohEhIScOjQIRgMhnr3c7ZbMz4+HgCc/jkSUdPEYEZEihs1ahT++OMPbNy40b7OZDIhPT0der0e11xzDQCgsLCwxnt79OgBAPbg5Mw+rkpISMCBAwdw+vRp+7qcnBysXLmyQccDgHHjxqGkpAQLFiyosa16i5Wfn59TdUdHRyM5ORmffPKJw7Vkp06dwieffILevXsjMjKywfUSkXfgdBlE1Cg+/vjjWu/reOutt2Lu3LnIyMjA6NGj7dNlLFmyBNu3b8eLL76I0NBQAMAdd9yBvLw8DB06FJdddhkKCgrw9ttvw8/PD2lpaU7v46o77rgDCxcuxLBhw3DnnXeiqKgIixYtwhVXXIFdu3Y16Ji33norPv/8czzxxBPYs2cPhg4dCrPZjJ9++glJSUl4+OGHAQC9evXCp59+imeeeQbt27dHZGQkhgwZUusxFy5ciGuuuQZ9+vTBtGnTAMjTZRgMBrz88ssNqpOIvIxHx4QSUZNnm5qhrsfGjRslSZKko0ePSrfccosUFhYmabVaqVu3btL777/vcKylS5dK1113nRQdHS1ptVqpVatW0tixY6U9e/a4tE9d6pouQ5Ik6csvv5Q6dOggaTQaqVOnTlJGRkad02VMnTq1xvtrm3LDYDBITz75pHT55ZdLWq1WCg8Pl4YNGyZt27bNvs+xY8ek4cOHS/7+/hIA+zFqmy5DkiRp69at0uDBgyU/Pz/Jz89PGjx4sLR9+3aHfeqawuTIkSMSAOmDDz6o/wdFRB4jSBKvAiUiIiLyBrzGjIiIiMhLMJgREREReQkGMyIiIiIvwWBGRERE5CWaxXQZ4eHh9skXiYiIiLxZdnY2CgoKat3WLIJZfHw8srKyPF0GERER0UUlJyfXuY1dmURERERegsGMiIiIyEt4JJiZzWb06NEDI0eOrLGtoqIC48ePR0JCAlJSUi7pJsJERERETYlHgtmrr76KTp061brtvffeQ0hICA4fPoxZs2Zh7ty5bq6OiIiIyDPcHsxOnDiBtWvX4o477qh1+6pVqzBp0iQAwI033ohNmzaBd40iIiKilsDtwWzmzJl44YUXIIq1f3ROTg5at24NAFCr1QgKCkJhYWGN/RYvXozk5GQkJycjPz9f0ZqJiIiI3MGt02WsWbMGkZGR6NWrFzZv3nxJx5o2bRqmTZsGoP5hp0RERJ5QXFyMvLw8GI1GT5dCbqTRaBAZGYnAwMAGvd+twWz79u1YvXo11q1bB4PBgOLiYtx666349NNP7fvExsbi+PHjiIuLg8lkwrlz5xAWFubOMomIiC5JcXExTp8+jdjYWPj4+EAQBE+XRG4gSRLKy8uRk5MDAA0KZ27tynzuuedw4sQJZGdnIyMjA0OGDHEIZQCQlpaGjz76CACwdOlSDBkyhL/QRETUpOTl5SE2Nha+vr78G9aCCIIAX19fxMbGIi8vr0HH8IqZ/x9//HEkJycjLS0NU6dOxW233YaEhASEhoYiIyPD0+URERG5xGg0wsfHx9NlkIf4+Pg0uAvbY8Fs0KBBGDRoEADgySeftK/X6/VYsmSJh6oiIiJqHGwpa7ku5bvnzP9EREREXoLBjIiIiMhLMJgRERGRA0EQLvpo6LRX2dnZEAQBa9ascel9mzdvhiAI2Lt3b4M+t6nwiov/vZ3BaEZ24Xm0CvZBoF7j6XKIiIgUlZmZaX9dXl6OIUOG4NFHH8X1119vX9+5c+cGHTsmJgaZmZno2LGjS+/r2bMnMjMz0b59+wZ9blPBYOaEw3mlGPn6Nvzvtl4Y3iXa0+UQEREpqk+fPvbXpaWlAID27ds7rK/ObDbDbDZDq9Ve9Ng6na7O49QnMDCwQe9ratiV6QSVKI+usFh4z04iIqLJkycjOTkZK1euRJcuXaDX6/HLL78gNzcXU6ZMQbt27eDj44PLL78cjz76KCorK+3vra0rMz4+Hg888ABeeeUVxMXFISQkBDfffDOKiors+9TWlSkIAl599VU8/PDDiIiIQGRkJO6++25UVFQ41Lt582YkJiZCr9fjyiuvxI4dOxAeHo758+cr9jNqKLaYOcEWzMy8mToREREAOWDNmTMHjz/+OKKjo9G2bVsUFBQgNDQUL7/8MkJCQvDXX39h/vz5yM/Px//+9796j/fVV18hMTERixcvxokTJ3Dffffh4YcfxltvvVXv+xYuXGifsP7333/HQw89hDZt2mDOnDkA5HtwjxgxAn379sWzzz6LU6dOYeLEiSgvL2+0n0VjYjBzgmidj4QNZkRE1FBPfL0P+08We+SzO7cKxLxRXRr1mIWFhfjuu++QlJRkXxcXF4eXXnrJvnz11VfDz88PU6ZMweuvv15vV6dGo8HKlSuhVsvRZP/+/cjIyLhoMIuPj8eHH34IABg+fDi2b9+O5cuX24NZeno6fH198fXXX9sn/Q0MDMT48eMbctqKY1emE6wNZuzKJCIisoqNjXUIZYB8r8j09HR07twZPj4+0Gg0mDhxIioqKnDs2LF6jzd48GB7KAPkwQXO3AR+2LBhDsudO3fGiRMn7Ms7d+5Eamqqw50Y0tLSLnZ6HsMWMyfYuzIZzIiIqIEau8XK06KiomqsS09Px+zZszF37lwMHDgQISEh2LlzJ+6++24YDIZ6jxccHOywrNVqIUkSKioqoNHUPSNCbe+r/lmnTp1CYmKiwz56vR7+/v711uMpDGZOsHVl8hozIiIiWW23HVqyZAluvPFGPPPMM/Z1+/fvd2dZNURHRyM/P99hncFgsI829TbsynQCR2USERFdXHl5OXQ6ncO6zz77zEPVyK688kps3LjR4WL/1atXe7Ci+rHFzAkclUlERHRxqampeO2115CSkoL27dvjs88+w+HDhz1a08yZM/Hmm29i1KhRmDVrFk6dOoUFCxbA19cXouh97VPeV5EXso/KZIsZERFRnR5//HFMmDABjz76KCZMmACtVovXXnvNozXFxsZi7dq1yMvLw5gxY/D666/j/fffh9lsRmBgoEdrq40gSU2/GSg5ORlZWVmKHf/M+Ur0fGojnkjrgkl94xX7HCIiah4OHDiATp06eboMqsO2bdvQv39/fP/99xg8eLAin1Hf70B9uYVdmU6wTZfBUZlERERNz9y5c9GjRw9ER0fjzz//xFNPPYXExEQMHDjQ06XVwGDmBNF28X/Tb1wkIiJqcSoqKjB79mycPn0aAQEBGDZsGF5++WWvvMaMwcwJKoHzmBERETVV6enpSE9P93QZTvG+qOiFOCqTiIiI3IHBzAkclUlERETuwGDmhKpbMnm4ECIiImrWGMycYL+JObsyiYiISEEMZk4QBAGCwGBGREREymIwc5JKEDgqk4iIiBTFYOYkURQ4KpOIiFqEUaNGoVu3bnVuv+eeexAcHIyKiop6j7N582YIgoC9e/fa1wmCgDfeeKPe961ZswaCICA7O9ulul944QVs3ry5xnpnPtNbMJg5SSUIHJVJREQtwoQJE7B3717s37+/xjaz2YylS5dizJgx0Ol0Lh87MzMT48aNa4wya6grmCn5mY2NwcxJKlHgqEwiImoR/vWvf8HX1xdffPFFjW0//PADTp8+jQkTJjTo2H369EFUVNSlluj1n9lQDGZOEnnxPxERtRB+fn4YNWoUvvzyyxrbMjIyEBkZiVatWuHmm29G69at4evriy5duiA9PR0WS/2tGBd2K0qShPnz5yMyMhIBAQG4/fbbUVxcXON9Dz74ILp16wZ/f3/ExcVh4sSJOHXqlH17fHw8CgsL8cQTT1gH7Qn21rPaujLfeOMNdOjQATqdDgkJCXjllVccts+fPx/h4eHYvXs3+vTpA19fX/To0QNbt2696M/vUjCYOUkUBQYzIiJqMSZMmIBDhw5h165d9nVGoxHLly/HTTfdhFOnTuGKK67AW2+9hXXr1uHOO+/EvHnz8Pzzz7v0Oa+99hqefPJJTJs2DUuXLoWPjw/mzJlTY7+8vDw8/PDDWLt2LdLT0/HPP/9gyJAh9iC4YsUKBAUFYerUqcjMzERmZiZ69uxZ62e+8847uPfee5GWloavv/4a48aNw/33348FCxY47FdWVoZJkyZh+vTpWLZsGXQ6HcaMGYOysjKXztEVvFemkzgqk4iILsn6B4FTf3jms6O7AdctuPh+1Vx33XUIDg5GRkYGevXqBQD45ptvcPbsWUyYMAF9+/bF0KFDAcitXv369UNZWRneeecdPPTQQ059htlsxvPPP4/p06fj6aefBgAMHz4cqampyMnJcdj3/fffd3jfVVddhbi4OGzbtg0DBgxAjx49oFarERcXhz59+tT5mRaLBfPnz8fkyZOxcOFCAMCwYcNw7tw5PPfcc5g5cyb0ej0AoLy8HOnp6RgyZAgAICYmBj169MCWLVtw7bXXOnWOrmKLmZPYYkZERC2JVqvFmDFj8NVXX0Gy/v378ssv0aZNG1x11VUwGAyYN28eEhISoNPpoNFo8Mgjj+DIkSMwmUxOfcbx48eRm5uLf/3rXw7rx4wZU2Pf9evXo2/fvggKCrIHMAD466+/XDqvEydO4OTJkzUGA4wfPx7FxcX444+q8KzVajFo0CD7cufOne3HUApbzJzEFjMiIrokLrZYeYMJEybg/ffft3cLrlq1Cv/5z38gCALmzp2Ld999F/PmzUPPnj0RHByMVatW4emnn4bBYIC/v/9Fj2+7RiwyMtJh/YXLO3fuRFpaGm644QY8+OCDiIyMhCAI6NOnDwwGg0vnlJubCwA1BgPYls+cOWNfFxAQAFGsasPSarUA4PJnuoLBzEkclUlERC3N4MGDERUVhYyMDOTm5qKkpMQ+GnPJkiW49957Ha4HW7t2rUvHj46OBiBfP1bdhcsrVqxAREQEvvzySwiCfJ/Eo0ePunw+gNwdWdtnnD59GgAQGhraoOM2FnZlOkkUOSqTiIhaFpVKhZtuuglLlizB559/jk6dOqF79+4A5Ouvqs9jZjabkZGR4dLxW7dujejoaKxatcph/fLlyx2Wy8vLodFo7KEMAD777LMax9NqtRdtzYqLi0OrVq2wZMkSh/VfffUVAgMD651Y1x3YYuYkdmUSEVFLNGHCBLz++utYsWIFnnjiCfv61NRUvPnmm0hISEBoaCjefPPNi94J4EIqlQpz5szBAw88gPDwcPTv3x/Lli3DgQMHHPZLTU1Feno6Zs6ciVGjRuGnn37Cp59+WuN4HTt2xNq1a3HttdfC398fV1xxBQICAhz2EUUR8+fPx/Tp0xEWFobU1FT8+OOPWLRoEZ599ln7hf+ewhYzJ4kCL/4nIqKW56qrrkJ8fDwkSXKYVPb1119H//79cffdd2PKlCno2rWr06Mxq5s5cyYefvhhvP322xg7dixKS0vxwgsvOOwzYsQIPP/881i2bBnS0tLw448/Ys2aNTWO9eKLL8LPzw/XX389rrzySoepPqq788478eqrr2LFihUYOXIkvvjiCyxcuBAPPvigy/U3NkGSmn7aSE5ORlZWlqKfcc3LP+LyKH+8NbGXop9DRERN34EDB9CpUydPl0EeVN/vQH25hS1mTmJXJhERESmNwcxJIkdlEhERkcIYzJyk4qhMIiIiUhiDmZPYlUlERERKYzBzEm/JRERErmgGY+uogS7lu2cwcxKnyyAiImdpNBqUl5d7ugzyENuEuA3BYOYkdmUSEZGzIiMjkZOTg7KyMractSCSJKGsrAw5OTk17vfpLM787yRRBCwclUlERE4IDAwEAJw8eRJGo9HD1ZA7aTQaREVF2X8HXMVg5iSVKMDI+TKIiMhJgYGBDf7jTC0XuzKdJLIrk4iIiBTGYOYkFUdlEhERkcLcGswMBgN69+6N7t27o0uXLpg3b16NfT788ENEREQgKSkJSUlJePfdd91ZYp148T8REREpza3XmOl0Onz//ffw9/eH0WhEv379cN1116FPnz4O+40fPx5vvPGGO0u7KEEQwFxGRERESnJri5kgCPD39wcAGI1GGI1GCILgzhIaTCUCFiYzIiIiUpDbrzEzm81ISkpCZGQkUlNTkZKSUmOfZcuWITExETfeeCOOHz9e63EWL16M5ORkJCcnIz8/X+myoRIFmHmNGRERESnI7cFMpVJhz549OHHiBHbs2IG9e/c6bB81ahSys7Px+++/IzU1FZMmTar1ONOmTUNWVhaysrIQERGheN2iILDFjIiIiBTlsVGZwcHBGDx4MDZs2OCwPiwsDDqdDgBwxx13YNeuXZ4orwa2mBEREZHS3BrM8vPzUVRUBEC+j9TGjRvRsWNHh31yc3Ptr1evXo1OnTq5s8Q6cVQmERERKc2tozJzc3MxadIkmM1mWCwW3HTTTRg5ciQef/xxJCcnIy0tDa+99hpWr14NtVqN0NBQfPjhh+4ssU6iKIANZkRERKQkQWoGd1dNTk5GVlaWop8xZ+lv2PJXAX5+eKiin0NERETNW325hTP/O4nXmBEREZHSGMycxFGZREREpDQGMyexxYyIiIiUxmDmJJGjMomIiEhhDGZOUonsyiQiIiJlMZg5SSXyJuZERESkLAYzJwkCeI0ZERERKYrBzEkqjsokIiIihTGYOYmjMomIiEhpDGZOEgX5lkzN4EYJRERE5KUYzJykEgUA4JQZREREpBgGMyfZgxlbzIiIiEghDGZOEgU5mDGXERERkVIYzJxkbTBjVyYREREphsHMSezKJCIiIqUxmDnJ1pXJucyIiIhIKQxmTuKoTCIiIlIag5mTRHZlEhERkcIYzJyksndlergQIiIiarYYzJxkG5VpYYsZERERKYTBzEkirzEjIiIihTGYOcnelckWMyIiIlIIg5mTOCqTiIiIlMZg5iRbVyZbzIiIiEgpDGZOsnVlmjkqk4iIiBTCYOYklfUnxa5MIiIiUgqDmZMEXvxPRERECmMwcxJHZRIREZHSGMycxFGZREREpDQGMydxVCYREREpjcHMSRyVSUREREpjMHOSyFGZREREpDAGMyfx4n8iIiJSGoOZk3iNGRERESmNwcxJosBRmURERKQsBjMnqdhiRkRERApjMHMSR2USERGR0hjMnMRRmURERKQ0BjMnsSuTiIiIlMZg5iQVL/4nIiIihTGYOUngPGZERESkMAYzJ7Erk4iIiJTGYOYkjsokIiIipTGYOck2KtPCa8yIiIhIIQxmTrJ1ZZrZlUlEREQKYTBzEkdlEhERkdIYzJzEm5gTERGR0hjMnGS7iTmvMSMiIiKlMJg5yd6VyVxGRERECnFrMDMYDOjduze6d++OLl26YN68eTX2qaiowPjx45GQkICUlBRkZ2e7s8Q6cVQmERERKc2twUyn0+H777/Hb7/9hj179mDDhg34+eefHfZ57733EBISgsOHD2PWrFmYO3euO0usE0dlEhERkdLcGswEQYC/vz8AwGg0wmg02m91ZLNq1SpMmjQJAHDjjTdi06ZNkLwgDIkclUlEREQKc/s1ZmazGUlJSYiMjERqaipSUlIctufk5KB169YAALVajaCgIBQWFtY4zuLFi5GcnIzk5GTk5+crXrf9lkwMZkRERKQQtwczlUqFPXv24MSJE9ixYwf27t3boONMmzYNWVlZyMrKQkRERCNXWVPVxf8MZkRERKQMj43KDA4OxuDBg7FhwwaH9bGxsTh+/DgAwGQy4dy5cwgLC/NEiQ5sPa5sMCMiIiKluDWY5efno6ioCABQXl6OjRs3omPHjg77pKWl4aOPPgIALF26FEOGDKlxHZonCIIAUWBXJhERESlH7c4Py83NxaRJk2A2m2GxWHDTTTdh5MiRePzxx5GcnIy0tDRMnToVt912GxISEhAaGoqMjAx3llgvlSiwK5OIiIgU49ZglpiYiN27d9dY/+STT9pf6/V6LFmyxJ1lOU0UBLaYERERkWI4878LVKLA6TKIiIhIMQxmLlAJ7MokIiIi5TCYuUAU2ZVJREREymEwc4EocLoMIiIiUg6DmQs4KpOIiIiUxGDmAo7KJCIiIiUxmLmAozKJiIhISQxmLhA5KpOIiIgUxGDmAhVHZRIREZGCGMxcoBIFjsokIiIixTCYuUAQwK5MIiIiUgyDmQtUHJVJRERECmIwcwFHZRIREZGSGMxcIAoCLOzKJCIiIoUwmLmALWZERESkJAYzF4iiADNzGRERESmEwcwFogBI7MokIiIihTCYuUAlsCuTiIiIlMNg5gKR15gRERGRghjMXKDiqEwiIiJSEIOZCzgqk4iIiJTEYOYCjsokIiIiJTGYuUAlgLdkIiIiIsUwmLmAM/8TERGRkhjMXMBRmURERKQkBjMXcFQmERERKYnBzAUclUlERERKYjBzgSgKYC4jIiIipTCYuUAlgC1mREREpBgGMxfw4n8iIiJSEoOZC0RBgMSL/4mIiEghDGYuUAkCzAxmREREpBAGMxfIXZmeroKIiIiaKwYzF6hEcB4zIiIiUgyDmQtUAi/+JyIiIuUwmLlAFAXexJyIiIgUw2DmAl78T0REREpiMHOBPPM/gxkREREpg8HMBaIgwMJRmURERKQQBjMXqESwK5OIiIgUw2DmAo7KJCIiIiUxmLlAFAUA4MhMIiIiUgSDmQtUghzM2J1JRERESmAwc4GtxYzdmURERKQEBjMXiNYWMzaYERERkRIYzFygsv602JVJRERESmAwc4GtxYxdmURERKQEBjMXqDgqk4iIiBTk1mB2/PhxDB48GJ07d0aXLl3w6quv1thn8+bNCAoKQlJSEpKSkvDkk0+6s8R62YIZuzKJiIhICWq3fphajYULF6Jnz54oKSlBr169kJqais6dOzvs179/f6xZs8adpTnF1pXJFjMiIiJSwiW3mB08eBArV67EyZMnL7pvTEwMevbsCQAICAhAp06dkJOTc6kluA1bzIiIiEhJLgWz6dOnY8aMGfblL7/8Et26dcOYMWPQsWNH/PTTT04fKzs7G7t370ZKSkqNbZmZmejevTuuu+467Nu3r9b3L168GMnJyUhOTkZ+fr4rp9Fg1lwGNpgRERGRElwKZhs2bMCAAQPsy4899hgmTJiAkydPYvjw4XjsscecOk5paSnGjh2L9PR0BAYGOmzr2bMnjh49it9++w333nsvRo8eXesxpk2bhqysLGRlZSEiIsKV02gwdmUSERGRklwKZnl5eWjdujUA4NChQzh8+DDmzJmD6OhoTJs2Dbt3777oMYxGI8aOHYuJEydizJgxNbYHBgbC398fADBixAgYjUYUFBS4UqZiVJz5n4iIiBTkUjALDQ3F6dOnAQDfffcdoqOj0bVrVwCAJEkwm831vl+SJEydOhWdOnXCfffdV+s+p06dgmS9hmvHjh2wWCwICwtzpUzF8BozIiIiUpJLozKvu+46PP744zh9+jReeOEF3HTTTfZte/fuRXx8fL3v3759Oz755BN069YNSUlJAIBnn30Wx44dAwDMmDEDS5cuxaJFi6BWq+Hj44OMjAwI1i5ET2NXJhERESnJpWC2cOFCzJo1C2+//TYGDBjgMMfYihUrcO2119b7/n79+tlbw+pyzz334J577nGlLLdhixkREREpyaVgFhQUhPfff7/WbVu3bm2UgrwZb8lERERESnIpmJlMJpjNZuh0Ovu6b7/9Fvv378fAgQPRo0ePRi/Qm9imy2CDGRERESnBpWA2fvx4h1az1157DTNnzoROp4PZbMby5csxcuRIRQr1BhyVSUREREpyaVTmzz//jBEjRtiXX3zxRdx///0oLy/HHXfcgWeeeabRC/QmIq8xIyIiIgW5FMwKCwsRHR0NAPjjjz9w8uRJ+50Axo0bh/379zd+hV5ExVGZREREpCCXgllUVBSys7MByHcBaNOmDdq3bw8AKC8vhyhe8q03vRq7MomIiEhJLl1jNm7cOMydOxe//fYbPvjgA4dpLXbv3o0OHTo0eoHexD4qk12ZREREpACXgtmCBQsQGBiInTt34q677sJDDz1k37Zr1y6MHz++0Qv0JrYWM4vFw4UQERFRs+RSMFOr1Xj88cdr3bZ8+fJGKcib2abLsLDFjIiIiBTgUjCz+eWXX7Bt2zacOXMGoaGh6NevH1JSUhq7Nq/DUZlERESkJJeC2fnz5zFu3Dhs2LABarUaYWFhKCwshNlsxrXXXoslS5bA19dXqVo9jqMyiYiISEkuDaOcM2cOMjMz8eWXX8JgMCA3NxcGgwEZGRnIzMzE3LlzlarTK3BUJhERESnJpWC2bNkyPP/88xg3bpx9agxRFDFu3DgsWLAAS5YsUaRIb2EblclrzIiIiEgJLgWzc+fOoXXr1rVua926NYqLixulKG9V1WLm4UKIiIioWXIpmHXv3h2LFi2CdEGLkSRJWLRoEbp3796oxXkb26hMXvxPRERESnDp4v9nn30W1113HTp27IgbbrgBUVFRyMvLw4oVK5CdnY3169crVadXsI3KvDCYEhERETUGl4LZkCFD8Ouvv+Kpp57CkiVLkJubi5iYGKSkpGDx4sVK1eg1bKMyefE/ERERKcHlecy6dOmCjIyMGuuXLVuGm266CWazuVEK80YclUlERERKat53HW9ktq5MjsokIiIiJTCYuaCqK9PDhRAREVGzxGDmAuvUbRyVSURERIpgMHOByFsyERERkYIuevF/REQEBGsgqU9FRUWjFOTNVJz5n4iIiBR00WB29913OxXMWgKRozKJiIhIQRcNZvPnz3dDGU2DiqMyiYiISEG8xswFHJVJRERESmIwc4FtVCZbzIiIiEgJDGYu4C2ZiIiISEkMZi4QOSqTiIiIFMRg5gL7LZnYYkZEREQKYDBzkUoUOPM/ERERKYLBzBkFh4D3hgFHf4JKEDgqk4iIiBTBYOYMyQIc/wUoyYUo8hozIiIiUgaDmTO0/vJzRYm1xYzBjIiIiBofg5kzdLZgVgpRZDAjIiIiZTCYOcPWYlZZClEQILErk4iIiBTAYOYMUQVo/OSuTI7KJCIiIoUwmDlLFwBUlEDkqEwiIiJSCIOZs3T+1hYzTjBLREREymAwc5bWH6gslUdlsiuTiIiIFMBg5ixdgH1UJlvMiIiISAkMZs6yXmPGi/+JiIhIKQxmztL6A5Xyxf9sMCMiIiIlMJg5y9aVKfDifyIiIlIGg5mz7KMyOfM/ERERKYPBzFm6AMBcAQ3MvMaMiIiIFMFg5ixtAADAXzCwK5OIiIgUwWDmLOuNzAOEcraYERERkSLcGsyOHz+OwYMHo3PnzujSpQteffXVGvtIkoT/+7//Q0JCAhITE/Hrr7+6s8S66eQWMz+U8xozIiIiUoTarR+mVmPhwoXo2bMnSkpK0KtXL6SmpqJz5872fdavX49Dhw7h0KFD+OWXX3DXXXfhl19+cWeZtdPKLWZ+UhkKmcuIiIhIAW5tMYuJiUHPnj0BAAEBAejUqRNycnIc9lm1ahVuv/12CIKAPn36oKioCLm5ue4ss3a2FjPBwBYzIiIiUoTHrjHLzs7G7t27kZKS4rA+JycHrVu3ti/HxcXVCG8eYQ1mvhKvMSMiIiJluLUr06a0tBRjx45Feno6AgMDG3SMxYsXY/HixQCA/Pz8xiyvdrauTJRzVCYREREpwu0tZkajEWPHjsXEiRMxZsyYGttjY2Nx/Phx+/KJEycQGxtbY79p06YhKysLWVlZiIiIULRmAPZRmb5gixkREREpw63BTJIkTJ06FZ06dcJ9991X6z5paWn4+OOPIUkSfv75ZwQFBSEmJsadZdbOOo+Zj8QWMyIiIlKGW7syt2/fjk8++QTdunVDUlISAODZZ5/FsWPHAAAzZszAiBEjsG7dOiQkJMDX1xcffPCBO0usm0oNqH3gK5WxxYyIiIgU4dZg1q9fP0gXCTWCIODNN990U0Uu0gVYW8w8XQgRERE1R5z53xU6f/hYymBhixkREREpgMHMFVp/+EhlnMeMiIiIFMFg5gpdIPScx4yIiIgUwmDmCltXJlvMiIiISAEMZq7Q+kMvlcFg5NX/RERE1PgYzFxhHZV5pqzyoqNLiYiIiFzFYOYKnT/05jJUmiworTB5uhoiIiJqZhjMXKELhNpigApmnDlf6elqiIiIqJlhMHNFtRuZF5QymBEREVHjYjBzhfVG5v4wsMWMiIiIGh2DmSt08o3M/QQDCksrPFwMERERNTcMZq7QysEsAGUoZIsZERERNTIGM1dYuzLDNJUo5DVmRERE1MgYzFxh7cqM0ptw5jy7MomIiKhxMZi5wjoqM1JXya5MIiIianQMZq6wtpiFa4zsyiQiIqJGx2DmCmswC1UbUMiuTCIiImpkDGauUGkAlQ7BqkqcOc/7ZRIREVHjYjBzlS4AgaIBRrOEYgPvl0lERESNh8HMVTp/+AvlAMBJZomIiKhRMZi5ShsAX0kOZrwtExERETUmBjNX6QKgt8jBjDcyJyIiosbEYOYqnT+05lIAbDEjIiKixsVg5ipdANSm8wB4jRkRERE1LgYzVwXEQCzOQaBO5Oz/RERE1KgYzFwV2hYwGXC573kGMyIiImpUDGauCmkLAOioK+CNzImIiKhRMZi5KlQOZu01BbxfJhERETUqBjNXBV0GiGq0wSl2ZRIREVGjYjBzlUoNBLVGjCUXZ85XwmLh/TKJiIiocTCYNURoW4QbT8JskVBsMHq6GiIiImomGMwaIqQtgspPAODs/0RERNR4GMwaIrQttMZiBKGUs/8TERFRo2EwawjrlBlthNOc/Z+IiIgaDYNZQ4RWBbO8EgYzIiIiahwMZg0REg8A6KAtwKG8Es/WQkRERM0Gg1lDaP0A/2h01Rfiz1MMZkRERNQ4GMwaKrQt2qrycfBUCSSJc5kRERHRpWMwa6iQtog0nUSJwYTccwZPV0NERETNAINZQ4W2hV9FHnSoZHcmERERNQoGs4ayTplxmZCHgwxmRERE1AgYzBrKOmVGkt8Z/Hmq2MPFEBERUXPAYNZQYe0BCLjK7yRbzIiIiKhRMJg1lE8I0CoJV5r34O/8UhjNFk9XRERERE0cg9mlSLgGsef3wcdciiMF5z1dDRERETVxDGaXov1QiJIZfcV97M4kIiKiS8ZgdiniroSkC8Rg1W8cAEBERESXjMHsUqjUENoNxGD1H/gzl8GMiIiILg2D2aVKuAaRUgEMuQc8XQkRERE1cW4NZlOmTEFkZCS6du1a6/bNmzcjKCgISUlJSEpKwpNPPunO8hqm/VAAwBWlO5BTVO7hYoiIiKgpc2swmzx5MjZs2FDvPv3798eePXuwZ88ePP74426q7BIEt0ZlSAcMFH/D9wfzPF0NERERNWFuDWYDBgxAaGioOz/SLTRXDEMf1QHs3HvQ06UQERFRE+Z115hlZmaie/fuuO6667Bv374691u8eDGSk5ORnJyM/Px8N1ZYk5D8b2hhQsLRr1BeafZoLURERNR0eVUw69mzJ44ePYrffvsN9957L0aPHl3nvtOmTUNWVhaysrIQERHhviJrE94Bha0G4xbxW/z8V45nayEiIqImy6uCWWBgIPz9/QEAI0aMgNFoREFBgYerck7A4P8iXCjG2Z8/83QpRERE1ER5VTA7deoUJEkCAOzYsQMWiwVhYWEerso52oRBOK5tj+45n0Gy8L6ZRERE5Dq1Oz9swoQJ2Lx5MwoKChAXF4cnnngCRqMRADBjxgwsXboUixYtglqtho+PDzIyMiAIgjtLbDhBwMlO/0bKb4/iWNYaXNY7zdMVERERURMjSLYmqiYsOTkZWVlZni4DeWfOwfxqEoSAGETfvx1oKqGSiIiI3Ka+3OJVXZlNXWRoEFaHTkZ06T5Y9q7wdDlERETUxDCYNbLWg6figKU1KjY8DpgqPF0OERERNSEMZo0stUsrvKWeBJ/zx4Gs9z1dDhERETUhDGaNTKMScVnvkdhm6QrL5ueBUt6miYiIiJzDYKaAm3u3wROm22GpLANW3gVw+gwiIiJyAoOZAlqH+iKuQw8sxO3A4e+An9/ydElERETUBDCYKWRKv7ZYVDYIRyMGA9/NB07u9nRJRERE5OUYzBTSLyEcVyeEY1Lh7bD4RQBf3Q6cL/R0WUREROTFGMwUIggC5l7bEdllOnwR/yxQchpYOhkwmzxdGhEREXkpBjMFJcYFY2RiDJ7e44Pia14AjmwBNj7m6bKIiIjISzGYKeyBYVfAaLbgieM9gJQZ8kCAzc8DTf9OWERERNTIGMwUFh/uh+kD22HZryfwbdy9QNJEYPOzwLePMpwRERGRAwYzN/jv0MvRpVUgHlx5APlDFgK9pwOZbwBf/xewmD1dHhEREXkJBjM30KpFpI9PQmmFCQ8u3wvp2gXAgNnArx8By+4AzEZPl0hERERegMHMTTpEBeDBazti08E8LNryDzDkUSD1SWDfcuDLW4GKEk+XSERERB7GYOZG/746HmndW+HFb/7Exv2ngav/C4x8BfjrG+CtvsDfP3i6RCIiIvIgBjM3EgQBL9yYiG6xQZiZsRsHTxUDyVOAKd8Aah3wyWi5a5N3CSAiImqRGMzcTK9RYfFtyfDTqXH7eztw6HQJcFkKMGMr0O8+4OA6YPEg4L1hwIE1vAE6ERFRC8Jg5gHRQXp8dkcKJAA3L/4Z+08WAxof4Jp5wP0HgGsXAKWngS8nAm9fDfy+hHcMICIiagEYzDykQ1QAvpzWB1q1iAnv/Ixfj52VN+iDgD53AffsAsa8A0gWYPkdwBvJwK6PAGO5ZwsnIiIixTCYeVC7CH98Nf0qBPtqcMs7P+OHg3lVG1VqIPEm4K5MYPyncmD7+v+AFxOA5dPkAQOmSs8VT0RERI2OwczDWof6YumMvkiI9McdH2chY8cxSNXvCCCKQKdRwLTNwKSvgS43yKHs85uAlzoAq+6RR3Oyq5OIiKjJEySp6d8XKDk5GVlZWZ4u45KUVphw16e7sPVQAa5PjMEzo7si2Fdb+86mSuCfH4C9y+TBApUlgG840GU00GUMcNlVcqAjIiIir1NfbmEw8yJmi4T/bfkbL3/7F8L9dVh4U3dcnRBe/5uM5cChjfJEtX9uAEzlQEAruWWt6xggthcgCO45ASIiIrooBrMmZm/OOfw3Yzf+zj+Pqf3aYvbwK6DXqC7+xopS4K8NwN7lwOGNgLkSCGoNtE4BYnsCEVcAATHywzdU+RMhIiKiGhjMmqDySjOeW38AH2ceRYdIfzw3phuS410IU+VFwJ/rgINr5Qlri3Mctwe1BuKSgaiuQGArOay16gH4BDfmaRAREdEFGMyasM1/5uGRFXuRU1SOCb1bY/bwjgj1q+Pas/qUnAbOHgFKcoGi43JYO7ETOHe8ah9BlMNZ24FAu4FA6z6ARt94J0NEREQMZk3d+QoTXt10CO9tOwK9WsSkvvG4s387hDQkoF2osgwoPQUUHQOO/gT886Mc2CQzoNLJXZ6iBtD6AWHt5e7QVj2B+KsBn5BL/3wiIqIWhsGsmTicV4L07w5h7R+58NOqMblvPO7o37bu0ZsNZSiWQ9rRbUD5WcBiBgzngIJDwJl/5NAGAYjuCoRfDoS2l0NbaDv5tV9Y49ZDRETUjDCYNTN/nS7Bq9aAFqBT49ar2mBy33hEBbqh29FUAeTsAo5sAY7vAM78Lbe2SdXu6ekbBkR0AoIvkyfG9QkGwhKAqC7ys0qjfJ1EREReisGsmTp4qhivbzqM9XtzoRIFjOreCnf2b4dOMYHuLcRUKYezM38DhYeB/INA3kGg+CRQUSw/7ATAP1IebBAYCwTGyIMPAmPldcGXAUFxDG9ERNRsMZg1c8cKy/D+9iP4Kus4yirN6JcQjjv6t8XAyyMgeMMcZqYKuRs0bz9Q+DdQclIObbaHochxf0ElhzXfUPk6Np/Qmq8DooGQtnKIE52YSoSIiMhLMJi1EOfKjPhsx1F8uD0beSUVuDzKH3f0a4dR3VvBR+vF4aXyPFCcK0/pUXQMKDoqjxwtPwuUnwHKzsjP5UUALvh1FdXWsBYG+EdYW9wuk69z8wkF/KPk7lP/SE60S0REXoHBrIWpNFnw9W8n8c7Wf3DwVAn8dWqM6h6DG3rEoVebEKjEJhpQbIMQys7IIe7sEeDsUaCsUH6UnpYDXempmu/VBsjhzDe0WgtcqBzm/KMBvwj5xvG2oBfSRh6JSkRE1MgYzFooSZKw48gZfJV1Auv+yEW50Yxwfy2u6RSF4V2j0bd9GHRqL25JayhTZVVLW8lJoPAf+dq38/nVWuDOymHOWFb3cfTBVd2kar21KzXEuk4ANL5y2POPBDQ+gEorP/uGyfcu9QkGtP6ALkB+8Lo5IiICgxlBvkn6Dwfz8M2+U/jhYB7OV5rhr1NjcMdIDO8ShUFXRMJfp/Z0me5XUSq3tJ0vACwm+XE+X+5SLT4pjzYVBMBosHanWqcPgSR3wZbmyQHvwi7W2qj1clDT+lkDm/W1b5h1IEQra8DTyZ9pqpDr0frLo1u1vnKLnqCSw6GokvfVB8rbNb7sriUiagLqyy0t8C9xyyR3Z7bCqO6tUGEy46fDhdiw9xS+O3AaX/92Elq1iJS2oRjQIQIDLo/A5VH+3jFwQGk6a0AKa9/wY1jMcogyV8otcOcLgLICoKLkgkexHObsj1J5zrjCv+UQaDFe2rmIakBnDWn2h3VZFyi32IkaOewZywCTQb7hfUi83Oqn0sjHENXW4KeW96++rNbLQVLF/3QQESmBLWYtnNkiISv7DDbuP40f/8rHobxSAEB0oB79O4SjX4dwXNUuDJHumCOtJbNY5JY3k0EOeJIEqLVyGKosk6+tqyyRQ6BksbbumeX9K4rlgGc4Jz8qqr22ra8oBsxG+X2CKIdRUSO3DjrT2nchn1A5zPlFWO8OoZaPK6jkZ1G8YNn6bHvoAuUwHNZevv5PtO5rC4EmgxxmJYs8oIN3mSCiZoQtZlQnlSggpV0YUtqF4VEAJ4vKsfVQPrb8VYBv9p3Ckl0nAADtI/zQt304rmofhpS2oQjz13m28OZGFOWBCO5mqpC7bcsKq7pybaHPFuRsy7aWtvMFcqA7nye/zjsob5Msjg9biJRsYdICQJJfV56HS4HQJ0Ru+QPkABcQLXf/6uubs0+Qu4dD28n7C6K8zidYDpT6IDkAS2ZrsGwBLcRE5PXYYkZ1Mlsk7D9ZjJ/+LkDmP4XYceQMyirNAIB2EX7oHR+KK+ND0bttKOJCfFpG1yc1DqNBHlVb+DdgLJfDUfUAqNbLrXoQ5OlTzvxjDXOQWxRLTgHncgDj+bo/w2KSWwvrJMAeDkW1HP5sXb6CSg7L1a/pE1TyNYF+EfJ0LBo/QK2Ta1Xr5OsDqy+rfaq91gMaveM2dgcTtVi8+J8ahdFswe8nzmHHkTPYmX0GWdlnUGwwAQAiAnToHheExLhgdIsLQve4YIQ2xk3WiS5FRQlw5ojcugfILWTlZ+VBG4aiquBlLJPXG85Vtf5ZzBcERrN8XaDtGkKT4dJqE1TySF65sKrr93xCqkb5qnW1POvkbm6H53r2U+vrP4ZKK4fQ2lisLZ4cUUzUqNiVSY1CoxLRq00IerUJwV1oD4tFwp+nS7Az+wz2HCvCbyeKsOlgHmxRPy7EB92tQa1TTCA6RQcgIkDHljVyH10AEJOozLEtFsBcIQc0U4Xc8meqtmwyVHtYl40XLJsrrAcT5PfbpnMxVQDGInnqF3NF1eCS6s+XOlikOlFzQXDTyCOWDUVySPWx3m1D41ttkIhKfp9GL18nqPWzjjT2l7vBy8/Iwdg/quq+ubbucZWm7qBZPUgK1ulqbC2abGWkFoC/5dRgoijIgSsmELdfJa8rMRixN6cYv58owu855/D7iSKs/SPX/p4QXw2uiA5Ax+hAtIvwQ5swP8SH+aJVsA80qjr+r53IG4kiIPrIrVueYLHIIc0W3BzCW0W1UFdPuKtzP6McsnxC5FBUehooOQ2YyuVgZTZVhUOjQW5JrCyVw5wtMOqD5ZBWerqRQqRQVY8t3NoCnFpfFe5sg2NEVbVpaQLkZ0FVNThGrbeOWPavOUhFVMkhVOMjd1lrrN3SFqP8uYJQbbuP3DUNSb47ieFc1TQ4On/rdZbWFlFdgLy/xST/jAXRsXaVVj62rbXWtkwtCoMZNaoAvQZXtQ/DVe3D7OvOnq/EwVMl+PNUMf48XYIDuSX2+3raqEQBcSE+aBPmhzahvmgT5msPba1DfaHXNMOJcIkuhSgCovXaNW9iqrB201r/vFgsQEmuHNxsrW0WU91h0jYy2VQhhxpAXi4rlAedSBbrNXoaOdw4BNOKqmsCLSY5KFaWAucLraOaLdYwFiCvP/O3vI9tgIptkIrFJIdQTxNEawD0lecx1PhZu50Fa2Cr5Rmoe5vtWaWWWzIDY+Vgaxu5Larr7iK3t27W0W0uCDUH/Qiq+rvbHa7hZAC1YTAjxYX4aWuENUmSkF9SgezCMhwtPI+jhWXILjyPY2fKsPvYWZRYr10D5H+v0YF6tAnzRXyYHy6zPtvCW4ucGJfIW6kvGLEtikBQrGdquRQWi7X7uUweeGKqkMOgWie3gNm2Gcur7iBiG0BiLJODZEVp1RQxpnK5a9dYbg1AGjnAVA+Vpkr5OLZRwiaDPF2O0Tr3obG8aoJrSar9GahjW7X1leeBo5nynVEspqoWRYvZsfXUFozdQbhgyhz7RNpqa+ttqDyi2hYcJYs1mFdWtfKaK6q6y2233NMGVF03qg+qasm0tfxajNb3GKuWL7sK6Haj+879AvyLRh4hCAIiA/WIDNSjd9tQh22SJKGozIijZ+TQll1QhqNn5PD23YHTKCitdNg/3F+Ly0J9cVmoL2JDfNAqWH7EWh9+DG5E5CpRlFuptL6AX7inq1GGxSyHtbqu3TObLugGN9TdRS5J1eYwtHYJS+b6u9TtA21MFwy2sVR7bZIDbdkZOeyabd3JorU1TlvVAqcLsF6bKABlZ4G8A3IItXVRG87Jg3wuZJtM29aiq/FlMCOqThAEhPhpEeKnRVLr4BrbSytM9la2o9YWt+zC88g6ehZrfs+FyeI40DjIR2MNanrEBlcLbiFycIvw10Fsqjd2JyJqKPEil4io1PJD6+eeetzBbJJbIKsHMS/rRmUwoybHX6dGl1ZB6NIqqMY2s0VCXokBJ4vKkVNkQM7Zcpwskh8nzpbjlyNnHLpJAUCjEhAdVBXaLnxuFayHr5b/VIiImjyVGlDV/NvhTdz612bKlClYs2YNIiMjsXfv3hrbJUnCf//7X6xbtw6+vr748MMP0bNnT3eWSE2cShQQE+SDmCAf9GpT+z7FBiNyiwzIKSpDTpHBHtxyzpbj578LcarYgAsa3RDiq0FsiHzcqEAdIvz1iAjQITJAhwjrI9xfB62aI0uJiKjh3BrMJk+ejHvuuQe33357rdvXr1+PQ4cO4dChQ/jll19w11134ZdffnFnidQCBOo1CIyWp+2ojclswemSCntrW05R1fPRwvPIyj6Ds2W1D/8P9tVUhTX/qsAW6qdFiK/cPRvqp0WorxaBPmrO6UZERA7cGswGDBiA7OzsOrevWrUKt99+OwRBQJ8+fVBUVITc3FzExMS4r0hq8dQq0T5woC6VJgsKSiuQX2J9WF/nlRjs63YdO4u84gpUmGof2aRRCQj10yLMT4cwfy3C/XUI89MizN+2rEWonw5BPhoE6tUI0GvYIkdE1Mx51YUzOTk5aN26tX05Li4OOTk5tQazxYsXY/HixQCA/Px8t9VIBABatWgfRFAfSZJQWmFCUZkRZ85X4myZ/CgsrcSZ8/Jz4fkKFJRWIrvwPApLKx3md7uQXiPKLX4+GgTo1QjUW599NBe8Vlv3kwOd7bWPRsVWOiIiL+ZVwcwV06ZNw7Rp0wDI95wi8kaCICBAr0GAXoPWob5Ovaes0mQNbJUoLK1AscGI4nITisuNKKmQn4sNRpQYTCgqq8SxM2Uose5Taa5/3iGVKMih7cJgd0HYu3B7kDX4+evVUHEEKxGRYrwqmMXGxuL48eP25RMnTiA2tglOTEh0CXy1aviGqp0OctUZjGZ7kCsxGFFssAY6g8m6vup1iXXbkYLz9tfn62mts/HXqe1dq4E+avjr1PDVqqHXqOCjFeGjUcFHo4KfTg0/nW27Cv7WZds6P50Kflo1pyohIqrGq4JZWloa3njjDdx888345ZdfEBQUxOvLiFyg16ig16gQWfu4hosymS0orTDJLXQGo1MhL7+0AuWVZTAYLSg3mlFeaUa58eIBz8ZXq7KHNR+NCr5aFXx1avjaX6vgq1Vbw54KPlp5m/211rrfBa/ZskdETZFbg9mECROwefNmFBQUIC4uDk888QSMRnl024wZMzBixAisW7cOCQkJ8PX1xQcffODO8ohaPLVKRLCvFsG+2ks6jsUiocxoRlmFCaUVJpyvMFufTThfabK/Lq0wy+us+5VXmlFWaca5ciNyi8pRZg15ZZUmGIyu3R5GqxbhZw1pPloV/LQq+NQS4GyvfbRqh33q2l+vEXmdHhEpRpAkSbr4bt4tOTkZWVlZni6DiBRktkj2kFZWYbaGNjn0VX9tC3dllSbrc9Xr8kozzldWBUDb6wvvFlEfQQB8NRe21tUe8uyvdSpra6AavtbXPtbWTR+NCnqtaH+tUXHkLVFzV19u8aquTCKiuqhEAf7WLk80sKu2LpUmS71BrrZQV31/27aC0ooa21ylFgV7l7ReY71mT6uCXq2CXquCj6YqxOmrhzuNKO9XbZ1tvV6jglYtQqcWoVNXfy1CzSBI5FUYzIioxdOqRWjVWgS7Pt6iXhaLBIPJXCPkGaxdtPbr8oxmVFivzzOYzCivtFStM9r2lbt484rN9mv5DNZjXGw0bn1EAdCpVdBpRGhVoj0Q6tRVoU6nFqGzPus1cki07a+z7qtTiw6Br3oA1Kpr7mNbp1EJ7BomqobBjIhIIaIoWLs4lf1PrdkiwVAtwBmMcrizhcJKkwUVJjMqrCGuwmhGhcliXS9vqzRZYDDKr6s/l1aYUFgqH6ui2vpK06UFwuouDG+1BThtPeu1KtH+rFEJ0KhFaFS25ap1DsvW99iWtQ7LIgMjeQyDGRFRE6cSBftUJO5ksUjWoGcNftagV1kt7FUPgJXm6uGwWkh0WK753rJKE4rKLbW/12Rx6RpBV9gCnO2hrRb67Mu27eqqZVvAqx4a5fCnsr/WVd+n2mvdBetsNairBUjba40ocrqZZojBjIiIGkQUBehF+Zo2QOOxOiwWCUaLBUazBKPJAqPZYg9sRrMc7oxm63azHOqq1llgNMkB075sluwtgibbstliP7Z9udr7y8uNDu+xvbY9G80SzAoESJUo2EOaRi1CLVaFQ9vrqnAnQC3angWoRAFqlbyfWpSfVSoBGlGASpTfZ3tP9YCoVVW9T/4cx89w+MwLttmCpf21tQ62TlZhMCMioiZNFAXoRBV0agA6T1dTN7M1KNpaAo21BLhKU9XDZLGg0ixZw6Hja1vINJotMFmDoqla8DTZt1fbzyKhrNJkrUMOiiaLvN5Uy7LRbLGuU3byBkEANKJjqFOLIjRqa+C0hUpbKLSGUI0oVHuPLUjK62uEyGpBUH5vbZ8nvzcm2Adtw/0UPef6MJgRERG5gUoUoLK3MDYdFms4s4VAuXWyZiC0hT+jyQKjpWaItL/X3pppW18VOk0WyaGl0lj9+NZjmywWlJebL9hWM4za6nPVrX0uw9Ojuynwk3QOgxkRERHVSRQFaK3dlk2NJEn2Vj9biDRVa1U0WSyoNMnPtlAXEeDZZlcGMyIiImqWBMF6nZwKTaalsunFXyIiIqJmisGMiIiIyEswmBERERF5CQYzIiIiIi/BYEZERETkJRjMiIiIiLwEgxkRERGRl2AwIyIiIvISDGZEREREXoLBjIiIiMhLMJgREREReQkGMyIiIiIvwWBGRERE5CUYzIiIiIi8BIMZERERkZcQJEmSPF3EpQoPD0d8fLzin5Ofn4+IiAjFP8cbteRzB3j+Lfn8W/K5Azx/nn/LPX8lzz07OxsFBQW1bmsWwcxdkpOTkZWV5ekyPKIlnzvA82/J59+Szx3g+fP8W+75e+rc2ZVJRERE5CUYzIiIiIi8BIOZC6ZNm+bpEjymJZ87wPNvyeffks8d4Pnz/Fvu+Xvq3HmNGREREZGXYIsZERERkZdgMCMiIiLyEgxmTtiwYQOuuOIKJCQkYMGCBZ4uR3HHjx/H4MGD0blzZ3Tp0gWvvvoqAGD+/PmIjY1FUlISkpKSsG7dOg9Xqpz4+Hh069YNSUlJSE5OBgCcOXMGqamp6NChA1JTU3H27FkPV9n4/vzzT/v3m5SUhMDAQKSnpzfr737KlCmIjIxE165d7evq+q4lScL//d//ISEhAYmJifj11189VXajqe38Z8+ejY4dOyIxMRE33HADioqKAMhzL/n4+Nh/D2bMmOGhqhtPbedf3+/7c889h4SEBFxxxRX45ptvPFFyo6nt3MePH28/7/j4eCQlJQFont99XX/rPP7vX6J6mUwmqV27dtLff/8tVVRUSImJidK+ffs8XZaiTp48Ke3atUuSJEkqLi6WOnToIO3bt0+aN2+e9OKLL3q4Ovdo06aNlJ+f77Bu9uzZ0nPPPSdJkiQ999xz0pw5czxRmtuYTCYpKipKys7Obtbf/Y8//ijt2rVL6tKli31dXd/12rVrpWuvvVayWCxSZmam1Lt3b4/U3JhqO/9vvvlGMhqNkiRJ0pw5c+znf+TIEYf9moPazr+u3/d9+/ZJiYmJksFgkP755x+pXbt2kslkcme5jaq2c6/uvvvuk5544glJkprnd1/X3zpP//tni9lF7NixAwkJCWjXrh20Wi1uvvlmrFq1ytNlKSomJgY9e/YEAAQEBKBTp07IycnxcFWet2rVKkyaNAkAMGnSJKxcudKzBSls06ZNaN++Pdq0aePpUhQ1YMAAhIaGOqyr67tetWoVbr/9dgiCgD59+qCoqAi5ubnuLrlR1Xb+w4YNg1qtBgD06dMHJ06c8ERpblHb+ddl1apVuPnmm6HT6dC2bVskJCRgx44dCleonPrOXZIkfPXVV5gwYYKbq3Kfuv7WefrfP4PZReTk5KB169b25bi4uBYVUrKzs7F7926kpKQAAN544w0kJiZiypQpzbIrz0YQBAwbNgy9evXC4sWLAQCnT59GTEwMACA6OhqnT5/2ZImKy8jIcPiPckv57oG6v+uW+N+D999/H9ddd519+ciRI+jRowcGDhyIrVu3erAyZdX2+96Svv+tW7ciKioKHTp0sK9rzt999b91nv73z2BGdSotLcXYsWORnp6OwMBA3HXXXfj777+xZ88exMTE4P777/d0iYrZtm0bfv31V6xfvx5vvvkmtmzZ4rBdEAQIguCh6pRXWVmJ1atXY9y4cQDQor77CzX377o+zzzzDNRqNSZOnAhAbmE4duwYdu/ejZdffhm33HILiouLPVxl42vJv+82X3zxhcP/mDXn7/7Cv3XVeeLfP4PZRcTGxuL48eP25RMnTiA2NtaDFbmH0WjE2LFjMXHiRIwZMwYAEBUVBZVKBVEUceeddzbpJvyLsX3HkZGRuOGGG7Bjxw5ERUXZm61zc3MRGRnpyRIVtX79evTs2RNRUVEAWtZ3D6DO77ol/ffgww8/xJo1a/DZZ5/Z/zDpdDqEhYUBAHr16oX27dvjr7/+8mSZiqjr972lfP8mkwnLly/H+PHj7eua63df1986T/77ZzC7iCuvvBKHDh3CkSNHUFlZiYyMDKSlpXm6LEVJkoSpU6eiU6dOuO++++zrq/elr1ixwmEkT3Ny/vx5lJSU2F9/++236Nq1K9LS0vDRRx8BAD766CP861//8mSZirrw/5ZbyndvU9d3nZaWho8//hiSJOHnn39GUFCQvcujOdmwYQNeeOEFrF69Gr6+vvb1+fn5MJvNAIB//vkHhw4dQrt27TxVpmLq+n1PS0tDRkYGKioqcOTIERw6dAi9e/f2VJmK+e6779CxY0fExcXZ1zXH776uv3Ue//evyJCCZmbt2rVShw4dpHbt2klPP/20p8tR3NatWyUAUrdu3aTu3btL3bt3l9auXSvdeuutUteuXaVu3bpJo0aNkk6ePOnpUhXx999/S4mJiVJiYqLUuXNn+3deUFAgDRkyREpISJCGDh0qFRYWerhSZZSWlkqhoaFSUVGRfV1z/u5vvvlmKTo6WlKr1VJsbKz07rvv1vldWywW6T//+Y/Url07qWvXrtLOnTs9XP2lq+3827dvL8XFxdn//U+fPl2SJElaunSp1LlzZ6l79+5Sjx49pNWrV3u4+ktX2/nX9/v+9NNPS+3atZMuv/xyad26dR6s/NLVdu6SJEmTJk2SFi1a5LBvc/zu6/pb5+l//7wlExEREZGXYFcmERERkZdgMCMiIiLyEgxmRERERF6CwYyIiIjISzCYEREREXkJBjMisps/fz4EQcDw4cNrbLvxxhsxaNAgt9WyefNmCIKAvXv3uu0zXXHgwAH0798ffn5+EAQB2dnZni7JKZMnT0ZycrKnyyCiOjCYEVEN3377LXbu3OnpMrza7NmzUVRUhNWrVyMzM7NZTjRLRO7HYEZEDkJDQ9GtWzc888wzni5FUQaD4ZLef/DgQaSmpmLo0KHo06cPdDpdI1VGRC0ZgxkRORAEAY888ghWr16NP/74o8795s+fj/Dw8Frf/8Ybb9iX4+Pj8cADD2DBggWIiYlBUFAQ7r//fkiShHXr1qFLly4ICAjA6NGjcfbs2RrHO3nyJEaOHAk/Pz9cdtllePvtt2vss3XrVgwcOBC+vr4ICwvDnXfeab+tFiDf91EQBOzYsQODBg2Cj48PXnzxxTrPbc+ePRg6dCh8fX0REhKCiRMn4vTp0wCA7OxsCIKAv//+G6+88goEQai3i9disWDBggVISEiATqfD5Zdfbr/di82gQYNw4403YvHixYiPj4ePjw+uv/565OTkOOxXUFCASZMmISwsDL6+vhg0aBCysrJqfOY777yDbt26Qa/XIyoqCjfeeCPOnTvnsM/GjRuRmJgIPz8/9OvXD/v27XPY/t5776Fz587w8fFBeHg4Bg4cWGMfImp8DGZEVMO4cePQoUOHRms1y8jIwI4dO/DBBx9gzpw5ePnll3Hffffhsccew1NPPYW3334bP/74Ix566KEa7506dSoSExOxfPlyjBgxAnfddRfWrFlj3759+3Zcc801iI6OxtKlS5Geno5169bh3//+d41jTZgwAaNGjcK6deswcuTIWmvNz8/HoEGDUFZWhs8//xyvv/46fvzxR6SmpqKyshIxMTHIzMxEdHQ0brnlFmRmZuKtt96q89zvvfdePP3005g2bRrWrl2LG264AVOmTHE4BwDIzMzE66+/jpdffhnvvfcefv/9d4wePdphn9GjR+Obb77BSy+9hC+//BIWiwWDBw/G4cOH7fs8/fTTmD59OgYOHIiVK1di0aJFCAoKQmlpqX2fY8eOYfbs2XjkkUfwxRdfIC8vD+PHj4ftRjBbtmzBjBkzcNttt2H9+vV4//330bdv3xrhjogUoMiNnoioSZo3b54UFhYmSZIkffDBB5IoitKff/4pSZIkjR07Vho4cGCt+1YHQHr99dfty23atJHat28vmUwm+7orr7xSUqlU0j///GNfN3v2bCkyMtK+/MMPP0gApDvvvNPh+Ndcc42UkpJiX+7Xr580aNAgh302bdokAZD++OMP+7kAkNLT0y/6M5g7d64UFBQknTt3zr7u559/lgBIn3/+ucN53X///fUe69ChQ5IgCNKHH37osP62226TkpOT7csDBw6U1Gq1dPToUfu6bdu2SQCk9evXS5IkSevXr5cASJs3b7bvU1paKoWHh0vTpk2TJEmSzp49K/n4+EizZs2qs6ZJkyZJKpVK+uuvv+zrVqxYIQGQDhw4IEmSJL344otSz5496z03IlIGW8yIqFa33norLrvsMjz33HOXfKxBgwZBpVLZlxMSEhAfH4+2bds6rMvPz0dlZaXDe2+44QaH5TFjxmDXrl0wm80oKytDZmYmbrrpJphMJvujX79+0Gg02LVrl8N7r7/++ovWumPHDgwbNgyBgYH2dSkpKYiPj8e2bdtcOu9NmzZBFEXccMMNDvUNHToUe/bsgdlstu/bs2dPXHbZZfblq6++GpGRkdixY4e9rsjISAwcONC+j5+fH0aOHGmvKzMzE+Xl5bW2FlYXHx+PDh062Jc7d+4MADhx4gQAICkpCbt378asWbOwZcuWGt8JESmHwYyIaqVWqzFnzhx8+umnOHr06CUdKzg42GFZq9XWuk6SpBohIDIyssayyWRCQUEBzp49C7PZjP/85z/QaDT2h06ng9FoxPHjxx3eGxUVddFac3Nza90vKioKZ86cuej7qysoKIDZbEZQUJBDfZMnT4bJZEJubm6d52lbZ9snNze31n2q11VYWAgAFx0hWtvPHqgaEHHNNdfggw8+wJYtWzBo0CCEh4fj7rvvxvnz5508cyJqKLWnCyAi7zVlyhQ8/fTTeP7552ts0+v1NUJUbRfvX6q8vLway2q1GuHh4TAYDBAEAfPnz8eIESNqvLdVq1YOy4IgXPTzYmJianwmAJw+fRq9evVyqfbQ0FCo1Wps374doljz/4OrB63aPjMvL88esuqrKzQ0FAAQFhYGQA5xtQ3McMWkSZMwadIk5OfnY/ny5Zg1axYCAgKwYMGCSzouEdWPLWZEVCedTocHHngA77//vkPrDgDExcWhpKTEYeTgt99+2+g1rFixosZyr169oFKp4Ofnhz59+uDPP/9EcnJyjceFwcwZKSkp+OabbxxGde7cuRPZ2dno16+fS8caMmQIzGYzzp07V2t9tpYqAPj1119x7Ngx+/L27duRl5eH3r172+vKy8vDli1b7PuUlZVh7dq19rquuuoq+Pj41Bj1eSkiIiIwffp09O/fH/v372+04xJR7dhiRkT1mj59Op599ln89NNPDtc3XXvttfDx8cGUKVNw//3348iRI7VOZXGp1q9fj0ceeQQDBw7E8uXLsXHjRqxatcq+/YUXXsDQoUMhiiJuvPFGBAQE4NixY1i7di2eeeYZXH755S593n333YdFixZh+PDhmDt3LkpLS/Hggw+iW7duGDt2rEvHuuKKKzBjxgzcfPPNmDNnDpKTk2EwGLBv3z789ddfePfdd+37RkRE4Prrr8cTTzwBg8GAuXPnomfPnrj22msBAMOHD0ffvn0xfvx4LFiwAGFhYXjppZdQXl6O2bNnA5C7KB977DE88sgjqKysxIgRI1BRUYG1a9di3rx5iI2NdaruefPm4cyZM/ZuzN27d+PHH39kaxmRG7DFjIjq5evri1mzZtVYHx4ejmXLluHEiRMYPXo0Pv30U3z++eeN/vnvvvsufv31V4wePRpr1qzBm2++ibS0NPv2fv36YcuWLcjPz8dtt92GUaNG4YUXXkDr1q2duqbsQhEREfjhhx+g1+sxYcIE3H333ejfvz82btzo0MLlrDfffBOPPfYYPv74Y4wYMQKTJ0/G2rVrMWDAAIf9+vbti7vvvhszZ87E1KlT0bVrV6xcudJhn5UrVyI1NRUzZ87EuHHjIEkSvv/+eyQkJNj3eeihh7Bo0SJ89913+Ne//oXp06ejqKgIAQEBTtd85ZVXYv/+/ZgxYwaGDx+ORYsWYf78+fjvf//r8vkTkWsESbJOXENERB5ha5launSpp0shIg9jixkRERGRl2AwIyIiIvIS7MokIiIi8hJsMSMiIiLyEgxmRERERF6CwYyIiIjISzCYEREREXkJBjMiIiIiL/H/fAK3ppN3t2wAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot of training and validation loss\n",
    "print('Lowest loss value: ', history.history['val_loss'][-1])\n",
    "\n",
    "plt.figure(figsize = (10, 7), facecolor = 'white')\n",
    "\n",
    "plt.plot(history.history['loss'], label = 'Training')\n",
    "plt.plot(history.history['val_loss'], label = 'Validation')\n",
    "\n",
    "plt.title('Loss function', fontsize = 17)\n",
    "plt.xlabel('Number of epochs', fontsize = 15)\n",
    "plt.ylabel('Loss', fontsize = 15)\n",
    "\n",
    "plt.legend(fontsize = 15)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6d5ab796-533e-4558-bac4-3b14081572d9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Highest accuracy value:  0.5385151505470276\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot of training and validation accuracy\n",
    "print('Highest accuracy value: ', history.history['val_categorical_accuracy'][-1])\n",
    "\n",
    "plt.figure(figsize = (10, 7), facecolor = 'white')\n",
    "\n",
    "plt.plot(history.history['categorical_accuracy'], label = 'Training')\n",
    "plt.plot(history.history['val_categorical_accuracy'], label = 'Validation')\n",
    "\n",
    "plt.title('Accuracy', fontsize = 17)\n",
    "plt.xlabel('Number of epochs', fontsize = 15)\n",
    "plt.ylabel('Accuracy', fontsize = 15)\n",
    "\n",
    "plt.legend(fontsize = 15)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fc1a908-a891-4a70-9b9c-49b986251bd0",
   "metadata": {},
   "source": [
    "Both loss functions feature a very nice exponential-decay-like shape suggesting a good fit of the weights of the neural network. The accuracy too has a desired shape although here the limitations of our network become evident. At the end of 200 epochs the training accuracy seems to still be rising while the validation accuracy has reached its plateau signaling further accuracy not to be achievable with more training of the same batch. In fact reusing the same training data for too long actually has a negative effect on the network performance. This is called *overfitting* and it's the idea that the network \"learns the training data by heart\" and fixates intrinsic event specific characteristics as relevant for the classification. Conceptually, overfitting can be understood with the following image:\n",
    "\n",
    "<img src=\"images/overfitting.png\" width = 600>\n",
    "\n",
    "To combat overfitting three things can be done:\n",
    "\n",
    "1. Early stopping: Train for short enough such that there's no time for overfitting to take place. This is essentially what we have done.\n",
    "2. Use more data: Using more (varied) data in training diversifies the data set and allows for less epochs to be used.\n",
    "3. Dropout: Artificially setting a certain number of weight values to 0 (or some other number or not consider the weights) during each step of gradient descent \"keeps the neural network honest and open minded\" so to speak. In mathematical terms, dropout prevents the neural network from falling into a local minimum for its fit of weights and not get out. \n",
    "\n",
    "Not visible in the loss (due to the current settings) but very much apparent in the accuracies are fluctuations. These fluctuations can be understood as making a step into the wrong or the right direction in finding the correct weight values and stand in strong correlation with the learning rate of the network. The greater the learning rate the stronger the fluctuations and vice versa:\n",
    "\n",
    "<img src=\"images/learning_rate.png\" width = 600>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd874b23-e2f9-4f37-94f3-b6dfd6ffa55e",
   "metadata": {},
   "source": [
    "## NN performance: ROC curve and AUC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae18c75-27ff-4ee7-8a6e-f5ab45654507",
   "metadata": {},
   "source": [
    "More metrics about the performance of the neural network can be shown and read from the ROC curve and the AUC. \n",
    "\n",
    "The ROC curve, or receiver operating characteristic curve, shows the performance i.e. the classification ability of a binary classifier at various classification thresholds and is achieved by plotting the true positive rate against the false positive rate:\n",
    "\n",
    "### $(1) \\,\\,\\, TPR = \\frac{TP}{TP + FN}$\n",
    "\n",
    "### $(2) \\,\\,\\, FPR = \\frac{FP}{FP + TN}$\n",
    "\n",
    "<img src=\"images/roc.png\" width = 600>\n",
    "\n",
    "The closer the curve is to show the constant line at 1 the better the classification of the network. Since our network, opposed to having a binary classifier, has a multiclassifier, the classification is either tested one class versus another class (OvO) or one class versus the rest (OvR). The calculation of the true/false positive rates is handled by the `roc_curve` function from the `sklearn.metrics` package. You can read more about this package in the [sklearn docs]()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f4047076-2d7b-4537-9683-b547f8d482f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "# output prediction for roc curve\n",
    "prediction_v = net.predict_on_batch(nn_input_validation)\n",
    "prediction_t = net.predict_on_batch(nn_input_test)\n",
    "\n",
    "# false/true positive rates and thresholds\n",
    "fpr_v, tpr_v, thresholds_v = roc_curve(nn_target_validation[:, 0], prediction_v[:, 0])\n",
    "fpr_t, tpr_t, thresholds_t = roc_curve(nn_target_test[:, 0], prediction_t[:, 0])\n",
    "\n",
    "# auc\n",
    "auc_score_v = roc_auc_score(nn_target_validation, prediction_v, average = 'macro', multi_class = 'ovr')\n",
    "auc_score_t = roc_auc_score(nn_target_test, prediction_t, average = 'macro', multi_class = 'ovr')\n",
    "\n",
    "fig = plt.figure(figsize = (15, 7), facecolor = 'white')\n",
    "\n",
    "axes = np.array([fig.add_subplot(1, 2, i) for i in range(1, 3)])\n",
    "\n",
    "# plot for validation\n",
    "axes[0].plot(fpr_v, tpr_v)\n",
    "axes[0].text(0.35, 0.4, f'AUC validation score: \\n{auc_score_v}', fontsize = 17)\n",
    "\n",
    "axes[0].set_title('ROC OvR (validation)', fontsize = 17)\n",
    "axes[0].set_xlabel('False positive rate', fontsize = 15)\n",
    "axes[0].set_ylabel('True positive rate', fontsize = 15)\n",
    "\n",
    "# plot for testing\n",
    "axes[1].plot(fpr_t, tpr_t)\n",
    "axes[1].text(0.35, 0.4, f'AUC testing score: \\n{auc_score_t}', fontsize = 17)\n",
    "\n",
    "axes[1].set_title('ROC OvR (testing)', fontsize = 17)\n",
    "axes[1].set_xlabel('False positive rate', fontsize = 15)\n",
    "axes[1].set_ylabel('True positive rate', fontsize = 15)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f03631b0-a41a-471c-bce0-ef3f1d79ba9b",
   "metadata": {},
   "source": [
    "A more general metric for the performance of a neural network is given by the area under the curve or AUC for short, which can be calculated with the `roc_auc_score` function from the `sklearn.metrics` package.\n",
    "\n",
    "To study the exact classification of the various events into the process classes the confusion matrix is a very good visualization for this. It shows to what extent events with a certain label i.e. from a particular process are classified as such. This is shown in the following cell. The confusion matrix can be calculated using the function `confusion_matrix` from the package `sklearn.metrics`. As arguments it takes the classifications of both the predictions from the network as well as the targets, though not in the shape of the vectors (1 0 0) for example, but as classes 0 (signal), 1 (bgr_tt) and 2 (bgr_st). For that reason all the predictions and targets are first associated with these classes before `confusion_matrix` is run. `ConfusionMatrixDisplay` essentially does the same but in a nice plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "01fff407-0fa8-468c-abe0-54ac08b22610",
   "metadata": {},
   "outputs": [],
   "source": [
    "def confusion_builder(nn_target_data, prediction_data):\n",
    "    \n",
    "    # class arrays for confusion matrix\n",
    "    confused_targets = []\n",
    "    confused_predictions = []\n",
    "\n",
    "    for count, v in enumerate(nn_target_data):\n",
    "\n",
    "        for j, i in enumerate(prediction_data[count]):\n",
    "\n",
    "            if i == max(prediction_data[count]):\n",
    "                confused_predictions.append(j)\n",
    "\n",
    "        if list(v) == [1, 0, 0]:\n",
    "            confused_targets.append(0)\n",
    "        elif list(v) == [0, 1, 0]:\n",
    "            confused_targets.append(1)\n",
    "        else:\n",
    "            confused_targets.append(2)\n",
    "\n",
    "    return confused_targets, confused_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "75de8083-8599-4d4e-9f53-908bbf99cd01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x504 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# confusion matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import ConfusionMatrixDisplay\n",
    "\n",
    "confusion_v = confusion_matrix(confusion_builder(nn_target_validation, prediction_v)[0], \n",
    "                               confusion_builder(nn_target_validation, prediction_v)[1], normalize = 'true')\n",
    "confusion_t = confusion_matrix(confusion_builder(nn_target_test, prediction_t)[0], \n",
    "                               confusion_builder(nn_target_test, prediction_t)[1], normalize = 'true')\n",
    "\n",
    "fig = plt.figure(figsize = (15, 7), facecolor = 'white')\n",
    "\n",
    "axes = np.array([fig.add_subplot(1, 2, i) for i in range(1, 3)])\n",
    "\n",
    "ConfusionMatrixDisplay(confusion_v).plot(ax = axes[0])\n",
    "ConfusionMatrixDisplay(confusion_t).plot(ax = axes[1])\n",
    "\n",
    "axes[0].set_title('Confusion matrix (validation)')\n",
    "axes[1].set_title('Confusion matrix (testing)')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90bc7128-f3f3-4cd1-a442-e2e3ecf85a81",
   "metadata": {},
   "source": [
    "Taking a look at the confusion matrix it is clearly visible that the efficiency of classifying signal events as signal is \"quite high\" at roughly 70%. The same cannot be said about the top pair and single top background events. By the looks of it, the final states are too similar for the network to be able to differentiate the two, though, it is capable of generally differentiating signal from background which is already not bad. There's always room left for the network to be optimized, but this shall be left in your hands :)\n",
    "\n",
    "And now, to finish off this notebook series, one last plot detailing the classification of the signal node in particular. A histogram is made showing and comparing the number of signal  and background events for various signal node values, which is once again a measure of the performance of the network. For this `hist` is used once more to construct and plot the histogram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4fdb5a7e-04dd-45a4-a20d-3ca4d05bd7a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import hist\n",
    "\n",
    "def hist_builder(prediction_input, split_1, split_2):\n",
    "    \n",
    "    predictions = {}\n",
    "\n",
    "    for i, process in enumerate(processes):\n",
    "        predictions[process] = net.predict_on_batch(np.array(prediction_input[process][split_1[i]:split_2[i]]))\n",
    "\n",
    "    network_hist = (\n",
    "            hist.Hist.new\n",
    "            .StrCat(processes, name = \"process\", label = \"process\")\n",
    "            .Reg(20, 0, 1, name = \"classification\", label = \"Signal node classification\")\n",
    "            .Weight()\n",
    "        )\n",
    "\n",
    "    for count, process in enumerate(processes):\n",
    "\n",
    "        network_hist.fill(\n",
    "                process = process,\n",
    "                classification = predictions[process][:, count],\n",
    "                weight = class_weights[count],\n",
    "            )\n",
    "        \n",
    "    return network_hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ca140f20-b6bd-4c17-8169-484f105c5669",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import mplhep\n",
    "\n",
    "plt.style.use(mplhep.style.CMS)\n",
    "\n",
    "fig = plt.figure(figsize = (30, 15), facecolor = 'white', dpi = 40)\n",
    "\n",
    "axes = np.array([fig.add_subplot(1, 2, i) for i in range(1, 3)])\n",
    "\n",
    "mplhep.cms.label(label=\"Private Work\", ax = axes[0])\n",
    "mplhep.cms.label(label=\"Private Work\", ax = axes[1])\n",
    "\n",
    "for count, process in enumerate(processes):\n",
    "\n",
    "    hist_builder(nn_input, training_split, validation_split)[count, :].plot1d(\n",
    "        ax = axes[0],\n",
    "        overlay = \"process\",\n",
    "        histtype = \"step\",\n",
    "        stack = False,\n",
    "        alpha = 1,\n",
    "        # edgecolor = (0, 0, 0, 0.3),\n",
    "        label = process,\n",
    "        linewidth = 3.5,\n",
    "    )\n",
    "\n",
    "    hist_builder(nn_input, validation_split, test_split)[count, :].plot1d(\n",
    "        ax = axes[1],\n",
    "        overlay = \"process\",\n",
    "        histtype = \"step\",\n",
    "        stack = False,\n",
    "        alpha = 1,\n",
    "        # edgecolor = (0, 0, 0, 0.3),\n",
    "        label = process,\n",
    "        linewidth = 3.5,\n",
    "    )\n",
    "\n",
    "axes[0].set_ylabel('Number of events (validation)')\n",
    "axes[1].set_ylabel('Number of events (testing)')\n",
    "    \n",
    "axes[0].legend()    \n",
    "axes[1].legend()    \n",
    "    \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5fa5399-dd48-4b4e-913b-e9942d9eb1a4",
   "metadata": {},
   "source": [
    "Comparing the validation and the testing of the last 3 pairs of plots, the ROC curves, confusion matrices and signal node classifications, it is evident that the neural network that we have constructed performs quite admirably and shows no signs of overfitting. This is suggested by how similar the network performs with data which wasn't used during training vs. data which was used during training.\n",
    "\n",
    "You have now finished the introduction to CMS event selection and machine learning and can now call yourself a certified geek!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "553e49a4-ca8d-406a-bf00-756991fcab4f",
   "metadata": {},
   "source": [
    "# BACKUP CELLS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "305ed109-4cce-41ad-9737-d8a1f630e9d4",
   "metadata": {},
   "source": [
    "## Image Sources"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac79082c-2403-46c0-b8c9-fa16c520937c",
   "metadata": {},
   "source": [
    "[Overfitting](    \n",
    "https://builtin.com/sites/www.builtin.com/files/styles/ckeditor_optimize/public/inline-images/national/underfitting%2520and%2520overfitting%2520example.png)\n",
    "\n",
    "[Learning rate](\n",
    "https://miro.medium.com/proxy/0*QwE8M4MupSdqA3M4.png)\n",
    "\n",
    "[ROC](\n",
    "https://developers.google.com/static/machine-learning/crash-course/images/ROCCurve.svg)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cms-analysis",
   "language": "python",
   "name": "cms-analysis"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}