ApplicationExample.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example we will learn how to use a pretrained machine learning classifier to distinguish events with e+ mu+/K+ mu-/K- p and e+ pi+ pi- p . If you haven't already I recommend you read http://themlbook.com/wiki/doku.php."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import uproot\n",
    "import awkward as ak\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import metrics\n",
    "from sklearn import preprocessing\n",
    "from joblib import load\n",
    "import numpy as np\n",
    "import math\n",
    "from matplotlib.colors import LogNorm\n",
    "# when importing from keras we need to use the tensorflow backend ie like the following:\n",
    "import tensorflow.keras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this cell we're going to load in our data and do some general pre-processing. The data can be represented by a table where each row corresponds to an event that we want to classify and each column corresponds to a variable which we will use to classify the events.\n",
    "\n",
    "First we're going to load the data into a pandas dataframe as it's a more convenient data format to handle. \n",
    "\n",
    "Next we're going to define some variables that we want to remove as we don't want to train our classifier on them. For example, the EBPid (Event Builder Particle Identification) variables already assigns a particle type to the different particles in your dataset. As we want to do our own particle identification, and ideally improve on the EBPid, we don't want to include this variable.\n",
    "\n",
    "Another reason to remove variables is if they aren't useful to our classifier. This is called feature selection, you can read more at:\n",
    "                https://machinelearningmastery.com/feature-selection-machine-learning-python/\n",
    "                \n",
    "One of the reasons we do this is because we have a large number of variables which makes our events harder to classify. To solve this issue we can do what is know as dimensionality reduction, you can read more at:\n",
    "                https://machinelearningmastery.com/dimensionality-reduction-for-machine-learning/\n",
    "                \n",
    "Next, as we loop over the variables in our dataset we apply masks to these variables, so that our dataset only contains sensible values. You might want to add more conditions on the data that you will train on, for example by removing entries where the energy depositions are 0 in all three calorimeters. This is generally referred to as cleaning up your dataset.\n",
    "\n",
    "We then convert our pandas dataframe to a numpy array, as this data format can be passed directly to our classifiers. We also make sure that we have as many kaon/muon (signal) and pion (background) events as classifiers tend to work less well on inbalanced datasets. If you want you can also throw away events, this will allow you to run through this file faster but it will probably also decrease the accuracy of your classifier.\n",
    "\n",
    "We then separate out the ep2muLabel (or p2kLabel) variable into an array called y, whilst we have all the other variables in an array called X. The reason for this is that in X we have the discriminating variables from which the classifier learns what to predict, and y we have the \"true\" answer that the classifier will compare to its predictions, allowing it to know when the predictions were correct or not. Similarly we place several validation variables in an array called val.\n",
    "\n",
    "Finally we standardise our data as classifiers work better on data where all variables are on the same scale. You can read more about other data transformation techniques here:\n",
    "                https://machinelearningmastery.com/prepare-data-machine-learning-python-scikit-learn/\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X: Column 0 ElectronP\n",
      "X: Column 1 ElectronTheta\n",
      "X: Column 2 ElectronPhi\n",
      "X: Column 3 ElectronSF\n",
      "X: Column 4 ElectronEPCal\n",
      "X: Column 5 ElectronEECin\n",
      "X: Column 6 ElectronEECout\n",
      "X: Column 7 ElectronLU\n",
      "X: Column 8 ElectronLV\n",
      "X: Column 9 ElectronLW\n",
      "X: Column 10 ElectronDU\n",
      "X: Column 11 ElectronDV\n",
      "X: Column 12 ElectronDW\n",
      "X: Column 13 ElectronM2U\n",
      "X: Column 14 ElectronM2V\n",
      "X: Column 15 ElectronM2W\n",
      "X: Column 16 ElectronVz\n",
      "X: Column 17 ElectronVt\n",
      "X: Column 18 ElectronToF\n",
      "X: Column 19 ElectronPath\n",
      "X: Column 20 ElectronHypTime\n",
      "X: Column 21 ElectronDeltaTime\n",
      "X: Column 22 ElectronDeltaTimeVer\n",
      "X: Column 23 ElectronDeltaE\n",
      "X: Column 24 ElectronHTCC\n",
      "X: Column 25 ElectronTrChi2\n",
      "X: Column 26 ElectronRegion\n",
      "X: Column 27 ElectronSector\n",
      "X: Column 28 Electronchi2pid\n",
      "X: Column 29 parmP\n",
      "X: Column 30 parmTheta\n",
      "X: Column 31 parmPhi\n",
      "X: Column 32 parmSF\n",
      "X: Column 33 parmEPCal\n",
      "X: Column 34 parmEECin\n",
      "X: Column 35 parmEECout\n",
      "X: Column 36 parmLU\n",
      "X: Column 37 parmLV\n",
      "X: Column 38 parmLW\n",
      "X: Column 39 parmDU\n",
      "X: Column 40 parmDV\n",
      "X: Column 41 parmDW\n",
      "X: Column 42 parmM2U\n",
      "X: Column 43 parmM2V\n",
      "X: Column 44 parmM2W\n",
      "X: Column 45 parmVz\n",
      "X: Column 46 parmVt\n",
      "X: Column 47 parmToF\n",
      "X: Column 48 parmPath\n",
      "X: Column 49 parmHypTime\n",
      "X: Column 50 parmDeltaTime\n",
      "X: Column 51 parmDeltaTimeVer\n",
      "X: Column 52 parmDeltaE\n",
      "X: Column 53 parmHTCC\n",
      "X: Column 54 parmTrChi2\n",
      "X: Column 55 parmEBPid\n",
      "X: Column 56 parmRegion\n",
      "X: Column 57 parmSector\n",
      "X: Column 58 parmchi2pid\n",
      "X: Column 59 pP\n",
      "X: Column 60 pTheta\n",
      "X: Column 61 pPhi\n",
      "X: Column 62 pSF\n",
      "X: Column 63 pEPCal\n",
      "X: Column 64 pEECin\n",
      "X: Column 65 pEECout\n",
      "X: Column 66 pLU\n",
      "X: Column 67 pLV\n",
      "X: Column 68 pLW\n",
      "X: Column 69 pDU\n",
      "X: Column 70 pDV\n",
      "X: Column 71 pDW\n",
      "X: Column 72 pM2U\n",
      "X: Column 73 pM2V\n",
      "X: Column 74 pM2W\n",
      "X: Column 75 pVz\n",
      "X: Column 76 pVt\n",
      "X: Column 77 pToF\n",
      "X: Column 78 pPath\n",
      "X: Column 79 pHypTime\n",
      "X: Column 80 pDeltaTime\n",
      "X: Column 81 pDeltaTimeVer\n",
      "X: Column 82 pDeltaE\n",
      "X: Column 83 pHTCC\n",
      "X: Column 84 pTrChi2\n",
      "X: Column 85 pRegion\n",
      "X: Column 86 pSector\n",
      "X: Column 87 pchi2pid\n",
      "X: Column 88 parpP\n",
      "X: Column 89 parpTheta\n",
      "X: Column 90 parpPhi\n",
      "X: Column 91 parpSF\n",
      "X: Column 92 parpEPCal\n",
      "X: Column 93 parpEECin\n",
      "X: Column 94 parpEECout\n",
      "X: Column 95 parpLU\n",
      "X: Column 96 parpLV\n",
      "X: Column 97 parpLW\n",
      "X: Column 98 parpDU\n",
      "X: Column 99 parpDV\n",
      "X: Column 100 parpDW\n",
      "X: Column 101 parpM2U\n",
      "X: Column 102 parpM2V\n",
      "X: Column 103 parpM2W\n",
      "X: Column 104 parpVz\n",
      "X: Column 105 parpVt\n",
      "X: Column 106 parpToF\n",
      "X: Column 107 parpPath\n",
      "X: Column 108 parpHypTime\n",
      "X: Column 109 parpDeltaTime\n",
      "X: Column 110 parpDeltaTimeVer\n",
      "X: Column 111 parpDeltaE\n",
      "X: Column 112 parpHTCC\n",
      "X: Column 113 parpTrChi2\n",
      "X: Column 114 parpEBPid\n",
      "X: Column 115 parpRegion\n",
      "X: Column 116 parpSector\n",
      "X: Column 117 parpchi2pid\n",
      "X: Column 118 p2kEgamma\n",
      "X: Column 119 p2kStartTime\n",
      "X: Column 120 p2kMissMass2\n",
      "X: Column 121 p2kMissMass\n",
      "X: Column 122 p2kInvariantMass\n",
      "X: Column 123 p2kLabel\n",
      "(78956, 118)\n",
      "(78956, 1)\n",
      "(78956, 5)\n"
     ]
    }
   ],
   "source": [
    "#Load file, get tree and get branches in the tree\n",
    "file = uproot.open('KaonID.root') #change for kaon dataset\n",
    "tree = file['particle']\n",
    "branches = tree.arrays()\n",
    "branchNames=tree.keys()\n",
    "\n",
    "#Convert the awkward arry to a pandas dataframe\n",
    "X_pd=ak.to_pandas(branches)\n",
    "#print(X_pd.shape)\n",
    "\n",
    "#Choose the variables that we want to remove\n",
    "variable_mask =['ElectronEBPid',\n",
    "                'pEBPid',\n",
    "                'p2kQ2',\n",
    "                'p2kW',\n",
    "                'p2kMissE',\n",
    "                'p2kMissP']\n",
    "\n",
    "#Loop over all variables in the file\n",
    "count=0\n",
    "for i in range(0,len(branchNames)):\n",
    "    #Apply masks to make sure we only have sensible values for all variables\n",
    "    sensH_mask = X_pd[branchNames[i]] <1e9\n",
    "    sensL_mask = X_pd[branchNames[i]] >-1e9\n",
    "    nan_mask = X_pd[branchNames[i]] !=float(\"nan\")\n",
    "    X_pd=X_pd[sensH_mask & sensL_mask & nan_mask]\n",
    "    \n",
    "    #Remove variables from the dataset\n",
    "    if branchNames[i] in variable_mask:\n",
    "        X_pd=X_pd.drop([branchNames[i]], axis=1)\n",
    "    else:\n",
    "        print('X: Column '+str(count)+' '+branchNames[i])\n",
    "        count=count+1\n",
    "        \n",
    "    \n",
    "#print(X_pd.shape)\n",
    "\n",
    "#Masks to select signal or background events\n",
    "muon_mask = X_pd['p2kLabel'] == 1 #change for muon dataset\n",
    "pion_mask = X_pd['p2kLabel'] == 0 #change for muon dataset\n",
    "\n",
    "#Separate signal and background events\n",
    "X_sig_pd = X_pd[muon_mask]\n",
    "X_bg_pd = X_pd[pion_mask]\n",
    "\n",
    "#Create target array from ep2muLabel, this is 1 for signal 0 for background\n",
    "y_sig_pd=X_pd.iloc[:,-1:][muon_mask]\n",
    "y_bg_pd=X_pd.iloc[:,-1:][pion_mask]\n",
    "\n",
    "val_sig_pd=X_pd[['parpEBPid',\n",
    "                'parmEBPid',\n",
    "                'p2kMissMass2',\n",
    "                'p2kMissMass',\n",
    "                'p2kInvariantMass']][muon_mask]\n",
    "\n",
    "val_bg_pd=X_pd[['parpEBPid',\n",
    "                'parmEBPid',\n",
    "                'p2kMissMass2',\n",
    "                'p2kMissMass',\n",
    "                'p2kInvariantMass']][pion_mask]\n",
    "\n",
    "#Remove the label and validation variables from the dataset\n",
    "X_sig_pd=X_sig_pd.drop(['p2kLabel',\n",
    "                        'parpEBPid',\n",
    "                        'parmEBPid',\n",
    "                        'p2kMissMass2',\n",
    "                        'p2kMissMass',\n",
    "                        'p2kInvariantMass'], axis=1) #change for kaon dataset\n",
    "X_bg_pd=X_bg_pd.drop(['p2kLabel',\n",
    "                        'parpEBPid',\n",
    "                        'parmEBPid',\n",
    "                        'p2kMissMass2',\n",
    "                        'p2kMissMass',\n",
    "                        'p2kInvariantMass'], axis=1) #change for kaon dataset\n",
    "\n",
    "#Convert to numpy\n",
    "X_sig=X_sig_pd.to_numpy()\n",
    "X_bg=X_bg_pd.to_numpy()\n",
    "\n",
    "y_sig=y_sig_pd.to_numpy()\n",
    "y_bg=y_bg_pd.to_numpy()\n",
    "\n",
    "val_sig=val_sig_pd.to_numpy()\n",
    "val_bg=val_bg_pd.to_numpy()\n",
    "\n",
    "#print(X_sig.shape)\n",
    "#print(X_bg.shape)\n",
    "\n",
    "#Make sure we have as many signal and background events\n",
    "if(len(X_bg)>len(X_sig)):\n",
    "    X_bg=X_bg[0:len(X_sig),:]\n",
    "    y_bg=y_bg[0:len(X_sig),:]\n",
    "    val_bg=val_bg[0:len(val_sig),:]\n",
    "else:\n",
    "    X_sig=X_sig[0:len(X_bg),:]\n",
    "    y_sig=y_sig[0:len(X_bg),:]\n",
    "    val_sig=val_sig[0:len(val_bg),:]\n",
    "    \n",
    "#Note: if you want to only keep the N first events you can do this with\n",
    "#X_sig=X_sig[0:N,:]\n",
    "#y_sig=y_sig[0:N,:]\n",
    "#X_bg=X_bg[0:N,:]\n",
    "#y_bg=y_bg[0:N,:]\n",
    "    \n",
    "#print(X_sig.shape)\n",
    "#print(y_sig.shape)\n",
    "\n",
    "#print(X_bg.shape)\n",
    "#print(y_bg.shape)\n",
    "\n",
    "#print(val_sig.shape)\n",
    "#print(val_bg.shape)\n",
    "\n",
    "#Create arrays from both signal and background\n",
    "X= np.vstack((X_sig,X_bg))\n",
    "y= np.vstack((y_sig,y_bg))\n",
    "val=np.vstack((val_sig,val_bg))\n",
    "print(X.shape)\n",
    "print(y.shape)\n",
    "print(val.shape)\n",
    "\n",
    "#Standardise our data\n",
    "scaler = preprocessing.StandardScaler()\n",
    "X = scaler.fit_transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we want to load and evaluate our classifier ie we want to know how good it is. predict returns a 0 or 1 value for each event in the test array. This is the classifier's prediction if an event has kaons or pions (signal or background). predict_proba returns a probability that an event is of class 0 in column 0 and the probability that it is of class 1 in column 1. We call this the response. This is a more complete value than simply the prediction returned by predict. Note: these two functions might not work with keras classifiers.\n",
    "\n",
    "The accuracy is the ratio of how many events were correctly identified over all the events in our dataset. It's the most basic metric by which we can judge our classifier but it's not the most informative. You should read up on different metrics and think about which metrics are better suited here. One thing that comes up often in the discussion of metrics are the elements of the confusion matrix:\n",
    "\n",
    "True Positive (TP): in our case these are muon/kaon events (with ep2muLabel==1) for which our classifier predicts a label 1.\n",
    "\n",
    "True Negative (TN): in our case these are pion events (with ep2muLabel==0) for which our classifier predicts a label 0.\n",
    "\n",
    "False Positive (FP): in our case these are pion events (with ep2muLabel==0) for which our classifier predicts a label 1.\n",
    "\n",
    "False Negative (FN): in our case these are muon/kaon events (with ep2muLabel==1) for which our classifier predicts a label 0.\n",
    "\n",
    "Check out:\n",
    "                                https://en.wikipedia.org/wiki/Confusion_matrix\n",
    "and:   \n",
    "        https://medium.com/@MohammedS/performance-metrics-for-classification-problems-in-machine-learning-part-i-b085d432082b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy = 0.9325\n"
     ]
    }
   ],
   "source": [
    "model= load('mlp_kaon.joblib') \n",
    "\n",
    "y_pred = model.predict(X)\n",
    "\n",
    "y_proba = model.predict_proba(X)[:, 1]\n",
    "\n",
    "print(\"Accuracy =\",\"{:.4f}\".format(metrics.accuracy_score(y, y_pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also calculate the accuracy of the event builder PID. The relevant PID values are:\n",
    "\n",
    "mu+/mu-:-13/13\n",
    "\n",
    "K+/K-:321/-321\n",
    "\n",
    "pi+/pi-:211/-211\n",
    "\n",
    "Next we want to plot some of our validation variables based on the event builder and classifier predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Event builder TP: 22809 TN: 26953 FP: 7471 FN: 10208\n",
      "Event builder Accuracy: 0.7378597589003721 Purity: 0.7532694848084545 Efficiency: 0.6908259381530727\n",
      "Total Event Builder Accuracy: 0.6302497593596433\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y=y.reshape(len(y),)\n",
    "\n",
    "muon_mask2= y == 1\n",
    "pion_mask2= y == 0\n",
    "\n",
    "parpEBPID=val[:, 0]\n",
    "parmEBPID=val[:, 1]\n",
    "\n",
    "EBmuon_pos_mask= parpEBPID == 321\n",
    "EBmuon_neg_mask= parmEBPID == -321\n",
    "\n",
    "EBpion_pos_mask= parpEBPID == 211\n",
    "EBpion_neg_mask= parmEBPID == -211\n",
    "\n",
    "#print(y.shape)\n",
    "#print(parpEBPID.shape)\n",
    "#print(IM.shape)\n",
    "\n",
    "TP_EBPid=val[muon_mask2 & EBmuon_pos_mask & EBmuon_neg_mask].shape[0]\n",
    "TN_EBPid=val[pion_mask2 & EBpion_pos_mask & EBpion_neg_mask].shape[0]\n",
    "FN_EBPid=val[muon_mask2 & EBpion_pos_mask & EBpion_neg_mask].shape[0]+val[muon_mask2 & EBmuon_pos_mask & EBpion_neg_mask].shape[0]+val[muon_mask2 & EBpion_pos_mask & EBmuon_neg_mask].shape[0]\n",
    "FP_EBPid=val[pion_mask2 & EBmuon_pos_mask & EBmuon_neg_mask].shape[0]+val[pion_mask2 & EBpion_pos_mask & EBmuon_neg_mask].shape[0]+val[pion_mask2 & EBmuon_pos_mask & EBpion_neg_mask].shape[0]\n",
    "\n",
    "print(\"Event builder TP: \"+str(TP_EBPid)+\" TN: \"+str(TN_EBPid)+\" FP: \"+str(FP_EBPid)+\" FN: \"+str(FN_EBPid))\n",
    "\n",
    "EB_Accuracy=(TP_EBPid+TN_EBPid)/(TP_EBPid+TN_EBPid+FP_EBPid+FN_EBPid)\n",
    "EB_Purity=(TP_EBPid)/(TP_EBPid+FP_EBPid)\n",
    "EB_Efficiency=(TP_EBPid)/(TP_EBPid+FN_EBPid)\n",
    "\n",
    "EB_Accuracy2=(TP_EBPid+TN_EBPid)/val.shape[0]\n",
    "\n",
    "print(\"Event builder Accuracy: \"+str(EB_Accuracy)+\" Purity: \"+str(EB_Purity)+\" Efficiency: \"+str(EB_Efficiency))\n",
    "print(\"Total Event Builder Accuracy: \"+str(EB_Accuracy2))\n",
    "\n",
    "\n",
    "IM=val[:, -1]\n",
    "MM2=val[:, -3]\n",
    "\n",
    "fig = plt.figure(figsize=(10,10))\n",
    "plt.hist(IM[y==1], range=[1,3],bins=100, edgecolor='lime', label='True Signal',fill=False)\n",
    "plt.hist(IM[y==0], range=[1,3],bins=100, edgecolor='orange',label='True Background',fill=False)\n",
    "plt.hist(IM[y_proba>0.5], range=[1,3],bins=100, edgecolor='blue', label='Classifier Signal',fill=False)\n",
    "plt.hist(IM[y_proba<=0.5], range=[1,3],bins=100, edgecolor='red',label='Classifier Background',fill=False)\n",
    "plt.hist(IM[EBmuon_pos_mask & EBmuon_neg_mask], range=[1,3],bins=100, edgecolor='cyan', label='EBPid Signal',fill=False)\n",
    "plt.hist(IM[EBpion_pos_mask & EBpion_neg_mask], range=[1,3],bins=100, edgecolor='magenta',label='EBPid Background',fill=False)\n",
    "plt.legend(loc='upper right')#can change upper to lower and center to left or right\n",
    "plt.xlabel('Invariant Mass [GeV]')\n",
    "plt.title('Invariant Mass')\n",
    "plt.show()\n",
    "\n",
    "fig = plt.figure(figsize=(10,10))\n",
    "plt.hist(MM2[y==1], range=[-0.1,0.1],bins=100, edgecolor='green', label='True Signal',fill=False)\n",
    "plt.hist(MM2[y==0], range=[-0.1,0.1],bins=100, edgecolor='orange',label='True Background',fill=False)\n",
    "plt.hist(MM2[y_proba>0.5], range=[-0.1,0.1],bins=100, edgecolor='blue', label='Classifier Signal',fill=False)\n",
    "plt.hist(MM2[y_proba<=0.5], range=[-0.1,0.1],bins=100, edgecolor='red',label='Classifier Background',fill=False)\n",
    "plt.hist(MM2[EBmuon_pos_mask & EBmuon_neg_mask], range=[-0.1,0.1],bins=100, edgecolor='cyan', label='EBPid Signal',fill=False)\n",
    "plt.hist(MM2[EBpion_pos_mask & EBpion_neg_mask],range=[-0.1,0.1],bins=100, edgecolor='magenta',label='EBPid Background',fill=False)\n",
    "plt.legend(loc='upper right')#can change upper to lower and center to left or right\n",
    "plt.xlabel('Missing Mass Squared [GeV^2]')\n",
    "plt.title('Missing Mass Squared')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we plot the response to make sure that the predictions for pions and muons/kaons are well separated. You should try to think about what other plots would help us understand how to improve our classification.\n",
    "\n",
    "One final thing to note is that the accuracy value returned by y_pred is the accuracy we could calculate if we decided that any event with a response>=0.5 is classified as a signal event and any event with a response<0.5 is classified as a background event. Instead of using 0.5 you can set a threshold at any value between 0 and 1. You should plot how your metrics vary as you change this threshold value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10,10))\n",
    "plt.hist(y_proba[y==1], range=[0,1],bins=100, label='Signal')\n",
    "plt.hist(y_proba[y==0], range=[0,1],bins=100, edgecolor='red',label='Background',hatch='/',fill=False)\n",
    "plt.legend(loc='upper center')#can change upper to lower and center to left or right\n",
    "plt.xlabel('Response')\n",
    "plt.title('Response')\n",
    "plt.show()\n",
    "\n",
    "fig = plt.figure(figsize=(10,10))\n",
    "plt.hist(y_proba[y==1], range=[0,1],bins=100, label='Signal')\n",
    "plt.hist(y_proba[y==0], range=[0,1],bins=100, edgecolor='red',label='Background',hatch='/',fill=False)\n",
    "plt.legend(loc='upper center')#can change upper to lower and center to left or right\n",
    "plt.xlabel('Response')\n",
    "plt.title('Response (log(y) scale)')\n",
    "plt.yscale('log', nonpositive='clip')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Accuracy of: 0.9343178479152946 at threshold of 0.55\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#print(y_proba)\n",
    "#print(y_proba.shape)\n",
    "#print(y_proba[0])\n",
    "BestAcc=0\n",
    "BestTh=0\n",
    "thresh=[]\n",
    "acc=[]\n",
    "pur=[]\n",
    "sen=[]\n",
    "threshold=np.linspace(0.01,1,100)\n",
    "\n",
    "for i in threshold:\n",
    "    #print(i)\n",
    "    FP=0                                                 #Reset confusion matrix elements everytime I change the threshold\n",
    "    TP=0\n",
    "    TN=0\n",
    "    FN=0\n",
    "    for event in range (0,len(y_proba),1):\n",
    "        prob=y_proba[event]\n",
    "        #print(prob.shape)\n",
    "        if prob>i:               #If y_proba is above the threshold we classify that event as signal\n",
    "            if y[event]==1:    \n",
    "                 TP=TP+1                                    # Kaon event classified as signal\n",
    "            else:\n",
    "                  FP=FP+1                                   # Pion event classified as signal\n",
    "        else:\n",
    "            if y[event]==1:\n",
    "                 FN=FN+1                                    # Kaon event classified as background\n",
    "            else:\n",
    "                  TN=TN+1                                   # Pion event classified as background\n",
    "    if (TP+TN+FP+FN)!=0:\n",
    "        Accuracy=(TP+TN)/(TP+TN+FP+FN)               #Accuracy at threshold\n",
    "    else:\n",
    "        Acc=0.5\n",
    "    if (TP+FP)!=0:\n",
    "        Pur=(TP)/(TP+FP)\n",
    "    else:\n",
    "        Pur=0\n",
    "    if(TP+FN)!=0:\n",
    "        Sen=(TP)/(TP+FN)\n",
    "    else:\n",
    "        Sen=0\n",
    "    acc.append(Accuracy)\n",
    "    pur.append(Pur)\n",
    "    sen.append(Sen)\n",
    "    thresh.append(i)\n",
    "    if Accuracy>BestAcc:\n",
    "        BestAcc=Accuracy\n",
    "        BestTh=i\n",
    "    \n",
    "print(\"Best Accuracy of: \"+str(BestAcc)+\" at threshold of \"+str(BestTh))    \n",
    "\n",
    "fig = plt.figure(figsize=(15,15))\n",
    "plt.scatter(thresh,acc,marker='o',color='green', label='Accuracy')\n",
    "plt.scatter(thresh,pur,marker='o',color='red', label='Purity')\n",
    "plt.scatter(thresh,sen,marker='o',color='blue', label='Sensitivity')\n",
    "plt.legend(loc='upper center')#can change upper to lower and center to left or right\n",
    "plt.xlabel('Response')\n",
    "plt.ylabel('Metrics')\n",
    "plt.title('Metrics vs Response')\n",
    "plt.show()\n"
   ]
  },
  {
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}