4.1-dense-pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dense neural network with PyTorch\n",
    "Authors: Javier Duarte, Tyler Mitchell "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: torch in /eos/home-q/qnguyen/.local/lib/python2.7/site-packages (1.0.1)\n",
      "Requirement already satisfied: torchvision in /eos/home-q/qnguyen/.local/lib/python2.7/site-packages (0.2.1)\n",
      "Requirement already satisfied: root_pandas in /eos/home-q/qnguyen/.local/lib/python2.7/site-packages (0.6.1)\n",
      "Requirement already satisfied: pillow>=4.1.1 in /eos/home-q/qnguyen/.local/lib/python2.7/site-packages (from torchvision) (5.4.1)\n",
      "Requirement already satisfied: six in /cvmfs/sft.cern.ch/lcg/views/LCG_94/x86_64-centos7-gcc7-opt/lib/python2.7/site-packages (from torchvision) (1.11.0)\n",
      "Requirement already satisfied: numpy in /cvmfs/sft.cern.ch/lcg/views/LCG_94/x86_64-centos7-gcc7-opt/lib/python2.7/site-packages (from torchvision) (1.14.2)\n",
      "Requirement already satisfied: root-numpy in /cvmfs/sft.cern.ch/lcg/views/LCG_94/x86_64-centos7-gcc7-opt/lib/python2.7/site-packages (from root_pandas) (4.7.3)\n",
      "Requirement already satisfied: pandas>=0.18.0 in /cvmfs/sft.cern.ch/lcg/views/LCG_94/x86_64-centos7-gcc7-opt/lib/python2.7/site-packages (from root_pandas) (0.23.3)\n",
      "Requirement already satisfied: python-dateutil>=2.5.0 in /cvmfs/sft.cern.ch/lcg/views/LCG_94/x86_64-centos7-gcc7-opt/lib/python2.7/site-packages (from pandas>=0.18.0->root_pandas) (2.7.3)\n",
      "Requirement already satisfied: pytz>=2011k in /cvmfs/sft.cern.ch/lcg/views/LCG_94/x86_64-centos7-gcc7-opt/lib/python2.7/site-packages (from pandas>=0.18.0->root_pandas) (2018.5)\n",
      "\u001b[31mtensorflow 1.8.0 requires backports.weakref>=1.0rc1, which is not installed.\u001b[0m\n",
      "\u001b[31mpy2neo 4.0.0 requires colorama, which is not installed.\u001b[0m\n",
      "\u001b[31mpy2neo 4.0.0 requires neo4j-driver>=1.6.0, which is not installed.\u001b[0m\n",
      "\u001b[31mpylint 2.0.0 has requirement astroid>=2.0.0, but you'll have astroid 1.6.5 which is incompatible.\u001b[0m\n",
      "\u001b[31mtensorboard 1.8.0 has requirement bleach==1.5.0, but you'll have bleach 2.1.3 which is incompatible.\u001b[0m\n",
      "\u001b[31mtensorboard 1.8.0 has requirement html5lib==0.9999999, but you'll have html5lib 1.0.1 which is incompatible.\u001b[0m\n",
      "\u001b[33mYou are using pip version 10.0.1, however version 19.0.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install torch torchvision root_pandas --user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import root_pandas\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Copy TTree HZZ4LeptonsAnalysisReduced into a pandas DataFrame.\n",
    "filename = {\n",
    "    'VV': root_pandas.read_root('data/ntuple_4mu_VV.root', key='HZZ4LeptonsAnalysisReduced'),\n",
    "    'bkg': root_pandas.read_root('data/ntuple_4mu_bkg.root', key='HZZ4LeptonsAnalysisReduced')\n",
    "}\n",
    "\n",
    "# Drop all variables except for those we want to use when training.\n",
    "VARS = ['f_mass4l','f_massjj']\n",
    "df = {\n",
    "    'VV': filename['VV'][VARS],\n",
    "    'bkg': filename['bkg'][VARS],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make sure the inputs are well behaved.\n",
    "df['VV']= df['VV'][(df['VV'][VARS[0]] > -999) & (df['VV'][VARS[1]] > -999)]\n",
    "df['bkg']= df['bkg'][(df['bkg'][VARS[0]] > -999) & (df['bkg'][VARS[1]] > -999)] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add isSignal variable\n",
    "df['VV']['isSignal'] = np.ones(len(df['VV'])) \n",
    "df['bkg']['isSignal'] = np.zeros(len(df['bkg'])) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 123.59499359 1071.21447754]\n",
      " [ 124.97003174 1074.65454102]\n",
      " [ 124.32479095  643.70874023]\n",
      " ...\n",
      " [  87.93131256  538.8001709 ]\n",
      " [ 120.99951935  772.50964355]\n",
      " [  90.16904449  194.7850647 ]]\n",
      "[[ 125.07710266 1300.42687988]\n",
      " [ 124.2381134   437.22186279]\n",
      " [ 124.48066711 1021.74407959]\n",
      " ...\n",
      " [  89.28808594   53.66157913]\n",
      " [ 146.75657654   71.16202545]\n",
      " [ 218.86941528   98.91469574]]\n"
     ]
    }
   ],
   "source": [
    "# Combine signal and background into one DataFrame then split into input variables and labels.\n",
    "NDIM = len(VARS)\n",
    "df_all = pd.concat([df['VV'],df['bkg']])\n",
    "dataset = df_all.values\n",
    "X = dataset[:,0:NDIM]\n",
    "Y = dataset[:,NDIM]\n",
    "\n",
    "# Split into training and testing data.\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train_val, X_test, Y_train_val, Y_test = train_test_split(X, Y, test_size=0.2, random_state=7)\n",
    "print(X_train_val)\n",
    "print(X)\n",
    "\n",
    "# preprocessing: standard scalar (reshape inputs to mean=0, variance=1)\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler().fit(X_train_val)\n",
    "X_train_val = scaler.transform(X_train_val)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "# Split again, this time into training and validation data.\n",
    "X_train, X_val, Y_train, Y_val = train_test_split(X_train_val, Y_train_val, test_size=0.2, random_state=7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build our model. \n",
    "import torch\n",
    "model = torch.nn.Sequential(\n",
    "    torch.nn.Linear(2, 20),\n",
    "    torch.nn.Sigmoid(),\n",
    "    torch.nn.Linear(20, 20),\n",
    "    torch.nn.Sigmoid(),\n",
    "    torch.nn.Linear(20, 1),\n",
    "    torch.nn.Sigmoid()\n",
    ")\n",
    "\n",
    "# Use Binary Cross Entropy as our loss function.\n",
    "loss_fn = torch.nn.BCELoss()\n",
    "\n",
    "# Optimize the model parameters using the Adam optimizer.\n",
    "learning_rate = 0.001\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1024 13272\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "def getBatches(N, tot):\n",
    "    \"\"\"Function to find nearest acceptable batch size\"\"\"\n",
    "    print N, tot\n",
    "    if tot % N == 0:\n",
    "        return N\n",
    "    closest = 1\n",
    "    for i in xrange(1, N):\n",
    "        if tot % i == 0 and abs(N - i) < abs(N-closest):\n",
    "            closest = i\n",
    "    return closest\n",
    "    \n",
    "# Create batches from total data. We have to make sure the batch size is an appropriate divisor of the total \n",
    "# number of training events\n",
    "N = getBatches(1024, len(X_train))\n",
    "unbatched_x = torch.from_numpy(X_train).float()\n",
    "x = unbatched_x.view(-1, N, len(VARS))\n",
    "unbatched_y = torch.from_numpy(Y_train).float()\n",
    "y_b = unbatched_y.view(-1, N, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get validation data ready\n",
    "val_data = torch.from_numpy(X_val).float()\n",
    "val_label = torch.from_numpy(Y_val).float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "losses, val_losses = [], []\n",
    "min_loss, stale_epochs = 100., 0\n",
    "\n",
    "# 500 epochs. \n",
    "for t in xrange(500):\n",
    "    batch_loss, val_batch_loss = [], []\n",
    "    for b in xrange(len(x)):\n",
    "        \n",
    "        # Forward pass: make a prediction for each x event in batch b.\n",
    "        y_pred = model(x[b])\n",
    "\n",
    "        # Get the labels.\n",
    "        label = y_b[b]\n",
    "        y = label.view_as(y_pred)  # reshape label data to the shape of y_pred\n",
    "\n",
    "        # Compute and print loss.\n",
    "        loss = loss_fn(y_pred, y)\n",
    "        batch_loss.append(loss.item())\n",
    "\n",
    "        # Let's look at the validation set.\n",
    "        \n",
    "        # Torch keeps track of each operation performed on a Tensor, so that it can take the gradient later.\n",
    "        # We don't need to store this information when looking at validation data, so turn it off with\n",
    "        # torch.no_grad().\n",
    "        with torch.no_grad():\n",
    "            \n",
    "            # Forward pass on validation set.\n",
    "            output = model(val_data)\n",
    "\n",
    "            # Get labels and compute loss again\n",
    "            val_y = val_label.view_as(output)\n",
    "            val_loss = loss_fn(output, val_y)\n",
    "            val_batch_loss.append(val_loss.item())\n",
    "\n",
    "            # Monitor the loss function to prevent overtraining.\n",
    "            if stale_epochs > 20:\n",
    "                break\n",
    "\n",
    "            if val_loss.item() - min_loss < 0:\n",
    "                min_loss = val_loss.item()\n",
    "                stale_epochs = 0\n",
    "            else:\n",
    "                stale_epochs += 1\n",
    "\n",
    "        #print(t, b, loss.item(), val_loss.item())\n",
    "\n",
    "        # Before the backward pass, use the optimizer object to zero all of the\n",
    "        # gradients for the variables it will update (which are the learnable\n",
    "        # weights of the model). This is because by default, gradients are\n",
    "        # accumulated in buffers( i.e, not overwritten) whenever .backward()\n",
    "        # is called. Checkout docs of torch.autograd.backward for more details.\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # Backward pass: compute gradient of the loss with respect to model\n",
    "        # parameters\n",
    "        loss.backward()\n",
    "\n",
    "        # Calling the step function on an Optimizer makes an update to its\n",
    "        # parameters\n",
    "        optimizer.step()\n",
    "        \n",
    "    losses.append(min(batch_loss))\n",
    "    val_losses.append(min(val_batch_loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "with torch.no_grad():\n",
    "    # plot loss vs epoch\n",
    "    plt.figure(figsize=(16,8))\n",
    "    ax = plt.subplot(1, 2, 1)\n",
    "    ax.plot(losses, label='loss')\n",
    "    ax.plot(val_losses, label='val_loss')\n",
    "    ax.legend(loc=\"upper right\")\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "    # Plot ROC\n",
    "    X_test_in = torch.from_numpy(X_test).float()\n",
    "    Y_predict = model(X_test_in)\n",
    "    from sklearn.metrics import roc_curve, auc\n",
    "    fpr, tpr, thresholds = roc_curve(Y_test, Y_predict)\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    plt.figure(figsize=(16,8))\n",
    "    ax2 = plt.subplot(1, 2, 2)\n",
    "    ax2.plot(fpr, tpr, lw=2, color='cyan', label='auc = %.3f' % (roc_auc))\n",
    "    ax2.plot([0, 1], [0, 1], linestyle='--', lw=2, color='k', label='random chance')\n",
    "    ax2.set_xlim([0, 1.0])\n",
    "    ax2.set_ylim([0, 1.0])\n",
    "    ax2.set_xlabel('false positive rate')\n",
    "    ax2.set_ylabel('true positive rate')\n",
    "    ax2.set_title('receiver operating curve')\n",
    "    ax2.legend(loc=\"lower right\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(200, 200)\n"
     ]
    }
   ],
   "source": [
    "# Hint: We want to make a three 2D numpy arrays: \n",
    "# x values at each (x, y) grid point\n",
    "# y values at each (x, y) grid point\n",
    "# z values (model prediction) at each (x, y) grid point\n",
    "\n",
    "myXI, myYI = np.meshgrid(np.linspace(-2, 2, 200), np.linspace(-2, 2, 200))\n",
    "# print shape\n",
    "print(myXI.shape)\n",
    "\n",
    "myZI = np.zeros(myXI.shape)\n",
    "\n",
    "for i in range(0, len(myXI)):\n",
    "    for j in range(0, len(myYI)):\n",
    "        myXI[i,j] # x value of xi, yj point\n",
    "        myYI[i,j] # y value of xi, yj point\n",
    "        data_point = torch.tensor([myXI[i,j], myYI[i,j]])\n",
    "        myZI[i,j] = model(data_point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(myZI)\n",
    "myZI = model(torch.from_numpy(np.c_[myXI.ravel(), myYI.ravel()]).float())\n",
    "myZI = myZI.reshape(myXI.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "plt.figure(figsize=(20,7))\n",
    "\n",
    "# plot contour map of NN output\n",
    "# overlaid with test data points\n",
    "ax = plt.subplot(1, 2, 1)\n",
    "cm = plt.cm.RdBu\n",
    "cm_bright = ListedColormap(['#FF0000', '#0000FF'])\n",
    "\n",
    "cont_plot = ax.contourf(myXI, myYI, myZI>0.5, cmap=cm, alpha=.8)\n",
    "ax.scatter(X_test[:, 0], X_test[:, 1], c=Y_test, cmap=cm_bright, edgecolors='k')\n",
    "ax.set_xlim(-2,2)\n",
    "ax.set_ylim(-2,2)\n",
    "ax.set_xlabel(VARS[0])\n",
    "ax.set_ylabel(VARS[1])\n",
    "plt.colorbar(cont_plot,ax=ax, boundaries=[0,1],label='NN output')\n",
    "\n",
    "# plot decision boundary\n",
    "# overlaid with test data points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}