NB5_CVII-logreg_SUSY.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Notebook 5: Introduction to  Logistic Regression, Pandas, and TensorFlow #\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Learning Goals##\n",
    "This notebook will serve as an introduction to the logistic regression as well as the new extremely powerful TensorFlow library for Machine Learning (ML) from Google. We will also learn how to use the versatile Pandas package for handling data. For those of you familiar with the `R` language, the Pandas objects are extremely similar to the dataframe objects in `R`.\n",
    "\n",
    "## Overview##\n",
    "Throughout, we will work with the [SUSY dataset](https://archive.ics.uci.edu/ml/machine-learning-databases/00279/SUSY.csv.gz). It is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets.html), which is a very comprehensive repository of useful datasets relevant to ML.\n",
    "\n",
    "Here is the description of the SUSY dataset we will be playing around with for this notebook:\n",
    ">The data has been produced using Monte Carlo simulations and contains events with two leptons (electrons or muons). In high energy physics experiments, such as the ATLAS and CMS detectors at the CERN LHC, one major hope is the discovery of new particles. To accomplish this task, physicists attempt to sift through data events and classify them as either a signal of some new physics process or particle, or instead a background event from understood Standard Model processes. Unfortunately we will never know for sure what underlying physical process happened (the only information to which we have access are the final state particles). However, we can attempt to define parts of phase space that will have a high percentage of signal events. Typically this is done by using a series of simple requirements on the kinematic quantities of the final state particles, for example having one or more leptons with large amounts of momentum that is transverse to the beam line ($p_{T}$). Here instead we will use logistic regression in order to attempt to find out the relative probability that an event is from a signal or a background event and rather than using the kinematic quantities of final state particles directly we will use the output of our logistic regression to define a part of phase space that is enriched in signal events. The dataset we are using has the value of 18 kinematic variables (\"features\") of the event. The first 8 features are direct measurements of final state particles, in this case the $p_{T}$, pseudo-rapidity ($\\eta$), and azimuthal angle ($\\phi$) of two leptons in the event and the amount of missing transverse momentum (MET) together with its azimuthal angle. The last ten features are functions of the first 8 features; these are high-level features derived by physicists to help discriminate between the two classes. You can think of them as physicists attempt to use non-linear functions to classify signal and background events and they have been developed with a lot of deep thinking on the part of physicist. There is however, an interest in using deep learning methods to obviate the need for physicists to manually develop such features. Benchmark results using Bayesian Decision Trees from a standard physics package and 5-layer neural networks and the dropout algorithm are presented in the original paper to compare the ability of deep-learning to bypass the need of using such high level features. We will also explore this topic in later notebooks. The dataset consists of 5 million events, the first 4,500,000 of which we will use for training the model and the last 500,000 examples will be used as a test set.\n",
    "\n",
    "This dataset comes from this interesting paper by the UCI group: <cite> P. Baldi, P. Sadowski, and D. Whiteson. \"Searching for Exotic Particles in High-energy Physics with Deep Learning.\" Nature Communications 5 (July 2, 2014)</cite>.\n",
    "\n",
    "## Categorical data/Classification Tasks ##\n",
    "\n",
    "So far, we have largely focused on supervised learning tasks such as linear regression, where the goal is to make predictions about continuous labels. Often, we are also interested in classification tasks -- where the goal is to assign samples to categories. The training data consists of a set of features and discrete labels. This type of data is called categorical data (the data comes in different categories). \n",
    "\n",
    "Initially, we will focus on a binary classification task. In the SUSY dataset, the goal is to decide whether a data point represents signal \"potential collision\"- labeled 1, or \"background\"(Standard Model processes which produce final states with similar constituents as SUSY processes) - labeled 0. This is done by looking at 18 features - the first 8 of which are \"low-level\" features that can be directly measured and the last 10 features are \"higher-order\" features constructed using physics intuition. In more detail:\n",
    ">The first column is the class label (1 for signal, 0 for background), followed by the 18 features (8 low-level features then 10 high-level features):: lepton 1 pT, lepton 1 eta, lepton 1 phi, lepton 2 pT, lepton 2 eta, lepton 2 phi, missing energy magnitude, missing energy phi, MET_rel, axial MET, M_R, M_TR_2, R, MT2, S_R, M_Delta_R, dPhi_r_b, cos(theta_r1)\n",
    "\n",
    "Our goal will be to use either the first 8 features or the full 18 features to predict whether an event is signal or background.\n",
    "\n",
    "## Logistic Regression##\n",
    "\n",
    "\n",
    "One of the best understood and canonical methods for performing such a task is Logistic Regression. We will see that a deep understanding of Logistic regression will introduce us to many of the ideas and techniques at the forefront of modern Machine Learning. In Logistic regression, each set of features $\\mathbf{x}_i$ is associated with a category $C_i\\in\\{1,0\\}$, with $i=1\\ldots n$. It is helpful to re-define $\\mathbf{x}$ to be an extended vector $\\mathbf{x}\\rightarrow (1,\\mathbf{x})$ (which just accounts for an intercept, see Sec. VI of the review). Then, the Likelihood function for Logistic regression is given by the sigmoid function\n",
    "\n",
    "$$\n",
    "P(c_i=1)=1-P(c_i=0)= {1 \\over 1+ e^{-\\mathbf{w}\\cdot \\mathbf{x}_i}},\n",
    "$$\n",
    "\n",
    "where $\\mathbf{w}$ are the weights that define the logistic regression. Notice that this is just the Fermi function with $\\beta E=-\\mathbf{w}\\cdot \\mathbf{x}$.\n",
    "\n",
    "\n",
    "As in Sec. VI of the review, we will maximize the Log-likelihood of the observed data. Let us define the function\n",
    "$$\n",
    "f(a)={1 \\over 1+ e^{-a}},\n",
    "$$\n",
    "Notice that the derivative with respect to $a$ is given by\n",
    "$$\n",
    "{df \\over da}= f(1-f).\n",
    "$$\n",
    "\n",
    "Define $f_i \\equiv f(\\mathbf{w}\\cdot \\mathbf{x}_i)$. Then, the Likelihood of the data $\\{ \\mathbf{x}_i, C_i \\}$ is given by\n",
    "$$\n",
    "P(Data|\\mathbf{x})= \\prod_{i=1}^n f_i^{C_i}(1-f_i)^{1-C_i}\n",
    "$$\n",
    "and the log-likelihood is given by\n",
    "$$\n",
    "\\log{P(Data|\\mathbf{w})}= \\sum_{i=1}^n C_i \\log f_i + (1-C_i)\\log(1-f_i)\n",
    "$$\n",
    "\n",
    "The negative of the log-likelihood gives us the cross-entropy error function\n",
    "$$\n",
    "\\mathrm{Cross\\,Entropy}=E(\\mathbf{w})= -\\sum_{i=1}^n C_i \\log f_i + (1-C_i)\\log(1-f_i).\n",
    "$$\n",
    "\n",
    "Using the formula above notice that\n",
    "$$\n",
    "\\nabla E(\\mathbf{w})=\\sum_{i=1}^n (f_i-C_i)\\mathbf{x}_i.\n",
    "$$\n",
    "In other words, the gradient points in the sum of training example directions weighted by the difference between the true label and the probability of predicting that label.\n",
    "\n",
    "\n",
    "\n",
    "## Finding the MLE Estimate ##\n",
    "\n",
    "Notice the Maximum-Likelihood Estimation (MLE) is the same as minimizing the cross-entropy. There is no closed form expression for this. One strategy is to start with an arbitrary $\\mathbf{w}$ and then update our estimate based on our error function. In particular, we would like to nudge $\\mathbf{w}$ in the direction where the error is decreasing the fastest. This is the idea behind gradient descent. Furthermore, we can show that the cross-entropy error function used in logistic regression has a unique minimum. Thus, we can perform this procedure with relative ease (However, as a word of caution, note there is a generic instability in the MLE procedure for linearly separable data).\n",
    "\n",
    "Theoretically, one nice method for doing this is the <i> Newton-Raphson </i> method. In this method, we iteratively calculate the gradient \n",
    "$$\n",
    "\\mathbf{w}^{new} \\leftarrow \\mathbf{w}^{old} - \\mathbf{H}^{-1} \\nabla E(\\mathbf{w}),\n",
    "$$\n",
    "where $\\mathbf{H}$ is the Hessian matrix which is the second derivative of the energy function. For OLS linear regression, one can show that this procedure yields the right answer.\n",
    "\n",
    "<b> Exercise: </b> Show that for OLS Linear regression the formula above produces right answer.\n",
    "\n",
    "\n",
    "\n",
    "More generally, there are a number of generalizations of this idea that have been proposed. We will refer to these kinds of methods as generalized gradient descent methods and discuss them extensively in what follows.\n",
    "\n",
    "\n",
    "## Importing the SUSY data set with Pandas\n",
    "\n",
    "<b> Exercise:</b> In what follows, use Pandas to import the first 4,500,000 examples and call that the training data and import the last 500,000 examples and call that the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the SUSY Data set\n",
    "import sys, os\n",
    "import pandas as pd\n",
    "\n",
    "import numpy as np\n",
    "import warnings\n",
    "#Commnet the next line on to turn off warnings\n",
    "#warnings.filterwarnings('ignore')\n",
    "\n",
    "\n",
    "seed=12\n",
    "np.random.seed(seed)\n",
    "import tensorflow as tf\n",
    "# suppress tflow compilation warnings\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n",
    "\n",
    "tf.set_random_seed(seed)\n",
    "\n",
    "# Download the SUSY.csv (about 2GB) from UCI ML archive and save it in the same directory as this jupyter notebook\n",
    "# See: https://archive.ics.uci.edu/ml/machine-learning-databases/00279/\n",
    "#filename=\"SUSY.csv\"\n",
    "filename=os.path.expanduser('~')+'/ML_review/SUSY_data/SUSY.csv' \n",
    "\n",
    "columns=[\"signal\", \"lepton 1 pT\", \"lepton 1 eta\", \"lepton 1 phi\", \"lepton 2 pT\", \"lepton 2 eta\", \n",
    "         \"lepton 2 phi\", \"missing energy magnitude\", \"missing energy phi\", \"MET_rel\", \n",
    "         \"axial MET\", \"M_R\", \"M_TR_2\", \"R\", \"MT2\", \"S_R\", \"M_Delta_R\", \"dPhi_r_b\", \"cos(theta_r1)\"]\n",
    "\n",
    "# Load 1,500,000 rows as train data, 50,000 as test data\n",
    "df_train=pd.read_csv(filename,names=columns,nrows=1500000,engine='python')\n",
    "df_test=pd.read_csv(filename,names=columns,nrows=50000, skiprows=1500000,engine='python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run logistic regression using Linear Model functions in TensorFlow##\n",
    "\n",
    "We now will run logistic regression using MLE. \n",
    "\n",
    "<b>Exercise:</b> Using the tensor flow tutorial [here](https://www.tensorflow.org/versions/r0.9/tutorials/wide/index.html#setup), we will run logistic regression on the SUSY data for both the simple features (first 8 features) and the full feature space. First we will start with only the low-level features. We will also investigate the use of Ridge Regression by testing the results as as function of the regularization parameter $\\alpha$. \n",
    "\n",
    "Let us define some functions to do the actual training for us and will let them take the number of features as an input parameter.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import sys\n",
    "#import ml_style as style #optional styling sheet\n",
    "#mpl.rcParams.update(style.style) #optional styling sheet\n",
    "\n",
    "def getTrainData(nVar):\n",
    "    designMatrix = df_train.iloc[:,1:nVar+1].values\n",
    "    #now the signal\n",
    "    labels = df_train['signal'].values # labels (0 or 1)\n",
    "    return (designMatrix,labels)\n",
    "\n",
    "def getTestData(nVar):\n",
    "    designMatrix = df_test.iloc[:,1:nVar+1].values\n",
    "    #now the signal\n",
    "    labels = df_test['signal'].values\n",
    "    return (designMatrix,labels)\n",
    "\n",
    "# define\n",
    "def build_roc_curve(probs, signal_bit, threshes):\n",
    "    # Convert things to a pandas series to build a DataFrame\n",
    "    # which will make ROC curve logic easier to express\n",
    "    signal_probs = pd.Series(probs[:,1])\n",
    "    signal_true = pd.Series(signal_bit)\n",
    "    signal_df = pd.DataFrame(signal_probs, columns=['sig_prob'])\n",
    "    signal_df.loc[:,'sig_true'] = signal_true\n",
    "    Acceptance = []\n",
    "    Rejection = []\n",
    "    for thresh in threshes:\n",
    "        # define acceptance\n",
    "        signal_df.loc[:,'accept'] = signal_df['sig_prob'] > thresh\n",
    "        # sum over data frame with slicing conditions\n",
    "        nSigCor = len(signal_df[(signal_df['accept']) & (signal_df['sig_true']==1.)])\n",
    "        nSig = len(signal_df[signal_df['sig_true']==1.])\n",
    "        nBkgCor = len(signal_df[ (signal_df['sig_true']==0.) & (~signal_df['accept'])])\n",
    "        nBkg = len(signal_df[signal_df['sig_true']==0.])\n",
    "        Acceptance.append(nSigCor/nSig) # False positive rate\n",
    "        Rejection.append(nBkgCor/nBkg) # True positive rate\n",
    "\n",
    "    return Acceptance, Rejection\n",
    "    \n",
    "# let's define this as a function so we can call it easily\n",
    "def runTensorFlowRegression(nVar,alpha):\n",
    "\n",
    "    #make data array placeholder for just first 8 simple features\n",
    "    x = tf.placeholder(tf.float32,[None,nVar])\n",
    "    #make weights and bias\n",
    "    W = tf.Variable(tf.zeros([nVar,2])) #we will make y 'onehot' 0 bit is bkg, 1 bit is signal\n",
    "    b = tf.Variable(tf.zeros([2]))\n",
    "\n",
    "    #make 'answer variable'\n",
    "    y = tf.nn.softmax(tf.matmul(x, W) + b)\n",
    "    #placeholder for correct answer\n",
    "    y_ = tf.placeholder(tf.float32, [None, 2])\n",
    "    #cross entropy with L2 regularizer\n",
    "    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=y,labels=y_)+alpha*tf.nn.l2_loss(W))\n",
    "    \n",
    "    #define training step\n",
    "    train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)\n",
    "    #initialize variables \n",
    "    init = tf.global_variables_initializer()\n",
    "    #setup session\n",
    "    sess = tf.Session()\n",
    "    sess.run(init)\n",
    "\n",
    "    #ok now everything is setup for tensorflow, but we need the data in a useful form\n",
    "    #first let's get the variables\n",
    "    Var_train, Sig_train_bit1 = getTrainData(nVar)\n",
    "    #now the signal\n",
    "    Sig_train_bit0 = Sig_train_bit1.copy()\n",
    "    Sig_train_bit0 = 1 - Sig_train_bit0\n",
    "    Sig_train = np.column_stack((Sig_train_bit0,Sig_train_bit1))\n",
    "    \n",
    "    ######## ------- TRAINING ----------############\n",
    "    #Now perform minibatch gradient descent with minibatches of size 100:\n",
    "    n_data = len(Sig_train_bit1)\n",
    "    minibatch_size = 1000\n",
    "    n_minibatch = n_data//minibatch_size\n",
    "    print('\\t Training with %i minibatches, dataset size is %i'%(n_minibatch,n_data))\n",
    "    for i in range(0, n_minibatch):\n",
    "        sys.stdout.write(\"%.3f %% completed \\r\"%(100*i/n_minibatch))\n",
    "        sys.stdout.flush()\n",
    "        start = i*minibatch_size\n",
    "        end = (i+1)*minibatch_size-1\n",
    "        \n",
    "        batch_x = Var_train[start:end]\n",
    "        batch_y = Sig_train[start:end]\n",
    "        sess.run(train_step, feed_dict={x: batch_x, y_: batch_y})\n",
    "    \n",
    "    \n",
    "    # Accuracy function:\n",
    "    correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "    \n",
    "    ######## ------- TESTING ----------############\n",
    "    # Setup test data\n",
    "    Var_test = df_test.iloc[:,1:nVar+1].values\n",
    "    \n",
    "    # Now the signal\n",
    "    Sig_test_bit1 = df_test['signal'].values\n",
    "    \n",
    "    Sig_test_bit0 = Sig_test_bit1.copy()\n",
    "    Sig_test_bit0 = 1 - Sig_test_bit0\n",
    "    Sig_test = np.column_stack((Sig_test_bit0,Sig_test_bit1))\n",
    "    print(\"\\t Accuracy for alpha %.1E : %.3f\" %(alpha,sess.run(accuracy, feed_dict={x: Var_test, y_: Sig_test})))\n",
    "    \n",
    "    # Get the weights\n",
    "    weights = W.eval(session=sess)\n",
    "    # Get probabilities assigned (i.e. evaluate y on test data)\n",
    "    probs = y.eval(feed_dict = {x: Var_test}, session = sess)\n",
    "    # now let's get the signal efficiency and background rejection on the test data\n",
    "    print('\\t Computing ROC curve ...')\n",
    "    # build ROC curve by scanning over thresholds of probability of being\n",
    "    # a background event and calculating signal efficiency/background rejection\n",
    "    # at each threshold\n",
    "    threshes = np.arange(0,1,0.01)\n",
    "    Acceptance, Rejection = build_roc_curve(probs, Sig_test_bit1, threshes)\n",
    "\n",
    "    return (probs,Acceptance,Rejection)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training and evaluating model\n",
    "Now let's run using the first 8 variables only (the low-level features). Note: this will take several minutes !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training for alpha = 1.00E-10\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.770\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 7.94E-10\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 7.9E-10 : 0.770\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 6.31E-09\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 6.3E-09 : 0.770\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 5.01E-08\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 5.0E-08 : 0.770\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 3.98E-07\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 4.0E-07 : 0.770\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 3.16E-06\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 3.2E-06 : 0.770\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 2.51E-05\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 2.5E-05 : 0.770\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 2.00E-04\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 2.0E-04 : 0.769\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 1.58E-03\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 1.6E-03 : 0.768\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 1.26E-02\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 1.3E-02 : 0.760\n",
      "\t Computing ROC curve ...\n",
      "Training for alpha = 1.00E-01\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 1.0E-01 : 0.736\n",
      "\t Computing ROC curve ...\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We sweep the L2 regularizer strength (alpha) over 10 decades\n",
    "alphas = np.logspace(-10,-1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    print(\"Training for alpha = %.2E\"%alpha)\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probsSimple,accep,rej = runTensorFlowRegression(8,alpha)\n",
    "    ax.scatter(accep,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "    \n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An accuracy of 77% is pretty good! More important to physics analysis is the ROC curve above which allows physicists to define a part of phase space that has more or less signal acceptance, but also less or more background rejection. It is up to the individual analysts in particular searches to decide on the best working point for them.\n",
    "\n",
    "As you can see, using just the kinematic variables of the final state objects there is no need for regularization and in fact as we turn off the relative weights of the variables we lose discrimination power.\n",
    "\n",
    "<b> Question:</b> Why do you think this is the case?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 1.0E-05 : 0.770\n",
      "\t Computing ROC curve ...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0xb202efef0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# now let's investigate how mixed the events are\n",
    "probsSimple,accep,rej = runTensorFlowRegression(8,.00001) # train the model for 8 variables and alpha=.00001\n",
    "Signal = df_test['signal'].values\n",
    "\n",
    "df_test_acc = pd.DataFrame({'PROB':probsSimple[:,1]})\n",
    "df_test_acc['SIG']=Signal\n",
    "df_test_acc_sig = df_test_acc.query('SIG==1')\n",
    "df_test_acc_bkg = df_test_acc.query('SIG==0')\n",
    "df_test_acc_sig.plot(kind='hist',y='PROB',color='blue',alpha=0.5,bins=np.linspace(0,1,10),label='Signal')\n",
    "df_test_acc_bkg.plot(kind='hist',y='PROB',color='red',label='Background')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that the classification is pretty certain about its prediction (the majority of events are at the extremes of the probability), but also that a fair amount of signal events look lot like background events. This is often just a fact of life in HEP analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now let's try to train the same model using the full set of 18 features:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.788\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 1.3E-09 : 0.788\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 1.6E-08 : 0.788\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 2.0E-07 : 0.788\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 2.5E-06 : 0.788\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 3.2E-05 : 0.788\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 4.0E-04 : 0.787\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 5.0E-03 : 0.778\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 6.3E-02 : 0.749\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 7.9E-01 : 0.723\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 1500 minibatches, dataset size is 1500000\n",
      "\t Accuracy for alpha 1.0E+01 : 0.543\n",
      "\t Computing ROC curve ...\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probsSimple,accep,rej = runTensorFlowRegression(18,alpha)\n",
    "    ax.scatter(accep,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "    \n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interestingly the accuracy barely improved! This suggests (as noted in the paper cited above) that machine learning is already doing a good job of capturing the information present in the complex variables using only the low-level variables as input. \n",
    "\n",
    "One thing that does change is that varying $\\alpha$ now has some visible differences in the performance. It looks like increasing $\\alpha$ simply degrades performance so the result is telling us we are most likely not undersampled."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's now try the same with scikit packages. First we will define our function to run the regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "\n",
    "def runSciKitRegressionL2(nVar, alpha):\n",
    "    X_train, y_train = getTrainData(nVar)\n",
    "    X_test, y_test = getTestData(nVar)\n",
    "    clf = SGDClassifier(loss=\"log\", penalty=\"l2\",alpha=alpha,max_iter=5,tol=None)\n",
    "    clf.fit(X_train,y_train.ravel())\n",
    "    predictions = clf.predict(X_test)\n",
    "    print('Accuracy on test data with alpha %.2E : %.3f' %(alpha,clf.score(X_test,y_test)) )\n",
    "    probs = clf.predict_proba(X_test)\n",
    "\n",
    "    #get signal acceptance and background rejection\n",
    "    thresholds = np.arange(0,1,.01)\n",
    "    Acceptance, Rejection = build_roc_curve(probs, y_test, thresholds)\n",
    "    return (probs, Acceptance, Rejection)\n",
    "\n",
    "\n",
    "def runSciKitRegressionL1(nVar,alpha):\n",
    "    X_train, y_train = getTrainData(nVar)\n",
    "    X_test, y_test = getTestData(nVar)\n",
    "    clf = SGDClassifier(loss=\"log\", penalty=\"l1\",alpha=alpha,max_iter=5,tol=None)\n",
    "    clf.fit(X_train,y_train.ravel())\n",
    "    predictions = clf.predict(X_test)\n",
    "    print('Accuracy on test data with alpha %.2E : %.3f' %(alpha,clf.score(X_test,y_test)) )\n",
    "    probs = clf.predict_proba(X_test)\n",
    "\n",
    "    #get signal acceptance and background rejection\n",
    "    thresholds = np.arange(0,1,.01)\n",
    "    Acceptance, Rejection = build_roc_curve(probs, y_test, thresholds)\n",
    "    return (probs,Acceptance,Rejection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 1.00E-10 : 0.571\n",
      "Accuracy on test data with alpha 1.26E-09 : 0.644\n",
      "Accuracy on test data with alpha 1.58E-08 : 0.655\n",
      "Accuracy on test data with alpha 2.00E-07 : 0.687\n",
      "Accuracy on test data with alpha 2.51E-06 : 0.768\n",
      "Accuracy on test data with alpha 3.16E-05 : 0.768\n",
      "Accuracy on test data with alpha 3.98E-04 : 0.769\n",
      "Accuracy on test data with alpha 5.01E-03 : 0.767\n",
      "Accuracy on test data with alpha 6.31E-02 : 0.749\n",
      "Accuracy on test data with alpha 7.94E-01 : 0.543\n",
      "Accuracy on test data with alpha 1.00E+01 : 0.543\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probs,accept,rej = runSciKitRegressionL1(8,alpha)\n",
    "    ax.scatter(accept,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "\n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "This regression shows significantly more dependence on $\\alpha$, in particular the total sample accuracy depends on $\\alpha$, which is also manifested as being able to see clearly the differences in the ROC curves. It also has a slightly lower overall accuracy.\n",
    "\n",
    "The group of points in the middle is indicative of the regression not being able to differentiate well between signal and background events while also having its classification categories well separated. What we mean is that the likelihood that the algorithm comes up with is very 'certain' about its classification, but not accurate. It is understandable that this would happen at large values of $\\alpha$ in L1 regularization because it is turning off most of the input variables and so the classification is basically drawing a line in the distribution of just a few (or even one) input features and saying signal events are on this side while background events are on that side.\n",
    "\n",
    "Let's check and see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 5.00E-01 : 0.543\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0xb225d06d8>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# now let's investigate how mixed the events are\n",
    "probsSimple,accep,rej = runSciKitRegressionL1(8,.5)\n",
    "Signal = df_test.iloc[:,0:1]\n",
    "\n",
    "df_test_acc = pd.DataFrame({'PROB':probsSimple[:,1]})\n",
    "df_test_acc['SIG']=Signal\n",
    "df_test_acc_sig = df_test_acc.query('SIG==1')\n",
    "df_test_acc_bkg = df_test_acc.query('SIG==0')\n",
    "df_test_acc_sig.plot(kind='hist',y='PROB',color='blue',alpha=0.5,bins=np.linspace(0,1,10),label='Signal')\n",
    "df_test_acc_bkg.plot(kind='hist',y='PROB',color='red',label='Background')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exactly as we thought, the events have been distributed into two bins. What is interesting is that we have disfigured the model to such an extreme point that the background test data looks more like signal than the signal test data (recall that the reference point is the signal <i> train</i> data).\n",
    "\n",
    "Now let's check running LASSO regression with the full set of features:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 1.00E-10 : 0.713\n",
      "Accuracy on test data with alpha 1.26E-09 : 0.765\n",
      "Accuracy on test data with alpha 1.58E-08 : 0.722\n",
      "Accuracy on test data with alpha 2.00E-07 : 0.616\n",
      "Accuracy on test data with alpha 2.51E-06 : 0.726\n",
      "Accuracy on test data with alpha 3.16E-05 : 0.787\n",
      "Accuracy on test data with alpha 3.98E-04 : 0.790\n",
      "Accuracy on test data with alpha 5.01E-03 : 0.783\n",
      "Accuracy on test data with alpha 6.31E-02 : 0.749\n",
      "Accuracy on test data with alpha 7.94E-01 : 0.543\n",
      "Accuracy on test data with alpha 1.00E+01 : 0.457\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probs,accept,rej = runSciKitRegressionL1(18,alpha)\n",
    "    ax.scatter(accept,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "\n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the full set of variables there is more reasonable behavior versus our regularization parameter. To try to understand this, we can think of the underlying data. In our case, every input variable is important and when using just the eight low level variables we are removing too much valuable information when our regularization parameter is strong. When moving to the full set of variables, we recover some of the underlying information that we were killing off because of the fact that they are simply functions of those underlying variables.\n",
    "\n",
    "Let's test L2 now with the first 8 variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 1.00E-10 : 0.713\n",
      "Accuracy on test data with alpha 1.26E-09 : 0.609\n",
      "Accuracy on test data with alpha 1.58E-08 : 0.681\n",
      "Accuracy on test data with alpha 2.00E-07 : 0.663\n",
      "Accuracy on test data with alpha 2.51E-06 : 0.767\n",
      "Accuracy on test data with alpha 3.16E-05 : 0.766\n",
      "Accuracy on test data with alpha 3.98E-04 : 0.769\n",
      "Accuracy on test data with alpha 5.01E-03 : 0.767\n",
      "Accuracy on test data with alpha 6.31E-02 : 0.755\n",
      "Accuracy on test data with alpha 7.94E-01 : 0.694\n",
      "Accuracy on test data with alpha 1.00E+01 : 0.543\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probs,accept,rej = runSciKitRegressionL2(8,alpha)\n",
    "    ax.scatter(accept,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "\n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try the full set of variables with L2 regularization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 1.00E-10 : 0.773\n",
      "Accuracy on test data with alpha 1.26E-09 : 0.623\n",
      "Accuracy on test data with alpha 1.58E-08 : 0.740\n",
      "Accuracy on test data with alpha 2.00E-07 : 0.685\n",
      "Accuracy on test data with alpha 2.51E-06 : 0.781\n",
      "Accuracy on test data with alpha 3.16E-05 : 0.787\n",
      "Accuracy on test data with alpha 3.98E-04 : 0.789\n",
      "Accuracy on test data with alpha 5.01E-03 : 0.785\n",
      "Accuracy on test data with alpha 6.31E-02 : 0.760\n",
      "Accuracy on test data with alpha 7.94E-01 : 0.719\n",
      "Accuracy on test data with alpha 1.00E+01 : 0.457\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probs,accept,rej = runSciKitRegressionL2(18,alpha)\n",
    "    ax.scatter(accept,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "\n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With L2 regularization we get all the way up to 79% accuracy and have a stable local maximum of it in $\\alpha$ space. This is completing the picture that L2 regularization is better suited to the task at hand, which makes sense considering all the input variables are in fact important."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> Exercises:</b>\n",
    "* Try running sci-kit learn after scaling the data - does it help the performance?\n",
    "* Try coming up with some 'rectangular' requirements (i.e. a set of optimized requirements on the input variables) and see how the ROC curve for those requirements compares to using Logistic Regression\n",
    "* Is there a way we could select a region training data that could potentially improve performance? Hint: Think about where the gains of ML are most valuable\n",
    "* Try adding a layer of neurons in the TensorFlow code to see if you can improve performance (see also discussion in Notebook 13: __Section IX: Pytorch DNN (SUSY)__)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}