{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# How to rediscover the Higgs boson yourself - with a BDT!\n", "This notebook uses ATLAS Open Data http://opendata.atlas.cern to show you the steps to apply Machine Learning in search for the Higgs boson!\n", "\n", "ATLAS Open Data provides open access to proton-proton collision data at the LHC for educational purposes. ATLAS Open Data resources are ideal for high-school, undergraduate and postgraduate students.\n", "\n", "Notebooks are web applications that allow you to create and share documents that can contain for example:\n", "1. live code\n", "2. visualisations\n", "3. narrative text\n", "\n", "This notebook builds on [HZZAnalysis.ipynb](https://github.com/atlas-outreach-data-tools/notebooks-collection-opendata/blob/master/13-TeV-examples/uproot_python/HZZAnalysis.ipynb) in the same folder as this notebook. \n", "\n", "HZZAnalysis.ipynb loosely follows the [discovery of the Higgs boson by ATLAS](https://www.sciencedirect.com/science/article/pii/S037026931200857X) (mostly Section 4 and 4.1)\n", "\n", "Notebooks are a perfect platform to develop Machine Learning for your work, since you'll need exactly those 3 things: code, visualisations and narrative text!\n", "\n", "We're interested in Machine Learning because we can design an algorithm to figure out for itself how to do various analyses, potentially saving us countless human-hours of design and analysis work.\n", "\n", "Machine Learning use within ATLAS includes: \n", "* particle tracking\n", "* particle identification\n", "* signal/background classification\n", "* and more!\n", "\n", "This notebook will focus on signal/background classification.\n", "\n", "By the end of this notebook you will be able to:\n", "1. run a Boosted Decision Tree to classify signal and background\n", "2. know some things you can change to improve your Boosted Decision Tree\n", "\n", "Feynman diagram pictures are borrowed from our friends at https://www.particlezoo.net" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Contents: \n", "\n", "[Running a Jupyter notebook](#running)
\n", "[First time setup on your computer (no need on mybinder)](#setup_computer)
\n", "[To setup everytime](#setup_everytime)
\n", "[Lumi, fraction, file path](#fraction)
\n", "[Samples](#samples)
\n", "[Changing a cut](#changing_cut)
\n", "[Applying a cut](#applying_cut)
\n", "[Optimisation](#optimisation)
\n", "[Boosted Decision Tree (BDT)](#BDT)
\n", "  [Training and Testing split](#train_test)
\n", "  [Training Decision Trees](#training)
\n", "  [Assessing a Classifier's Performance](#performance)
\n", "  [Receiver Operating Characteristic (ROC) curve](#ROC)
\n", "  [Overtraining check](#overtraining)
\n", "  [Optimisation](#BDT_optimisation)
\n", "[Going further](#going_further)
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Running a Jupyter notebook\n", "\n", "To run the whole Jupyter notebook, in the top menu click Cell -> Run All.\n", "\n", "To propagate a change you've made to a piece of code, click Cell -> Run All Below.\n", "\n", "You can also run a single code cell, by clicking Cell -> Run Cells, or using the keyboard shortcut Shift+Enter." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## First time setup on your computer (no need on mybinder)\n", "This first cell only needs to be run the first time you open this notebook on your computer. \n", "\n", "If you close Jupyter and re-open on the same computer, you won't need to run this first cell again.\n", "\n", "If you open on mybinder, you don't need to run this cell." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import sys\n", "!{sys.executable} -m pip install --upgrade --user pip # update the pip package installer\n", "!{sys.executable} -m pip install uproot3 pandas numpy matplotlib sklearn --user # install required packages" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## To setup everytime\n", "Cell -> Run All Below\n", "\n", "to be done every time you re-open this notebook.\n", "\n", "We're going to be using a number of tools to help us:\n", "* uproot: lets us read .root files typically used in particle physics into data formats used in Machine Learning\n", "* pandas: lets us store data as dataframes, a format widely used in Machine Learning\n", "* numpy: provides numerical calculations such as histogramming\n", "* matplotlib: common tool for making plots, figures, images, visualisations" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import uproot3 # for reading .root files\n", "import pandas as pd # to store data as dataframe\n", "import time # to measure time to analyse\n", "import math # for mathematical functions such as square root\n", "import numpy as np # # for numerical calculations such as histogramming\n", "import matplotlib.pyplot as plt # for plotting\n", "from matplotlib.ticker import AutoMinorLocator # for minor ticks\n", "\n", "import infofile # local file containing info on cross-sections, sums of weights, dataset IDs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Lumi, fraction, file path\n", "\n", "General definitions of fraction of data used, where to access the input files" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "lumi = 10 # fb-1 # data_A+B+C+D\n", "\n", "fraction = 0.03 # reduce this is you want the code to run quicker\n", " \n", "#tuple_path = \"Input/4lep/\" # local \n", "tuple_path = \"https://atlas-opendata.web.cern.ch/atlas-opendata/samples/2020/4lep/\" # web address" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Samples\n", "\n", "In this notebook we only process the signal H->ZZ and the main background ZZ, for illustration purposes. You can add data and the Z and ttbar backgrounds after if you wish." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "samples = {\n", "\n", " 'ZZ' : {\n", " 'list' : ['llll']\n", " },\n", "\n", " r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$' : { # H -> ZZ -> llll\n", " 'list' : ['ggH125_ZZ4lep'] # gluon-gluon fusion\n", " }\n", "\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define function to get data from files.\n", "\n", "The datasets used in this notebook have already been filtered to include at least 4 leptons per event, so that processing is quicker." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def get_data_from_files():\n", "\n", " data = {} # define empty dictionary to hold dataframes\n", " for s in samples: # loop over samples\n", " print('Processing '+s+' samples') # print which sample\n", " frames = [] # define empty list to hold data\n", " for val in samples[s]['list']: # loop over each file\n", " if s == 'data': prefix = \"Data/\" # Data prefix\n", " else: # MC prefix\n", " prefix = \"MC/mc_\"+str(infofile.infos[val][\"DSID\"])+\".\"\n", " fileString = tuple_path+prefix+val+\".4lep.root\" # file name to open\n", " temp = read_file(fileString,val) # call the function read_file defined below\n", " frames.append(temp) # append dataframe returned from read_file to list of dataframes\n", " data[s] = pd.concat(frames) # dictionary entry is concatenated dataframes\n", " \n", " return data # return dictionary of dataframes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "define function to get cross-section weight" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def get_xsec_weight(sample):\n", " info = infofile.infos[sample] # open infofile\n", " xsec_weight = (lumi*1000*info[\"xsec\"])/(info[\"sumw\"]*info[\"red_eff\"]) #*1000 to go from fb-1 to pb-1\n", " return xsec_weight # return cross-section weight" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "define function to calculate weight of MC event" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def calc_weight(xsec_weight, mcWeight, scaleFactor_PILEUP,\n", " scaleFactor_ELE, scaleFactor_MUON, \n", " scaleFactor_LepTRIGGER ):\n", " return xsec_weight*mcWeight*scaleFactor_PILEUP*scaleFactor_ELE*scaleFactor_MUON*scaleFactor_LepTRIGGER" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We add functions to return the individual lepton transverse momenta, in GeV" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def calc_lep_pt_i(lep_pt,i):\n", " return lep_pt[i]/1000 # /1000 to go from MeV to GeV" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Changing a cut\n", "\n", "We apply 'cuts' to throw away collisions that have properties different to the signal we're looking for.\n", "\n", "If you change a cut: Cell -> Run All Below\n", "\n", "If you change a cut here, you also need to make sure the cut is applied in the \"[Applying a cut](#applying_cut)\" cell." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# cut on lepton charge\n", "# paper: \"selecting two pairs of isolated leptons, each of which is comprised of two leptons with the same flavour and opposite charge\"\n", "def cut_lep_charge(lep_charge):\n", "# throw away when sum of lepton charges is not equal to 0\n", "# first lepton is [0], 2nd lepton is [1] etc\n", " return lep_charge[0] + lep_charge[1] + lep_charge[2] + lep_charge[3] != 0\n", "\n", "# cut on lepton type\n", "# paper: \"selecting two pairs of isolated leptons, each of which is comprised of two leptons with the same flavour and opposite charge\"\n", "def cut_lep_type(lep_type):\n", "# for an electron lep_type is 11\n", "# for a muon lep_type is 13\n", "# throw away when none of eeee, mumumumu, eemumu\n", " sum_lep_type = lep_type[0] + lep_type[1] + lep_type[2] + lep_type[3]\n", " return (sum_lep_type != 44) and (sum_lep_type != 48) and (sum_lep_type != 52)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Applying a cut\n", "If you add a cut: Cell -> Run All Below" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def read_file(path,sample):\n", " start = time.time() # start the clock\n", " print(\"\\tProcessing: \"+sample) # print which sample is being processed\n", " data_all = pd.DataFrame() # define empty pandas DataFrame to hold all data for this sample\n", " tree = uproot3.open(path)[\"mini\"] # open the tree called mini\n", " numevents = uproot3.numentries(path, \"mini\") # number of events\n", " if 'data' not in sample: xsec_weight = get_xsec_weight(sample) # get cross-section weight\n", " for data in tree.iterate(['lep_charge','lep_type','lep_pt',\n", " # uncomment these variables if you want to calculate masses \n", " #,'lep_eta','lep_phi','lep_E', \n", " # add more variables here if you make cuts on them \n", " 'mcWeight','scaleFactor_PILEUP',\n", " 'scaleFactor_ELE','scaleFactor_MUON',\n", " 'scaleFactor_LepTRIGGER'\n", " ], # variables to calculate Monte Carlo weight\n", " outputtype=pd.DataFrame, # choose output type as pandas DataFrame\n", " entrystop=numevents*fraction): # process up to numevents*fraction\n", "\n", " nIn = len(data.index) # number of events in this batch\n", "\n", " if 'data' not in sample: # only do this for Monte Carlo simulation files\n", " # multiply all Monte Carlo weights and scale factors together to give total weight\n", " data['totalWeight'] = np.vectorize(calc_weight)(xsec_weight,\n", " data.mcWeight,\n", " data.scaleFactor_PILEUP,\n", " data.scaleFactor_ELE,\n", " data.scaleFactor_MUON,\n", " data.scaleFactor_LepTRIGGER)\n", "\n", " # cut on lepton charge using the function cut_lep_charge defined above\n", " fail = data[ np.vectorize(cut_lep_charge)(data.lep_charge) ].index\n", " data.drop(fail, inplace=True)\n", "\n", " # cut on lepton type using the function cut_lep_type defined above\n", " fail = data[ np.vectorize(cut_lep_type)(data.lep_type) ].index\n", " data.drop(fail, inplace=True)\n", "\n", " # return the individual lepton transverse momenta in GeV\n", " data['lep_pt_1'] = np.vectorize(calc_lep_pt_i)(data.lep_pt,1)\n", " data['lep_pt_2'] = np.vectorize(calc_lep_pt_i)(data.lep_pt,2)\n", " \n", " # dataframe contents can be printed at any stage like this\n", " #print(data)\n", "\n", " # dataframe column can be printed at any stage like this\n", " #print(data['lep_pt'])\n", "\n", " # multiple dataframe columns can be printed at any stage like this\n", " #print(data[['lep_pt','lep_eta']])\n", "\n", " nOut = len(data.index) # number of events passing cuts in this batch\n", " data_all = data_all.append(data) # append dataframe from this batch to the dataframe for the whole sample\n", " elapsed = time.time() - start # time taken to process\n", " print(\"\\t\\t nIn: \"+str(nIn)+\",\\t nOut: \\t\"+str(nOut)+\"\\t in \"+str(round(elapsed,1))+\"s\") # events before and after\n", " \n", " return data_all # return dataframe containing events passing all cuts\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is where the processing happens (this will take some minutes)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing ZZ samples\n", "\tProcessing: llll\n", "\t\t nIn: 16628,\t nOut: \t15740\t in 105.9s\n", "Processing $H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$ samples\n", "\tProcessing: ggH125_ZZ4lep\n", "\t\t nIn: 4941,\t nOut: \t4841\t in 250.9s\n", "Time taken: 356.7s\n" ] } ], "source": [ "start = time.time() # time at start of whole processing\n", "data = get_data_from_files() # process all files\n", "elapsed = time.time() - start # time after whole processing\n", "print(\"Time taken: \"+str(round(elapsed,1))+\"s\") # print total time taken to process every file" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optimisation\n", "\n", "Here we define histograms for the variables that we'll look to optimise" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "lep_pt_2 = { # dictionary containing plotting parameters for the lep_pt_2 histogram\n", " # change plotting parameters\n", " 'bin_width':1, # width of each histogram bin\n", " 'num_bins':13, # number of histogram bins\n", " 'xrange_min':7, # minimum on x-axis\n", " 'xlabel':r'$lep\\_pt$[2] [GeV]', # x-axis label\n", "}\n", "\n", "lep_pt_1 = { # dictionary containing plotting parameters for the lep_pt_1 histogram\n", " # change plotting parameters\n", " 'bin_width':1, # width of each histogram bin\n", " 'num_bins':28, # number of histogram bins\n", " 'xrange_min':7, # minimum on x-axis\n", " 'xlabel':r'$lep\\_pt$[1] [GeV]', # x-axis label\n", "}\n", "\n", "SoverB_hist_dict = {'lep_pt_2':lep_pt_2,'lep_pt_1':lep_pt_1} \n", "# add a histogram here if you want it plotted" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we define a function to illustrate the optimum cut value on individual variables, based on signal to background ratio." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def plot_SoverB(data):\n", " \n", " signal = r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$' # which sample is the signal\n", "\n", " # *******************\n", " # general definitions (shouldn't need to change)\n", "\n", " for x_variable,hist in SoverB_hist_dict.items(): # access the dictionary of histograms defined in the cell above\n", "\n", " h_bin_width = hist['bin_width'] # get the bin width defined in the cell above\n", " h_num_bins = hist['num_bins'] # get the number of bins defined in the cell above\n", " h_xrange_min = hist['xrange_min'] # get the x-range minimum defined in the cell above\n", " h_xlabel = hist['xlabel'] # get the x-axis label defined in the cell above\n", " \n", " bin_edges = [ h_xrange_min + x*h_bin_width for x in range(h_num_bins+1) ] # bin limits\n", " bin_centres = [ h_xrange_min+h_bin_width/2 + x*h_bin_width for x in range(h_num_bins) ] # bin centres\n", " \n", " signal_x = data[signal][x_variable] # histogram the signal\n", " \n", " mc_x = [] # define list to hold the Monte Carlo histogram entries\n", "\n", " for s in samples: # loop over samples\n", " if s not in ['data', signal]: # if not data nor signal\n", " mc_x = [*mc_x, *data[s][x_variable] ] # append to the list of Monte Carlo histogram entries\n", "\n", " \n", " \n", " # *************\n", " # Signal and background distributions\n", " # *************\n", " distributions_axes = plt.gca() # get current axes\n", " \n", " mc_heights = distributions_axes.hist(mc_x, bins=bin_edges, color='red', \n", " label='Total background',\n", " histtype='step', # lineplot that's unfilled\n", " density=True ) # normalize to form probability density\n", " signal_heights = distributions_axes.hist(signal_x, bins=bin_edges, color='blue',\n", " label=signal, \n", " histtype='step', # lineplot that's unfilled\n", " density=True, # normalize to form probability density\n", " linestyle='--' ) # dashed line\n", " \n", " distributions_axes.set_xlim( left=bin_edges[0], right=bin_edges[-1] ) # x-limits of the distributions axes\n", " distributions_axes.set_ylabel('Arbitrary units' ) # y-axis label for distributions axes\n", " distributions_axes.set_ylim( top=max(signal_heights[0])*1.3 ) # set y-axis limits\n", " plt.title('Signal and background '+x_variable+' distributions') # add title\n", " distributions_axes.legend() # draw the legend\n", " distributions_axes.set_xlabel( h_xlabel ) # x-axis label\n", " \n", " # Add text 'ATLAS Open Data' on plot\n", " plt.text(0.05, # x\n", " 0.93, # y\n", " 'ATLAS Open Data', # text\n", " transform=distributions_axes.transAxes, # coordinate system used is that of distributions_axes\n", " fontsize=13 ) \n", " # Add text 'for education' on plot\n", " plt.text(0.05, # x\n", " 0.88, # y\n", " 'for education', # text\n", " transform=distributions_axes.transAxes, # coordinate system used is that of distributions_axes\n", " style='italic',\n", " fontsize=8 ) \n", " \n", " plt.show() # show the Signal and background distributions\n", " \n", " \n", " # *************\n", " # Signal to background ratio\n", " # *************\n", " plt.figure() # start new figure\n", " SoverB = [] # list to hold S/B values\n", " for cut_value in bin_edges: # loop over bins\n", " signal_weights_passing_cut = sum(data[signal][data[signal][x_variable]>cut_value].totalWeight)\n", " background_weights_passing_cut = 0 # start counter for background weights passing cut\n", " for s in samples: # loop over samples\n", " if s not in ['data', signal]: # if not data nor signal\n", " background_weights_passing_cut += sum(data[s][data[s][x_variable]>cut_value].totalWeight)\n", " if background_weights_passing_cut!=0: # some background passes cut\n", " SoverB_value = signal_weights_passing_cut/background_weights_passing_cut\n", " SoverB_percent = 100*SoverB_value # multiply by 100 for percentage\n", " SoverB.append(SoverB_percent) # append to list of S/B values\n", " \n", " SoverB_axes = plt.gca() # get current axes\n", " SoverB_axes.plot( bin_edges[:len(SoverB)], SoverB ) # plot the data points\n", " SoverB_axes.set_xlim( left=bin_edges[0], right=bin_edges[-1] ) # set the x-limit of the main axes\n", " SoverB_axes.set_ylabel( 'S/B (%)' ) # write y-axis label for main axes\n", " plt.title('Signal to background ratio for different '+x_variable+' cut values', family='sans-serif')\n", " SoverB_axes.set_xlabel( h_xlabel ) # x-axis label \n", " \n", " plt.show() # show S/B plot\n", " \n", " return" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we call our function to illustrate the optimum cut value on individual variables, based on signal to background ratio.\n", "\n", "We're not doing any Machine Learning yet! We're looking at the variables we'll later use for Machine Learning.\n", "\n", "Let's talk through the lep_pt_2 plots.\n", "1. Imagine placing a cut at 7 GeV in the distributions of signal and background (1st plot). This means keeping all events above 7 GeV in the signal and background histograms. \n", "2. We then take the ratio of the number of signal events that pass this cut, to the number of background events that pass this cut. This gives us a starting value for S/B (2nd plot). \n", "3. We then increase this cut value to 8 GeV, 9 GeV, 10 GeV, 11 GeV, 12 GeV. Cuts at these values are throwing away more background than signal, so S/B increases. \n", "4. There comes a point around 13 GeV where we start throwing away too much signal, thus S/B starts to decrease. \n", "5. Our goal is to find the maximum in S/B, and place the cut there.\n", "\n", "The same logic applies to lep_pt_1." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEbCAYAAADNr2OMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3deXgUVdbA4d8xrAISNoUAElBBI5skwuCGgArIpowLiiMoGlEQ13GZDdQZx8F1HJ0RRERREYQZZZlvEFHcFyCyGBBZBAlBWYMgsiQ53x9V3XaSTlIdekvnvM/TD91Vt6pOdZo+XffeuldUFWOMMcarY2IdgDHGmMrFEocxxpiQWOIwxhgTEkscxhhjQmKJwxhjTEgscRhjjAmJJY4oEZFhIvJ2FI5zvojkRPo47rGmisifS1k3QkQ+isAxF4vIDeHeb6TF4r2KRyKySUQucJ//TkQmh3Hf+0Wkjfu81Pe7gvt+TkT+GK79VXaWOMJIRM4RkU9EZK+I7BaRj0XkTABVfVVVL4p1jMYUF0riEpHfishXIrJPRL4Vkd9W9Liq+rCqlvsjwOuPBVWtq6obKxpPwPFKvB+qOkpVHzrafSeKarEOIFGIyHHAPOBmYCZQAzgXOBTLuExwIlJNVfNjHUclJMC1wErgJOBtEdmiqq/HLCD7W0adXXGET1sAVZ2uqgWq+rOqvq2qK6HkrxgRuUhE1rpXJ/8Ukfd9v6p8ZUXkMRHZ4/6y6xew7XUissb91bdRRG7yGqSI/F1EtojIjyKyTETODVg3XkRmisjL7r6zRSQjYP0ZIpLlrpsB1Cr/cPKMe45fi0hvr+cgIoNFZLkb5wYR6Rtk581EZKXvV6+ItBaRD9x9viMiz4rIK+66VBFRERkpIt8B74rIMSLyBxHZLCLb3fOu75YvUeVXrJol3O9V4HFOFZGF7lXrWhG5ImDdVLfaZKG77/dFpJWHfaqIjHXf650i8qh7/qcBzwHdxanqyStrP6o6QVWzVDVfVdcCbwFnl3Hc37jv7y4R+X2xdeMD/j61ROQVt1yeiCwRkRNE5C84P8CeceN7JuB8RovIOmBdwLKTAw7RONj7FPBZqBYQy2IRuaG090OKVX2JyI0ist79G80RkZRi7/UoEVnnnsuzIiLuupPdWPa6f4cZZb3f8coSR/h8AxSIyEsi0k9EGpRWUEQaA7OA+4FGwFrgrGLFurnLGwMTgBd8Hz5gOzAAOA64DnhSRLp4jHMJ0BloCLwGvCEigV9qg4DXgWRgDuD7j1oDeBOY5m77BvDrco7VDdjgnsM44N8i0rC8cxCRrsDLwG/dOM4DNgXuWERaA+8Dz6jqo+7i14AvcN7T8cBvgsTUAzgN6AOMcB89gTZAXd/5ehTO98p3XnWAhe65HA8MBf4pImkBxYYBD+G8r8uBVz3GeymQAXQBBgPXq+oaYBTwqVvVk+xxX7ifx3OB7FLWpwH/wvk7pOD8XVqUsrvhQH2gpVtuFPCzqv4e+BAY48Y3JmCbS3A+Y2nFd+YK+X3y8n6ISC/gr8AVQDNgM87nINAA4Eygo1uuj7v8IeBtoAHOe/GP8mKKR5Y4wkRVfwTOARR4Htjh/hI5IUjxi4FsVf23e4n9NPB9sTKbVfV5VS0AXsL5gJ7gHmu+qm5Qx/s4H8Rz8UBVX1HVXe4vxseBmkC7gCIfqep/3eNOAzq5y38FVAeeUtUjqjoLJwmVZXtA+Rk4ibC/h3MYCUxR1YWqWqiqW1X164D9pgHvAeNUdRKAiJyI8x/1T6p6WFU/wvkyL268qv6kqj/jfLE8oaobVXU/TiIfGvhLtBzhfK98BgCbVPVF92/0JTAbuDygzHxV/UBVDwG/x/l13NLDvv+mqrtV9TvgKeAqjzGVZjzOd8iLpay/DJgXEOsfgcJSyh7BSRgnu1fsy9z/U2X5q3s+P5eyvqLvU3mG4Xw+s9x93+/uOzWgzCOqmue+1+/h/FgD5zxbASmqetD9nFY6ljjCSFXXqOoIVW0BtMf5lfVUkKIpwJaA7RQo3hPq+4D1B9yndQHcK5rP3MvkPJxE1NhLjCJytzhVRHvdbesX2zYwgR0AarlfpCnAVi06Kubmcg4XrHyKh3NoiXOlUpphwFacqzafFGB3wHsFAe9xKctSip3DZpx2v2DJPphwvlc+rYBubhVHnvveDAOaBjsHN+Htdo9ZnsBz9/8tKkJExuC0dfR3vzyDKf45/wnYVUrZacAC4HURyRWRCSJSvZwwgv19g64P8X0qT5HPjbvvXUDzgDLFPxt13ef34LQTfSFO9eb1YYgn6ixxRIj7C3kqTgIpbhsBl+zuJX9pl/BFiEhNnF+gjwEnuJfS/8X5MJa37bk4H9wrgAbutnu9bOvG3DygugzgxHK2CVY+18M5bMFpeC3NeGAn8JqIJAXE11BEjg0oF+zXZeCXeS7OF3VgfPnAD8BPgH9f7nGalBFToIq8Vz5bgPdVNTngUVdVbw4o4z8vEamLUx2W62Hfge/HiQHbhDREtvtldx/QW1XL6vq9rVisx+JcVZTgXpk9oKppONW2A3ASU1nxlRd3ae/TT+7iwM9KYGIub79FPjdu9WIjnB8zZVLV71X1RlVNAW7CqYY8ubzt4o0ljjARp0HzLhFp4b5uiVMV8FmQ4vOBDiJyifsLdTRFP7hlqYFTvbQDyBen0dxrN996OF+MO4BqIvInnDYGLz51tx0rItVFZAjQtZxtjg8ofzlO28J/PZzDC8B1ItJbnAbc5iJyasD6IzhVN3WAl0XkGFXdDCwFxotIDRHpDgwsJ77pwB3iNKrXBR4GZrjVh9/gXEH0d3/5/sGN2YuKvFc+84C24jQqV3cfZ7qNtj4Xi9P1uwZOnflnqlrer2+A34pIA/ezeRvga5j9AWjh7q9MIjIM5326UMvv+joLGBAQ64OU8p0jIj1FpIOboH/E+Rv7qrV+wGmDClXQ90lVd+B8yV8jIkluIgz8oVLe+zEd5/PZ2f0R9DDwuapuKi8gEbnc9x0B7MFJUqVV38UtSxzhsw+noe5zEfkJJ2F8BdxVvKCq7sT54puAc4mbhvOlV27XXVXdB4zF6fK7B7ia4HX5wSwA/ofzpbgZOEj5l/u+4x4GhuA0Ju8GrgT+Xc5mnwOn4Fwd/AW4zG1fKfMcVPUL3AZznCui9yl6ZRAYzwnAFBE5BqdKpzvOe/pnnC/Gst7TKThVJB8A3+K8H7e6+98L3AJMxvmS+YmS1YlBVfC98m27DyeJDsX5Zfs98DeKJq3XcDob7AbSgWu87BunB9QynIbi+TgJGuBdnAbu70VkZzn7+DPOr+sl4vQ62i8iz5VyLtk4P4pew7n62EPp72FTnETzI7AG528+zV33d+AycXoYPl3uWf6irPfpRpzOF7uA04FPAtaV+X6o6js47TWz3fM6Cefv5cWZON8R+3E+87d5SMBxR9Qmcoo590svBximqu/FOp5EIU5Xx69VdVysYwkXEZkK5KjqH0LcToFTVHV9RAIzVYpdccSIiPQRkWT3Uvd3OPX7waq1jEdulc5JbvVWX5wup2/GOi5jEo0ljtjpjtNzaCdOXfwlZXQrNN40BRYD+3G6ON/sdmdNeCJybkDVUZFHBfaVXcq+hkUidlP5RLSqyv3V93cgCZisqo8UW38eTnfVjsBQt7+7b92JOPXLLXEakC720vhkjDEmsiJ2xeH2jngW6IfT+HuVFL37FeA7nAbE14Ls4mXgUVU9DadHyvZIxWqMMca7SA5y2BVY7+sxICKv49Q5r/YV8F1BiEiR7mhugqmmqgvdciFfbhtjjImMSCaO5hTt6pmD013Vi7ZAnoj8G2gNvAPc5w7tEFTjxo01NTW1gqEaY0zVtGzZsp2q6vXmViB+h1WvhjNu0Rk41VkzcKq0XggsJCKZQCbAiSeeyNKlS6MbpTHGVHIi4nU4HL9I9qraStEhDlrg4ZZ8Vw6w3B18Lh+nS2WJ0V9VdZKqZqhqRpMmISVMY4wxFRTJxLEEOMUdzqEGzp2VXu9wXgIki4gvG/QioG3EGGNM7EQscbhXCmNwhrlYA8xU1WwReVBEBoH/hq0cnOE3JopItrttAXA3sEhEVuHcHPd8pGI1xhjjXcIMOZKRkaHWxmFMxR05coScnBwOHjwY61BMBNSqVYsWLVpQvXrR0epFZJmqZpSyWXCqmhCP9PR0Dac///nPCujUqVNVVXXz5s1ap04d/yMpKUmrV6/uf52Wlqaqqq1atdJp06aVue+PPvpIAR0xYkSJddu3b9frr79eU1JStE6dOtq0aVPt27ev5ubmlrq/goICffzxxzUtLU1r166tDRs21CFDhmh2dvZRvANH79tvv1VAjz32WK1bt64mJydrenq6jhs3TvPy8jzv57333tOkpKQIRmpUVTdu3Kg7duzQwsLCWIdiwqywsFB37NihGzduLLEOWKohft/akCNBFBYW8vzzz9OwYUMmTZoEOL229u/f73+cf/75/O53v/O/zs4OOntmUBMnTqRhw4bMnDmTvXv3Fll3zTXXsG/fPr788kv279/PihUruOqqqyg6tUNR1113HU888QRPPvkkeXl5fPXVV5xwwgl069aNlStXVuxNCKO1a9eyb98+tm/fztNPP82iRYvIyMhg167S5vQxsXDw4EEaNWpU5mfNVE4iQqNGjcJ2NWmJI4gFCxawdetWXn75ZT755BO++uqrsO17z549vPHGG/zjH/+gdu3aTJs2rcj6Tz75hBEjRnD88ccDcPzxx3PttdfStGnw6To++ugjXn75ZV599VUuuugiatSoQbNmzfjnP/9JRkYGd955p7+siPDUU0/RuXNn6tWrR8+ePVm//pfBUvPz83n44Ydp27YtycnJnH322UW6OI8YMYLf/OY33HjjjSQnJ9O8eXMmTpzo+dyrV6/OWWedxVtvvcXevXt54oknADhw4ABDhgyhadOmHHfccXTp0oWFCxcCkJubS79+/SgoKKBu3brUrVuXl156CXASZsuWLalXrx5paWm89lqwAQhMKCxpJK6w/m1DvUSJ10c4q6ouueQSHThwoKqqduzYUceMGVOiTO/evXXcuHEllpdXVfXUU09p48aN9dChQzp27Fjt0KFDkfUXX3yxpqWl6cSJEzUrK0vz8/PLjPX+++/XFi1aBF03efJkTUpK0gMHDqiqKqCnnXaarlu3Tg8cOKCjR4/W0047zX+M3/3ud9q1a1fdsGGD5ufn6+TJk7VRo0a6e/duVVUdPny41qpVS9966y0tKCjQ2bNna7Vq1XTTpk1Bj++rqtqyZUuJdVdffbV269ZNVVX37dun06ZN0x9//FEPHz6sEyZM0Hr16un27dtVtfSqqsmTJ+vOnTs1Pz9fp0+frtWrV4959Vxltnr16pgef+fOndqpUyft1KmTnnDCCZqSkuJ/fejQoSJln3zySf3pp5/K3WePHj10yZIlJZa3atVKd+zYcdQx16lT56j3EQnDhw/XN954o8TyYH9jrKrq6OXm5jJv3jyuv96ZCnjkyJG88sor/PxzeAaunTRpEsOGDaNGjRqMHDmSVatW8emnn/rXz5gxg2uuuYYXX3yRs846i0aNGnH77beXeom5Y8cOmjdvHnRdSkoKBQUF7N6927/srrvu4uSTT6Z27dpMmDCBDRs28Pnnn6OqPP300zz66KO0adOGpKQkRo4cSbNmzZg/f75/+169ejFo0CCOOeYYhgwZQnJyMsuXLw/5fWjRooW/qqpu3bpcc8011KtXj+rVq/Pb3/6WGjVqsGTJkjL3MXLkSBo1akRSUhJDhw6lY8eOLF68OORYTClSU0EkfI9yRnZo1KgRy5cvZ/ny5YwaNYo77rjD/7pGjaKT8T311FMcOHCglD1VDgUFpQ6EEfcscRTzwgsv0LBhQwYMGAA4bQ4///wzM2bMKGfL8n344YesXr3an5Q6duxIRkZGkeqeunXrcv/99/Ppp5+yd+9eXn75ZV588UUefvjhoPts0qQJW7cGv68yNzeXpKQkGjZs6F8WOCzLscceS5MmTcjJyWHnzp3s37+fgQMHkpyc7H9s3LiRnJxfJm1r1qxZkWPUqVOHffv2hfxe5OTk0KiRM/30zz//zJgxY2jTpg3HHXccycnJ7Nmzhx07dpS6fWFhIX/6059o164d9evXJzk5mRUrVpS5jQnR5s2gGr7H5pBvUGbRokWcccYZdOjQgeuvv55Dhw7x9NNPk5ubS8+ePenZsycAN998MxkZGZx++umMG+dt3q4JEybQoUMHunbt6q+ynTt3Lt26deOMM87gggsu4IcffgBg//79XHfddXTo0IGOHTsye/bsIvvauXMn3bt3Z/78+RQWFnLLLbdw6qmncuGFF3LxxRcza5Yz8Hdqair33nsvXbp04Y033mD69Ol06NCB9u3bc++99/r3V7duXf/zWbNmMWLECMCpLh47dixnnXUWbdq08e9XVRkzZgzt2rXjggsuYPv2yI4Ja4kjQGFhIS+88AJ5eXm0aNGCpk2bkpaWRkFBQUh1+aXxNbRfdNFFNG3alKZNm7J69WpmzpxJXl5eifI1atRg0KBBXHDBBaX+qu/bty85OTl8+OGHJda99tpr9OjRg9q1a/uXbdq0yf/8wIED7NixgxYtWtC4cWPq1KnDO++8Q15env/x008/cd999x3lmRe1Z88eFi5cSK9evQB44okn+OCDD1i0aBF79+4lLy+PBg0a4FxFwzHHlPyYTp8+ncmTJzN79mz27NlDXl4enTp18m9jKr+DBw8yYsQIZsyYwapVq8jPz+df//oXY8eOJSUlhffee4/33nMmzPzLX/7C0qVLWblyJe+//76nTiH169dn1apVjBkzhttvvx2Ac845h88++4wvv/ySoUOHMmHCBAAeeughf/mVK1f6P7sAP/zwA/379+fBBx+kf//+/Pvf/2bTpk2sXr2aadOmFalRAOfKKisri/POO497772Xd999l+XLl7NkyRLefLP8ece2bdvGRx99xLx58/z/N//zn/+wdu1aVq9e7W+bjSRLHAH+97//sWXLFj755BP/JfLy5cuZN28en332GatWrfK0nyNHjnDw4EH/49ChQ+zevZtZs2bx7LPPFtn36tWrqVWrlr+R/M4772TJkiUcPHiQwsJCFi9ezHvvvce5554b9FjnnXceV199NcOGDeOdd97h8OHDfP/999x66618/vnnPPbYY0XKP/nkk2zYsIGDBw9y33330aZNG7p164aIcNttt3H33Xezbt06wPmVtWDBAnJzc4/iXf1Ffn4+n332GZdeein16tXzN9z/+OOP1KxZk0aNGnH48GEefPDBIom0adOmFBQU8O233/qX/fjjj1SrVo0mTZpQWFjIlClTWLFiRVjiNPGhoKCA1q1b07ZtWwCGDx/OBx98ELTszJkz6dKlC2eccQbZ2dmsXl3+QBNXXXWV/1/fl3tOTg59+vShQ4cOPProo/7eku+88w6jR4/2b9ugQQPA+b/eu3dvJkyYwIUXXgg4HVYuv/xyjjnmGJo2beq/KvK58sorAViyZAnnn38+TZo0oVq1agwbNqzU8wt0ySWXcMwxx5CWlua/Ivrggw+46qqrSEpKIiUlpUhiiwRLHAEmTpzIJZdcQnp6uv+KoGnTpvTp04fu3bt7vuq4/vrrqV27tv9Rv359XnrpJRo0aMANN9xQZN+tWrVi1KhR/n0XFhZy3XXXcfzxx9OgQQNuueUW7r77bu66665Sj/fyyy8zduxYxo4dS3JyMmlpaeTk5PDZZ59xxhlnFCl7ww03MGTIEJo0acKKFSt46623SEpKAuCBBx5g8ODBDB48mOOOO45TTjmF5557jsLCwmCH9axdu3bUq1ePxo0bc8stt3DuueeybNkyGjduDDjJMjk5mZSUFE466SSOPfbYIlVqbdu25eabb6Zr164kJyczbdo0hg8fTrdu3Tj55JNp3rw5q1evLjW5msT27bff8thjj7Fo0SJWrlxJ//79PXU7Dexl5Ht+6623MmbMGFatWsXEiRPL3U+1atVIT09nwYIFnuOtU6dOSLEVj6FmzZr+5zG7wg61NT1eH+G+ATARAfrhhx/GOgwTp0r0uIHwHiCE/Y0bN04feughbdmypa5bt05VnZ5CTz31lKqqtm/f3n8z2/Lly7Vjx45aUFCg33//vR5//PH64osvqmrZvar++te/qqrqtGnTdMCAAaqq2rlzZ126dKmqqo4YMUJ79Oihqqr33nuv3nbbbf7tfT0N69Spo/n5+XrppZfqI488oqqqM2fO1P79+/vjadCggb+HU2BvrtzcXD3xxBN1x44dmp+fr71799Y333xTVVVPOukkXb16tRYUFOiQIUN0+PDh/vcgsLeUr1fX7Nmz9aKLLtL8/HzNzc3V5OTkiPaqitdh1Y0xVVytWrV48cUXufzyy8nPz+fMM89k1KhRAGRmZtK3b19/W8cZZ5zBqaeeSsuWLTn77LM97X/Pnj107NiRmjVrMn36dADGjx/P5ZdfToMGDejVq5e/evQPf/gDo0ePpn379iQlJTFu3DiGDBkCQFJSEtOnT2fQoEHUq1ePUaNGsWjRItLS0mjZsiVdunShfv36JY7frFkzHnnkEXr27Imq0r9/fwYPHgzAI488woABA2jSpAkZGRns31/2XHaXXnop7777LmlpaZx44ol0797d25tcQTZWVRUiInz44Yecc845sQ7FxKE1a9Zw2mmn/bIgNbVCPaFK1aoVBHTOSGT79++nbt267Nq1i65du/Lxxx+XehNvNJX4G1OxsarsiqMKSZQfCSZKqsiXfCQMGDCAvLw8Dh8+zB//+Me4SBrhZI3jxaxfv57u3bszZsyYsO3zzTff9HfFrajp06f7bxiaMGGCjfNkTBxbvHixv9ek7x6MRGKJo5hp06bx5JNP8swzz5RZLpSeRmvWrOH0008/qrimTJni7/10zz33+G+eM8aYaLPEEeDdd9/lmWee4b777mPFihXcfvvtnHXWWfTt25effvqJrKws+vTpw6WXXsrcuXP9223dupXBgwdz7rnnMn78eAC+/PJLzjnnHPr06cPHH3/M6aefzj333OO/MemWW25h48aNHDhwgGuvvZaePXty2WWXAU731HPPPZfOnTuTm5vLM888w5dffsn555/P119/Tb9+/QDnvpNf/epXdOvWzX8jVI8ePbjttttIS0vj1VdfjeK7Z4ypMkLthhWvj3B1x+3Tp4+qqk6dOtXfve7vf/+7Tp8+XV966SW94YYbSmxzxRVX6DfffKOqqgMHDtRDhw5pnz59dOfOnbpv3z5t3bq1qqoOGDBADx48qKqqffv21cLCQr3zzjt13rx5qqp6+PBhVVXdv3+/qqpOmTJFX3vtNd2wYYOOHj1aVZ15QW688Ubdu3evnn/++XrgwAHNy8vTvn376qFDh7RVq1a6Z88e3bhxo1577bVheU9M1RDrQQ5N5Fl33Ag4dOgQtWrVApwxa6ZMmQI4Q17Url2brKwsMjMzi2xz+PBh3n//fW688UYAdu3axXfffUfbtm3949+feuqpgDPER82aNVFVCgsLERGys7N5/PHHAWfY8a1bt3LXXXfxww8/kJOTw+TJk1m5ciUdO3YE4KuvvqJ9+/Z88MEHDBkyhNq1a1NQUECtWrX45ptv6N+/P8nJyaxbt47WrVtH5X0zxlQtEa2qEpG+IrJWRNaLSIkBj0TkPBHJEpF8EbksyPrjRCRHRMpucAiTwK5qBQUFHDlyhEOHDjF79mx69OjB2rVr/V/gPvv376d79+4sXryYxYsXk5WVRV5enr8he9KkSbRr147Dhw/72yjef/99/4i2eXl5/t5O+fn5PPTQQ4wdO5aFCxfStGlTOnTowJo1a2jXrh3wS+LIz8/n8OHD/mP079+f7OxsOnfuDMCKFSuOul3FGGOCiVjiEJEk4FmgH5AGXCUiacWKfQeMAEqbgechoPzBW8Jk1apVdOjQAYDbbruNfv36cf7553PHHXeQnJzMoUOHitzuD9CwYUPatGnD2WefzQUXXMD8+fPp3Lkza9asoVevXsyaNYu0tDRq1KhBjRo1uP3225k2bRrt27cH4Ne//jVdu3blvPPOY8uWLZx11lnccsst3HbbbRw5coSGDRvSsWNHbr31VqZOnepPHH369GHhwoWcffbZrFu3juuuu47s7Gx/Ylu1apX/GMYYE1ah1m15fQDdgQUBr+8H7i+l7FTgsmLL0oHXcRLLM+Udz4YcMeboxEsbx3PPPaejRo0qsuz000+vUHwjRozwTwblmyCqQYMG5a4L1f79+3X06NH66aefBn3ttUykVYaJnJoDWwJe57jLyiUixwCPA3dHIC5jjEeZmUXnYsrNhblziy7z3aIUuGzgQGfZwIFFl3uxatUqunTp4n998OBBNm3a5B8lNxQvvviifyTq//znP1SrVo2pU6eWuy5Uzz33HAcPHuSjjz4K+tprmcoiXrvj3gL8V1VzyiokIpkislREltoEPsaEV3q6kxQ0YC6mlBQnGQQu8/UXCVzm660+d27R5V6sXLmySOJYtWoVbdu29bcRlrbNxo0bS12/c+dO+vbtyx//+EcGDRrkeZ3X4/zvf/+jXbt2/jbG4q+9lqksIpk4tgItA163cJd50R0YIyKbgMeAa0XkkeKFVHWSqmaoakaTJk2ONl5jTICsrPDuz+vgCdnZ2QwZMoTU1FRSU1Pp169fiU4pxR08eJBLLrkk6Jf6gQMHGDhwIFdccQU33XST53Vej3Pw4EEKCgrIysqiR48eJV57LVOZRLI77hLgFBFpjZMwhgJXe9lQVYf5novICCBDVcM7DZ0xJqpuuumXq5PSbNmyhSZNmvD111/7l40ZM6ZI1/JXXnmFRx4p8TuSbdu2MXToUL744gv/soKCAoYOHcqpp57KQw89VKR8WetCOc66desoKCjg1FNPpXr16nz99ddFXnstU6mE2igSygO4GPgG2AD83l32IDDIfX4mTtvHT8AuIDvIPkZgjePGRFzxhtNmzcK7fy/TccyfP1+HDBlSZFnPnj317bffLnO7zZs3a6dOnfSjjz4qsjwzM1P79u2rR77MxrQAAB3uSURBVI4cKbFNWetCOc6iRYu0adOmumfPnqCvvZaJhkpxA6Cq/hf4b7Flfwp4vgSnCqusfUzF6XVljImiMM0YHJKVK1eSlla01352dra/m3xp1q5dyz//+U/OOuss/7IHHniAZcuWsXjxYqpVK/pVV9a6UI+Tm5vLr3/9awoLC9mzZ0+J1w0aNPBUpjKJ18ZxY0yMucOuhc2cOeWXWbVqVZHEsXv3blS13GHJL7zwwiJf5ps2bWL8+PHs2rWLc845h86dO9O5c2euvPLKMteVp/hx8vPzycrK4vvvv2fUqFEkJSWVeO2lTGVjEzkZY4CSk/wU7z7r+++VETDlz7hxToJJSYFt25xlXbrAsmVOe8bzz/9SdutWp5yJHZvIyRgTUaX9pgy2PFi11qRJ3ntSmcrFqqqMMcaExBKHMcaYkFjiMMb4JUqbpykpnH9bSxzGGABq1arFrl27LHkkIFVl165d/vmGjpY1jhtjAGjRogU5OTnYuG+JqVatWrRoUeZtc55Z4jDGAM4MlDZrpPHCqqqMMcaExBKHMcaYkFjiMMYYExJLHMYYY0JiicMYY0xILHEYY4wJiSUOY4wxIbHEYYwxJiSWOIypwlJTnXk3li1zHiK/PHwTOaWk/LIsPd1ZlplZtGxuLsydW3SZb0h1Eec40Tqfisboewwc6CwbOLDocnDKR/N84lVEJ3ISkb7A34EkYLKqPlJs/XnAU0BHYKiqznKXdwb+BRwHFAB/UdUZZR3LJnIyJnQipc+7YceJ/XGioSITOUXsikNEkoBngX5AGnCViKQVK/YdMAJ4rdjyA8C1qno60Bd4SkSSIxWrMVXVuHHROc6AAdE5TrNm0TmOl2lwE1kkx6rqCqxX1Y0AIvI6MBhY7SugqpvcdYWBG6rqNwHPc0VkO9AEyItgvMZUOeGeV7w0c+dG5zjBZiKMBF91WFUVyTaO5sCWgNc57rKQiEhXoAawIUxxGWNc0ZoD3NduEGnRSoTNQ/4mSyxx3TguIs2AacB1qloYZH2miCwVkaU2FLQxodu2LTrHmTcvOsd54IHoHKeqi2Ti2Aq0DHjdwl3miYgcB8wHfq+qnwUro6qTVDVDVTOaNGlyVMEaYyKnVauSPZN8j7lznSqmwGWZmU7Z9PRflvmujsaPL1o2sEdYq1YxOb0qJ2K9qkSkGvAN0BsnYSwBrlbV7CBlpwLzAnpV1QD+D5irqk95OZ71qjImdOnpzpeuCU1m5i9deSu7uOpVpar5wBhgAbAGmKmq2SLyoIgMAhCRM0UkB7gcmCgivqRyBXAeMEJElruPzpGK1ZiqypJGxUyaFPrVUEXuj4lXEb2PI5rsisOY0CXSL+dEk5sbnc4LcXXFYYyJf88/H+sITGni+WrQEocxxsShQYNiHUHpLHEYY4wJiSUOY6qwrZ47yBvzC0scxlRh8VyPXtVNnBjrCEpnicOYKiye69GrOt9NkPHIEocxxsSheL6PwxKHMcaYkFjiMKYKi+d6dBO/LHEYU4XFcz16VRetya8qwhKHMVVYPNejV3XRmvyqIixxGGNMHIrW5FcVYYnDGGPiULQmv6oISxzGVGHxXI9u4le5iUNEzhaROu7za0TkCRGxebaMibCKzuGQm+vUjwcu8w2dHrhs4MD4rkc38avc+ThEZCXQCegITAUmA1eoao+IRxcCm4/DJJply35JDsZESqTm48hXJ7sMBp5R1WeBehUJ0BhjjDfxPMGWl8SxT0TuB64B5ovIMUD1yIZljMkI6TegSTQ33RTrCErnJXFcCRwCRqrq90AL4FEvOxeRviKyVkTWi8h9QdafJyJZIpIvIpcVWzdcRNa5j+FejmeMMYmiVSunLWruXKfdKrB9ynfjZjjmPa8IL20cf1PVe8tbFmS7JOAb4EIgB1gCXKWqqwPKpALHAXcDc1R1lru8IbAUyAAUWAakq+qe0o5nbRwm0YhAOf89jTlqkWrjuDDIsn4etusKrFfVjap6GHgdp53ET1U3qepKoLDYtn2Ahaq6200WC4G+Ho5pTMIYNy7WERgTXLXSVojIzcAtQBu3Z5VPPeATD/tuDmwJeJ0DdPMYV7Btm3vc1piE4KtOMCbelJo4gNeA/wP+CgS2T+xT1d0RjcojEckEMgFOPPHEGEdjYi41FTZvjvxxWrWCTZsifpiUFKdu25h4U1ZVlarqJmA0sC/g4WuDKM9WoGXA6xbuMi88bauqk1Q1Q1UzmjRp4nHXJmFt3uw0CkT6EY3kBGzbFpXDGBOy8q44BuA0TCsQOI6mAm3K2fcS4BQRaY3zpT8UuNpjXAuAh0Wkgfv6IuB+j9saY4yJoFKvOFR1gPtva1Vt4/7re5SXNFDVfGAMThJYA8xU1WwReVBEBgGIyJkikgNcDkwUkWx3293AQzjJZwnwYLxUjxmTyrflDuUBzr+By8EpH7isrK6WXbpE/9yM8aLc7rgAItIcaEXAFYqqfhDBuEJm3XFNtPqvzpWBDFQb5Mkkhop0xy2rqsq307/h3AS4GihwFysQV4nDmGhJZ1msQzAmpspNHMAlQDtVPRTpYIypDJqTi92XZ6oyL4ljI87YVJY4jPFJlDlXo9S12CQWL4njALBcRBYRkDxUdWzEojIm3iXKWCCJkgBNVHlJHHPchzEGuPHGWEcQRr6R9KJxHLuySRjlJg5VfSkagRhTWcTzPAkhi9aXuV3ZJBQvvaq+hZJtgV7u5TAmEaWnO8NUG1NVeamqCuzfWwvnZj0vQ44Y44jmGFJRkJUVlcMYE7e8VFXtKrboKRFZBvwpMiGZhOMbQ8oYkxC8VFUFDnxwDM4ViJcrFWMSUrNmsY7AmNjykgAeD3ieD3wLXBGZcIyJfzbUuanqvFRV9YxGIMZUFuPH2yRLpmrzMnWsMSbAAw/EOgJjYssShzHGmJBY4qjqUlOLTgYRiUeUuskaY6LDS6+qZcAU4DVV3RP5kExUWVfZkNm0L6aq83LFcSWQAiwRkddFpI+IjR9gjDFVVbmJQ1XXq+rvgbY485BPATaLyAMiYneQmyonI6S50oxJPJ7aOESkI879HI8Cs3GGHfkReDdyoRljjIlH5SYOt43jSWAJ0FFVx6rq56r6OM4kT2Vt21dE1orIehG5L8j6miIyw13/uYikusuri8hLIrJKRNaIyP0VOTljjDHhV2biEJFjgNmq2ltVXys+fayqDilj2yTgWaAfkAZcJSJpxYqNBPao6sk4yelv7vLLgZqq2gFIB27yJRVjYm3cuFhHYExslZk4VLUQKDU5lKMrsF5VN6rqYeB1YHCxMoMB33wfs4DebsO7AnVEpBpQGziMUzVmTMzZXeOmqvPSxvGOiNwtIi1FpKHv4WG75sCWgNc57rKgZVQ1H9gLNMJJIj8B24DvgMdUdXfxA4hIpogsFZGlO3bs8BCSMUcvJSXWERgTW14GObzS/Xd0wDIFIjmRU1egAKcbcAPgQxF5R1WLtKmo6iRgEkBGRobdjGCiYtu2WEdgShXNuV+q8FS4XgY5bF3BfW8FWga8buEuC1Ymx62Wqg/sAq4G/qeqR4DtIvIxznDuZTbGG2OquGjd0FrFb2Xz2h23vYhcISLX+h4eNlsCnCIirUWkBjAUmFOszBxguPv8MuBdVVWc6qle7rHrAL8CvvYSq6m6AkdP8c0LHjjyycCBzrKBA4suB6d84LK5c53h0wOXZWY6Zbt0KXFoU9W0ahX5oXpSU2N9lqUSLSc7i8g44HycnlH/xekl9ZGqXlbuzkUuBp4CkoApqvoXEXkQWKqqc0SkFjANOAPYDQxV1Y0iUhd40T2mAC+q6qNlHSsjI0OX2lgQoRNJmCFH5s79JTmYOGNVSKGL0nsmsExVQ7qt1UviWAV0Ar5U1U4icgLwiqpeWPFQw88SRwUlUOLIzbWGa2NCJSIhJw4vVVU/u91y80XkOGA7RdsujIkLzYv32TPGRISXXlVLRSQZeB5YBuwHPo1oVMYYY+JWmYnDvRnvr6qaBzwnIv8DjlPVlVGJzhhjTNwpM3GoqorIf4EO7utN0QjKmIq48cZYR2BM1eCljSNLRM6MeCTGHCVfF1xjTGR5SRzdgE9FZIOIrHRHrLWqKhN30tNjHYExVYOXxvE+EY/CmDDIyop1BMZUDV6uOP6sqpsDH8CfIx2YMcaY+OQlcZwe+MKdZ8MqBUzcadYs1hEYUzWUmjhE5H4R2Qd0FJEf3cc+nBsA34pahMZ4lJsb6wiMqRpKTRyq+ldVrQc8qqrHuY96qtpIVW0qVxN3bIIlY6Kj1LGqRORUVf1aRIKOBaqqcdUUaWNVVVACjVWVQKdiTNRUZKyqsnpV3QlkAo8HWae4w56bCInmaKLGGBOCUhOHqma6//aMXjjGL1oT0hhjTIjKvY/DnTPjFuAcnCuND4HnVPVghGMzJiRWU2lMdHi5AfBlYB/wD/f11TiTL10eqaCMMcbELy+Jo72qpgW8fk9EVkcqIGMqKiPDaveMiQavgxz+yvdCRLoBVilgjDFVVFk3APoGM0wHPhGRTSLyLc4kTp66bolIXxFZKyLrReS+IOtrisgMd/3nIpIasK6jiHwqItluLLVCPTljjDHhV1ZV1YCj2bE7NMmzwIVADrBEROaoamA110hgj6qeLCJDgb8BV4pINeAV4DequkJEGgFHjiYek/jGjYt1BMZUDWV1x93sfvlnq+qpFdh3V2C9qm4EEJHXgcFAYOIYDIx3n88CnnFnHbwIWKmqK9xYdlXg+KaKsTvHjYmOMts4VLUAWCsiJ1Zg382BLQGvc9xlQcuoaj6wF2gEtAVURBaISJaI3BPsACKSKSJLRWTpjh07KhCiSSQpKbGOwJiqwUuvqgZAtoh8AfzkW6iqgyIWlRPXOcCZwAFgkXtb/KLAQqo6CZgEzpAjEYzHVALbtsU6AmOqBi+J448V3PdWoGXA6xbusmBlctx2jfrALpyrkw9UdSeAO+95F2ARxhhjYqrc7riq+n7gAygArvCw7yXAKSLSWkRqAEOBOcXKzAGGu88vA95VZ9TFBUAHETnWTSg9KNo2YkwJXYIOx2mMCTcv93EgImeIyKMisgl4CFhT3jZum8UYnCSwBpipqtki8qCI+Kq5XgAaich6nEEV73O33QM8gZN8lgNZqjo/pDMzcWPuXGfkWt9j0iRneeCygQOdZQMHFl0OTvnAZXPnOnNvBC7LzIRly2JzfsZUNWUNq94WuMp97ARmAHeralwOp5pww6on0BjhubnWcG1MvAr3sOpf4wxoOEBV17sHuOMo4jNVVPPmCZMDjTGUXVU1BNiGMzbV8yLSG5DohGWMMSZelTV17JuqOhQ4FXgPuB04XkT+JSIXRStAY4wx8cVLr6qfVPU1VR2I06X2S+DeiEdmEsaNN8Y6AmNMOHnqVeWjqntUdZKq9o5UQCbx+HpRGWMSQ0iJw5iKSE+PdQTGmHCyxGEiLisr1hEYY8LJEocxxpiQWOIwEdesWawjMMaEkyUOE3G5ubGOwBgTTpY4TMTZBEvGJBZLHCbiHngg1hEYY8LJEocxxpiQWOIwxhgTEkscoUpNLToRRKQereJy9PoKSaTR7o0x3qaONYE2b7Yxwo0xVZpdcZiIywhpihhjTLyzxGGMMSYkEU0cItJXRNaKyHoRuS/I+poiMsNd/7mIpBZbf6KI7BeRuyMZpzHGGO8iljhEJAl4FugHpAFXiUhasWIjgT2qejLwJPC3YuufAP4vUjGa6Bg3LtYRGGPCKZJXHF2B9aq6UVUPA68Dg4uVGQy85D6fBfQWEQEQkUuAb4HsCMZoosDuHDcmsUQycTQHtgS8znGXBS2jqvnAXqCRiNTFmWWwzHuORSRTRJaKyNIdO3aELXATXikpsY7AGBNO8do4Ph54UlX3l1XInY0wQ1UzmjRpEp3ITMi2bYt1BMaYcIrkfRxbgZYBr1u4y4KVyRGRakB9YBfQDbhMRCYAyUChiBxU1WciGK8xxhgPIpk4lgCniEhrnAQxFLi6WJk5wHDgU+Ay4F1VVeBcXwERGQ/st6RReXXpEusIjDHhFLHEoar5IjIGWAAkAVNUNVtEHgSWquoc4AVgmoisB3bjJBeTYJYti3UExphwEk2Q4TMyMjJ0aTQGRRKxIUdClJkJkybFOgpjTDAiskxVQxrfIV4bx00Cef75WEdgjAknSxzGGGNCYonDGGNMSCxxmIjbWrwTtjGmUrPEYSLOelUZk1gscZiIGzQo1hEYY8LJEkcVl57u/JuZWXTm2txcmDu36DJfl9rAZQMHOssGDiy6HJzyCTYLrjEGu48jdAl2H0eCnY4xJkR2H4cxxpiIs8RRxTVrFusIjDGVjSWOKi43N9YRGGMqG0scVZzNzmeMCZUljirugTLnWDTGmJIsccSp1NSS3Vp9j7lznSqmwGWZmU7Z9PRflvmmbB0/vmjZZcuch3WVNcZUhHXHDVWU+q9aN1ljTDRYd9wEMmBArCMwxpjgLHHEqblzYx2BMcYEZ4kjTvmG8jDGmHgT0cQhIn1FZK2IrBeR+4KsrykiM9z1n4tIqrv8QhFZJiKr3H97RTLOeDRvXqwjMMaY4CKWOEQkCXgW6AekAVeJSFqxYiOBPap6MvAk8Dd3+U5goKp2AIYD0yIVpzHGmNBE8oqjK7BeVTeq6mHgdWBwsTKDgZfc57OA3iIiqvqlqvruac4GaotIzQjGaowxxqNIJo7mwJaA1znusqBlVDUf2As0Klbm10CWqh4qfgARyRSRpSKydMeOHWELPB5YV1xjTLyK68ZxETkdp/rqpmDrVXWSqmaoakaT778vepdbpB5RumPON/eFMcbEm0gmjq1Ay4DXLdxlQcuISDWgPrDLfd0C+A9wrapuKPdohw87P9Mj/di06ajfGC9uCpoqjTEm9iKZOJYAp4hIaxGpAQwF5hQrMwen8RvgMuBdVVURSQbmA/ep6scRjNEYY0yIIpY43DaLMcACYA0wU1WzReRBEfHNQv0C0EhE1gN3Ar4uu2OAk4E/ichy93F8pGI1xhjjXeKMVSWiSxPkXMC5c9xuAjTGRJqNVZVA0tNjHYExxgRniSNONS/ecdkYY+KEJY4QpaZWfO4L38M3615Kyi/LfFcYmZk2T4YxJr5ZG0eIbJ4MY0wisTYOY4wxEWeJI0Rbi9/CaIwxVYwljhAtWxbrCIwxJrYscYRo0KDyyxhjTCKzxGGMMSYkljiMMcaExBJHiCZOjHUExhgTW5Y4QuS7+c8YY6oqSxwhEol1BMYYE1uWOIwxxoTEEocxxpiQWOII0YABsY7AGGNiyxJHiObOjXUExhgTWwmTOA5wbIWGL/c9cnOdpBC4bNIkp2zgMpuVzxhT1UV0WHUR6Qv8HUgCJqvqI8XW1wReBtKBXcCVqrrJXXc/MBIoAMaq6oKyj5WhqkvDfg7GGJPI4mpYdRFJAp4F+gFpwFUiklas2Ehgj6qeDDwJ/M3dNg0YCpwO9AX+6e7PGGNMjEWyqqorsF5VN6rqYeB1YHCxMoOBl9zns4DeIiLu8tdV9ZCqfgusd/dnjDEmxqpFcN/NgS0Br3OAbqWVUdV8EdkLNHKXf1Zs2xKzcItIJuC7l3u/iKwNT+hlagzsjMJxoiWRzieRzgUS63wS6Vwgsc6nXagbRDJxRJyqTgImRfOYIrI01PrAeJZI55NI5wKJdT6JdC6QWOcjIiE3Dkeyqmor0DLgdQt3WdAyIlINqI/TSO5lW2OMMTEQycSxBDhFRFqLSA2cxu45xcrMAYa7zy8D3lWnm9ccYKiI1BSR1sApwBcRjNUYY4xHEauqctssxgALcLrjTlHVbBF5EFiqqnOAF4BpIrIe2I2TXHDLzQRWA/nAaFUtiFSsIYpq1VgUJNL5JNK5QGKdTyKdCyTW+YR8LhG9j8MYY0ziSZg7x40xxkSHJQ5jjDEhscQRAhG5Q0SyReQrEZkuIrViHVMoRGSKiGwXka8CljUUkYUiss79t0EsY/SqlHN5VES+FpGVIvIfEUmOZYyhCHY+AevuEhEVkcaxiC1UpZ2LiNzq/n2yRWRCrOILVSmftc4i8pmILBeRpSJSKW5QFpGWIvKeiKx2/w63uctD+h6wxOGRiDQHxgIZqtoep8F/aGyjCtlUnCFcAt0HLFLVU4BF7uvKYColz2Uh0F5VOwLfAPdHO6ijMJWS54OItAQuAr6LdkBHYSrFzkVEeuKMCNFJVU8HHotBXBU1lZJ/mwnAA6raGfiT+7oyyAfuUtU04FfAaHeIp5C+ByxxhKYaUNu95+RYIDfG8YREVT/A6b0WKHDYl5eAS6IaVAUFOxdVfVtV892Xn+Hc/1MplPK3AWcMt3uAStOLpZRzuRl4RFUPuWW2Rz2wCirlfBQ4zn1en0ryXaCq21Q1y32+D1iDMypHSN8Dljg8UtWtOL+SvgO2AXtV9e3YRhUWJ6jqNvf598AJsQwmjK4H/i/WQRwNERkMbFXVFbGOJQzaAueKyOci8r6InBnrgI7S7cCjIrIF53uhMl3dAiAiqcAZwOeE+D1gicMjt85vMNAaSAHqiMg1sY0qvNybLyvNL9vSiMjvcS7JX411LBUlIscCv8OpBkkE1YCGONUjvwVmugOaVlY3A3eoakvgDpx70ioNEakLzAZuV9UfA9d5+R6wxOHdBcC3qrpDVY8A/wbOinFM4fCDiDQDcP+tNFUIwYjICGAAMEwr901KJ+H8SFkhIptwqt2yRKRpTKOquBzg3+r4AijEGSiwshqO8x0A8AaVaPRuEamOkzReVVXfOYT0PWCJw7vvgF+JyLHuL6XeOPWDlV3gsC/DgbdiGMtRcScOuwcYpKoHYh3P0VDVVap6vKqmqmoqzhdvF1X9PsahVdSbQE8AEWkL1KByjy6bC/Rwn/cC1sUwFs/c764XgDWq+kTAqtC+B1TVHh4fwAPA18BXwDSgZqxjCjH+6TjtM0dwvohG4gxjvwjng/8O0DDWcR7FuazHGaZ/uft4LtZxHs35FFu/CWgc6ziP4m9TA3jF/b+TBfSKdZxHeT7nAMuAFThtBOmxjtPjuZyDUw21MuD/ycWhfg/YkCPGGGNCYlVVxhhjQmKJwxhjTEgscRhjjAmJJQ5jjDEhscRhjDEmJJY4jDHGhMQSh0k4ItJbRF6JwnFaiMiV7vNUEflZRJa7r0sbvrq2OxT34eLDpBffh7vsBBF5TUQ2isgyEflURC4tJ673RKRPsWW3i8i/yjq+MV5Z4jCJqBPOjU2R1hvoEvB6gzrDbEMpw1er6s9umdJGU/Xvw73L903gA1Vto6rpOEP5lzfq73RKDvk/FJju4fjGlMsSh0lEnXDGeGotIm+5E+18ISLtANxJuGa4yzaLSP+ydhasvIicAzwBXOZeIRT5v6SlD18dil7AYVV9LmC/m1X1HwGxXePGtVxEJopIEjAL6C8iNdwyqTgDc34Y4vGNCcoSh0lEviuOycCdqpoBjOeXyWk6ARtVtSswDBjnYX9FyqvqR8ASYLD7C76wtI2LDV8ditNxhucobb+nAVcCZ7sxFOAM7rgb+ALo5xYdCsxUGybChEm1WAdgTDi5I3/WB87H+eKd7Y7eXQ34UJzpfpvgjDsGsBoodZrMcsq3wxm7rKx4Sh2+OlQi8izOWEOHVfVMnKqydGCJe461+WVUU1911VvuvyOP5tjGBLLEYRLNaTjVQp2A36tqkXkSRCQDWKeqB91FXXAGqitN+2Dl3YblvfrLjIMllDJ8dSiygV/7XqjqaPe4S32HAF5S1WCTCL0FPCkiXYBjVXVZBY5vTFBWVWUSTSecRLAN6CMixwCISAe3sbkTcKKI1BKROjhXEk+Ws79g5VMpo4G5jOGrQ/EuUEtEbg5YdmzA80U4bSzHu8dsKCKtAFR1P/AeMAXn6sOYsLHEYRKNr31jCs7ne43beH2vW8ffCWcCns9x2ij+paofl7O/YOW/BhqLyFciEmxCr7OB3wC93Ibr5SJycSgn4sZ7CdBDRL4VkS9w5oO+112/GvgD8LaIrAQWAs0CdjHdjd8ShwkrG1bdVCki8j6Qqaprw1nebQCfp6rtPe53E5ChqjsDloW0j6MR7PjGeGVXHKaqOYnQZmvzWr4AqB94814wvhvwgOqU7InlaR9Ho5zjG+OJXXEYA4iIbwa04nqr6q5ox2NMPLPEYYwxJiRWVWWMMSYkljiMMcaExBKHMcaYkFjiMMYYExJLHMYYY0JiicMYY0xILHEYY4wJiSUOY4wxIfl/I19gD5OREX0AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_SoverB(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the [ATLAS Higgs discovery paper](https://www.sciencedirect.com/science/article/pii/S037026931200857X), there are a number of numerical cuts applied, not just on lep_pt_1 and lep_pt_2.\n", "\n", "Imagine having to separately optimise about 7 variables! Not to mention that applying a cut on one variable could change the distribution of another, which would mean you'd have to re-optimise... Nightmare.\n", "\n", "This is where a Machine Learning algorithm such as a Boosted Decision Tree (BDT) can come to the rescue. A BDT can optimise all variables at the same time.\n", "\n", "A BDT not only optimises cuts, but can find correlations in many dimensions that will give better signal/background classification than individual cuts ever could.\n", "\n", "That's the end of the introduction to why one might want to use a BDT. If you'd like to try using one, just keep reading below!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Boosted Decision Tree (BDT)\n", "\n", "Choose variables for use in the BDT" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'ZZ': lep_pt_1 lep_pt_2\n", " entry \n", " 0 61.677957 48.666441\n", " 1 41.498750 18.562252\n", " 2 78.250461 56.973090\n", " 3 26.851668 13.466778\n", " 4 98.566398 74.528453\n", " ... ... ...\n", " 16623 40.231020 14.359087\n", " 16624 71.017078 24.197906\n", " 16625 54.766832 27.539174\n", " 16626 50.042633 35.911793\n", " 16627 35.250531 26.751711\n", " \n", " [15740 rows x 2 columns],\n", " '$H \\\\rightarrow ZZ \\\\rightarrow \\\\ell\\\\ell\\\\ell\\\\ell$': lep_pt_1 lep_pt_2\n", " entry \n", " 0 41.248570 16.397670\n", " 1 40.307168 16.133789\n", " 2 27.313271 20.035949\n", " 3 27.845740 17.726541\n", " 4 53.367754 25.596689\n", " ... ... ...\n", " 4935 29.323988 28.241137\n", " 4936 58.395027 43.535012\n", " 4937 32.114463 26.019475\n", " 4938 55.594645 22.598514\n", " 4940 36.496094 18.893633\n", " \n", " [4841 rows x 2 columns]}" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data_for_BDT = {} # define empty dictionary to hold dataframes that will be used to train the BDT\n", "BDT_inputs = ['lep_pt_1','lep_pt_2'] # list of features for BDT\n", "for key in data: # loop over the different keys in the dictionary of dataframes\n", " data_for_BDT[key] = data[key][BDT_inputs].copy()\n", "data_for_BDT" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Organise data ready for the BDT" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# for sklearn data is usually organised \n", "# into one 2D array of shape (n_samples x n_features) \n", "# containing all the data and one array of categories \n", "# of length n_samples \n", "\n", "all_MC = [] # define empty list that will contain all features for the MC\n", "for key in data: # loop over the different keys in the dictionary of dataframes\n", " if key!='data': # only MC should pass this\n", " all_MC.append(data_for_BDT[key]) # append the MC dataframe to the list containing all MC features\n", "X = np.concatenate(all_MC) # concatenate the list of MC dataframes into a single 2D array of features, called X\n", "\n", "all_y = [] # define empty list that will contain labels whether an event in signal or background\n", "for key in data: # loop over the different keys in the dictionary of dataframes\n", " if key!=r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$' and key!='data': # only background MC should pass this\n", " all_y.append(np.zeros(data_for_BDT[key].shape[0])) # background events are labelled with 0\n", "all_y.append(np.ones(data_for_BDT[r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$'].shape[0])) # signal events are labelled with 1\n", "y = np.concatenate(all_y) # concatenate the list of lables into a single 1D array of labels, called y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Training and Testing split\n", "One of the first things to do is split your data into a training and testing set. This will split your data into train-test sets: 67%-33%. It will also shuffle entries so you will not get the first 67% of X for training and the last 33% for testing. This is particularly important in cases where you load all signal events first and then the background events.\n", "\n", "Here we split our data into two independent samples. The split is to create a training and testing set. The first will be used for training the classifier and the second to evaluate its performance.\n", "\n", "We don't want to test on events that we used to train on, this prevents overfitting to some subset of data so the network would be good for the test data but much worse at any *new* data it sees." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", "# make train and test sets\n", "X_train,X_test, y_train,y_test = train_test_split(X, y, \n", " test_size=0.33, \n", " random_state=492 )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Training Decision Trees\n", "We'll use SciKit Learn (sklearn) in this tutorial. Other possible tools include keras and pytorch. \n", "\n", "Here we set several hyper-parameters to non default values.\n", "\n", "After instantiating our AdaBoostClassifier, call the fit() method with the training sample as an argument. This will train the tree, now we are ready to evaluate the performance on the held out testing set." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Time taken to fit BDT: 0.2s\n", "AdaBoostClassifier(algorithm='SAMME',\n", " base_estimator=DecisionTreeClassifier(class_weight=None,\n", " criterion='gini',\n", " max_depth=2,\n", " max_features=None,\n", " max_leaf_nodes=None,\n", " min_impurity_decrease=0.0,\n", " min_impurity_split=None,\n", " min_samples_leaf=1,\n", " min_samples_split=2,\n", " min_weight_fraction_leaf=0.0,\n", " presort=False,\n", " random_state=None,\n", " splitter='best'),\n", " learning_rate=0.5, n_estimators=12, random_state=None)\n" ] } ], "source": [ "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.ensemble import AdaBoostClassifier\n", "\n", "dt = DecisionTreeClassifier(max_depth=2) # maximum depth of the tree\n", "bdt = AdaBoostClassifier(dt,\n", " algorithm='SAMME', # SAMME discrete boosting algorithm\n", " n_estimators=12, # max number of estimators at which boosting is terminated\n", " learning_rate=0.5) # shrinks the contribution of each classifier by learning_rate\n", "\n", "start = time.time() # time at start of BDT fit\n", "bdt.fit(X_train, y_train) # fit BDT to training set\n", "elapsed = time.time() - start # time after fitting BDT\n", "print(\"Time taken to fit BDT: \"+str(round(elapsed,1))+\"s\") # print total time taken to fit BDT\n", "print(bdt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The fit() method returns the trained classifier. When printed out all the hyper-parameters are listed." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Assessing a Classifier's Performance\n", "Next let's create a quick report on how well our classifier is doing. It is important to make sure you use samples not seen by the classifier to get an unbiased estimate of its performance." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " background 0.85 0.91 0.88 5194\n", " signal 0.63 0.48 0.55 1598\n", "\n", " accuracy 0.81 6792\n", " macro avg 0.74 0.70 0.71 6792\n", "weighted avg 0.80 0.81 0.80 6792\n", "\n", "Area under ROC curve for test data: 0.8495\n" ] } ], "source": [ "from sklearn.metrics import classification_report, roc_auc_score\n", "y_predicted = bdt.predict(X_test) # get predicted y for test set\n", "print (classification_report(y_test, y_predicted,\n", " target_names=[\"background\", \"signal\"]))\n", "print (\"Area under ROC curve for test data: %.4f\"%(roc_auc_score(y_test,\n", " bdt.decision_function(X_test))) )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To illustrate that point, here's the same performance metrics evaluated on the training set instead. The estimates of the performance are more optimistic than on an unseen set of events." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " background 0.85 0.92 0.88 10546\n", " signal 0.64 0.49 0.56 3243\n", "\n", " accuracy 0.82 13789\n", " macro avg 0.75 0.70 0.72 13789\n", "weighted avg 0.80 0.82 0.81 13789\n", "\n", "Area under ROC curve for training data: 0.8563\n" ] } ], "source": [ "y_predicted = bdt.predict(X_train) # get predicted y for train set\n", "print (classification_report(y_train, y_predicted,\n", " target_names=[\"background\", \"signal\"]))\n", "print (\"Area under ROC curve for training data: %.4f\"%(roc_auc_score(y_train,\n", " bdt.decision_function(X_train))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Receiver Operarting Characteristic (ROC) curve for BDT\n", "Another useful plot to judge the performance of a classifier is to look at the ROC curve directly." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# we first plot the Neural Network output\n", "signal_decisions = bdt.decision_function(X[y>0.5]).ravel() # get probabilities on signal\n", "background_decisions = bdt.decision_function(X[y<0.5]).ravel() # get decisions on background\n", "\n", "plt.hist(background_decisions, color='red', label='background', \n", " histtype='step', # lineplot that's unfilled\n", " density=True ) # normalize to form a probability density\n", "plt.hist(signal_decisions, color='blue', label='signal', \n", " histtype='step', # lineplot that's unfilled\n", " density=True, # normalize to form a probability density\n", " linestyle='--' ) # dashed line\n", "plt.xlabel('BDT output') # add x-axis label\n", "plt.ylabel('Arbitrary units') # add y-axis label\n", "plt.legend() # add legend\n", "\n", "\n", "# we then plot the ROC\n", "plt.figure() # make new figure \n", "\n", "from sklearn.metrics import roc_curve, auc\n", "\n", "decisions = bdt.decision_function(X_test).ravel() # get probabilities on test set\n", "\n", "# Compute ROC curve and area under the curve\n", "fpr, tpr, _ = roc_curve(y_test, # actual\n", " decisions ) # predicted\n", "\n", "# Compute area under the curve for training set\n", "roc_auc = auc(fpr, # false positive rate \n", " tpr) # true positive rate\n", "\n", "plt.plot(fpr, tpr, label='ROC (area = %0.2f)'%(roc_auc)) # plot test ROC curve\n", "plt.plot([0, 1], # x from 0 to 1\n", " [0, 1], # y from 0 to 1\n", " '--', # dashed line\n", " color='grey', label='Luck')\n", "\n", "plt.xlabel('False Positive Rate') # x-axis label\n", "plt.ylabel('True Positive Rate') # y-axis label\n", "plt.title('Receiver operating characteristic (ROC) curve') # title\n", "plt.legend() # add legend\n", "plt.grid() # add grid" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sliding the cut threshold in Neural Network output (upper plot) from right to left builds up the ROC curve (lower plot) from bottom to top." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### BDT Overtraining Check\n", "Comparing the BDT's output distribution for the training and testing set is a popular way in HEP to check for overtraining. The compare_train_test() method will plot the shape of the BDT's decision function for each class, as well as overlaying it with the decision function in the training set.\n", "\n", "There are techniques to prevent overtraining." ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def compare_train_test(clf, X_train, y_train, X_test, y_test):\n", " decisions = [] # list to hold decisions of classifier\n", " for X,y in ((X_train, y_train), (X_test, y_test)): # train and test\n", " d1 = clf.decision_function(X[y<0.5]).ravel() # background\n", " d2 = clf.decision_function(X[y>0.5]).ravel() # signal\n", " decisions += [d1, d2] # add to list of classifier decision\n", " \n", " highest_decision = max(np.max(d) for d in decisions) # get maximum score\n", " bin_edges = [] # list to hold bin edges\n", " bin_edge = -1.1 # start counter for bin_edges\n", " while bin_edge < highest_decision: # up to highest score\n", " bin_edge += 0.1 # increment\n", " bin_edges.append(bin_edge)\n", " \n", " plt.hist(decisions[0], # background in train set\n", " bins=bin_edges, # lower and upper range of the bins\n", " density=True, # area under the histogram will sum to 1\n", " histtype='stepfilled', # lineplot that's filled\n", " color='red', label='B (train)', # Background (train)\n", " alpha=0.5 ) # half transparency\n", " plt.hist(decisions[1], # background in train set\n", " bins=bin_edges, # lower and upper range of the bins\n", " density=True, # area under the histogram will sum to 1\n", " histtype='stepfilled', # lineplot that's filled\n", " color='blue', label='S (train)', # Signal (train)\n", " alpha=0.5 ) # half transparency\n", "\n", " hist_background, bin_edges = np.histogram(decisions[2], # background test\n", " bins=bin_edges, # number of bins in function definition\n", " density=True ) # area under the histogram will sum to 1\n", " \n", " scale = len(decisions[2]) / sum(hist_background) # between raw and normalised\n", " err_background = np.sqrt(hist_background * scale) / scale # error on test background\n", "\n", " width = 0.1 # histogram bin width\n", " center = (bin_edges[:-1] + bin_edges[1:]) / 2 # bin centres\n", " \n", " plt.errorbar(x=center, y=hist_background, yerr=err_background, fmt='o', # circles\n", " c='red', label='B (test)' ) # Background (test)\n", " \n", " hist_signal, bin_edges = np.histogram(decisions[3], # siganl test\n", " bins=bin_edges, # number of bins in function definition\n", " density=True ) # area under the histogram will sum to 1\n", " scale = len(decisions[3]) / sum(hist_signal) # between raw and normalised\n", " err_signal = np.sqrt(hist_signal * scale) / scale # error on test background\n", " \n", " plt.errorbar(x=center, y=hist_signal, yerr=err_signal, fmt='o', # circles\n", " c='blue', label='S (test)' ) # Signal (test)\n", " \n", " plt.xlabel(\"BDT output\") # write x-axis label\n", " plt.ylabel(\"Arbitrary units\") # write y-axis label\n", " plt.legend() # add legend\n", " \n", "compare_train_test(bdt, X_train, y_train, X_test, y_test) # call compare_train_test" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### BDT Optimisation\n", "\n", "Here we get the BDT's decision function for every event that was processed at the begininning (so could be data, signal, background...). The higher the decision function, the more the BDT thinks that event looks like signal." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([-0.95262722, 0.11473984, -1. , ..., -0.05901893,\n", " -0.56423857, 0.11473984])" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y_predicted = bdt.decision_function(X)\n", "y_predicted" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this cell we save the BDT output to our dataframes." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "entry\n", "0 -0.952627\n", "1 0.114740\n", "2 -1.000000\n", "3 -0.059019\n", "4 -1.000000\n", " ... \n", "16623 0.114740\n", "16624 -0.664655\n", "16625 -0.737997\n", "16626 -0.899583\n", "16627 -0.059019\n", "Name: BDT_output, Length: 15740, dtype: float64\n", "entry\n", "0 0.114740\n", "1 0.114740\n", "2 -0.059019\n", "3 -0.059019\n", "4 -0.737997\n", " ... \n", "4935 -0.059019\n", "4936 -0.952627\n", "4937 -0.059019\n", "4938 -0.564239\n", "4940 0.114740\n", "Name: BDT_output, Length: 4841, dtype: float64\n" ] } ], "source": [ "cumulative_events = 0 # start counter for total number of events for which output is saved\n", "for key in data: # loop over samples\n", " data[key]['BDT_output'] = y_predicted[cumulative_events:cumulative_events+len(data[key])]\n", " cumulative_events += len(data[key]) # increment counter for total number of events\n", " print(data[key]['BDT_output']) # print the dataframe column BDT_output" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we define parameters to plot the BDT output" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "BDT_output = { # dictionary containing plotting parameters for the mllll histogram\n", " # change plotting parameters\n", " 'bin_width':0.1, # width of each histogram bin\n", " 'num_bins':14, # number of histogram bins\n", " 'xrange_min':-1, # minimum on x-axis\n", " 'xlabel':'BDT output', # x-axis label\n", "}\n", "\n", "SoverB_hist_dict = {'BDT_output':BDT_output}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we call the function defined above to to illustrate the optimum cut value on BDT output, based on signal to background ratio." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_SoverB(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Putting everything into a BDT means we only have 1 variable to optimise. The signal and background distributions are separated much better when looking at BDT output, compared to individual variables. Cutting on BDT output also achieves much higher S/B values than on individual variables.\n", "\n", "BDTs can achieve better S/B ratios because they find correlations in many dimensions that will give better signal/background classification.\n", "\n", "Hopefully you've enjoyed this discussion on optimising for signal to background ratio, and in particular how a BDT can be used to facilitate this." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Going further\n", "\n", "If you want to go further, there are a number of things you could try: \n", "* Increase the fraction of events that are processed in '[Lumi, fraction, file path](#fraction)'.\n", "* Add in the other H->ZZ signal samples in '[Samples](#samples)'. You can copy them from [HZZAnalysis.ipynb](https://github.com/atlas-outreach-data-tools/notebooks-collection-opendata/blob/master/13-TeV-examples/uproot_python/HZZAnalysis.ipynb). Try adding them one at a time first, then see how things look with all added.\n", "* Add in the Z and ttbar backgrounds samples in '[Samples](#samples)'. You can copy them from [HZZAnalysis.ipynb](https://github.com/atlas-outreach-data-tools/notebooks-collection-opendata/blob/master/13-TeV-examples/uproot_python/HZZAnalysis.ipynb). Try adding them separately first, then see how things look with both added.\n", "* Add some more variables into the in '[Boosted Decision Tree (BDT)](#BDT)'. Add them in one at a time, rather than all at once, because adding a variable could decrease BDT performance, due to anti-correlation. For some ideas of variables, you can look at the paper for the [discovery of the Higgs boson by ATLAS](https://www.sciencedirect.com/science/article/pii/S037026931200857X) (mostly Section 4 and 4.1).\n", "* Add in real data in '[Samples](#samples)' and see whether the BDT output distributions in data and simulation match. You can copy data from [HZZAnalysis.ipynb](https://github.com/atlas-outreach-data-tools/notebooks-collection-opendata/blob/master/13-TeV-examples/uproot_python/HZZAnalysis.ipynb). \n", "* Modify some BDT hyper-parameters in '[Training Decision Trees](#training)'.\n", "\n", "With each change, keep an eye on the:\n", "* total area under the ROC curve, \n", "* separation between signal and background in the BDT output distribution\n", "* S/B scores that can be achieved\n", "\n", "Notice that we've trained and tested our BDT on simulated data. We would then *apply* it to real experimental data. Once you're happy with your BDT, you may want to put it back into a full analysis to run over all data." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "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": 2 }