HiggsML_syst_evaluate.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import gridspec\n",
    "from matplotlib import colors\n",
    "import pandas as pd\n",
    "from pickle import load\n",
    "\n",
    "from sklearn.metrics import roc_auc_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadAndPlot = False\n",
    "#loadAndPlot = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seed_everything(seed=0):\n",
    "    #random.seed(seed)\n",
    "    #os.environ['PYTHONHASHSEED'] = str(seed)\n",
    "    np.random.seed(seed)\n",
    "    #torch.manual_seed(seed)\n",
    "    #torch.cuda.manual_seed(seed)\n",
    "    #torch.cuda.manual_seed_all(seed)\n",
    "    #torch.backends.cudnn.deterministic = True\n",
    "    #tf keras\n",
    "seed_everything(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Configure tunable params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#cmapp = plt.get_cmap(\"RdYlBu\")\n",
    "\n",
    "plotDir = \"plots/\"\n",
    "\n",
    "batch_size = 4*1024\n",
    "\n",
    "#nBins of NN Score histogram\n",
    "nBins = 30\n",
    "\n",
    "# mu values to scan\n",
    "mu_values = np.arange(0,50)/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "clfCol = \"b\"; aweCol = \"g\"; augCol = \"y\"; invCol = \"r\"; clfNomCol = \"k\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## z_syst list (reduced list to run faster)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "z_syst_plot =  np.sort(np.concatenate([np.array([0.8, 0.84]), np.arange(88,115)/100]))\n",
    "z_syst = z_syst_plot\n",
    "\n",
    "systUp = 1.1\n",
    "systDown = 0.8\n",
    "z_nominal = 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # Python 2\n",
    "    xrange\n",
    "except NameError:\n",
    "    # Python 3, xrange is now named range\n",
    "    xrange = range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train-test split done according to event number\n",
    "\n",
    "# load the scaler\n",
    "scaler = load(open('HiggsModels/scaler.pkl', 'rb'))\n",
    "\n",
    "def loadSystData(z_val):\n",
    "    from util import train_test_split_evtNo\n",
    "    from dataLoc import dataLoc\n",
    "    fileName = dataLoc +\"HiggsML_TES_{}.h5\".format(z_val)\n",
    "    print (\"Loading file: \",fileName)\n",
    "    \n",
    "    data = pd.read_hdf(fileName, \"data_syst\")\n",
    "    data = data.sample(frac=1).reset_index(drop=False) #shuffle the events\n",
    "    target = data[\"Label\"]\n",
    "    weights = data[\"Weight\"]\n",
    "    Z = data[\"Z\"]\n",
    "    evtNo = data[\"index\"]\n",
    "    del data[\"Label\"]\n",
    "    del data[\"Z\"]\n",
    "    del data[\"Weight\"]\n",
    "    del data[\"index\"]\n",
    "\n",
    "\n",
    "    data = data.values\n",
    "    target = target.values\n",
    "    weights = weights.values\n",
    "    Z = Z.values\n",
    "    evtNo = evtNo.values\n",
    "    \n",
    "    assert (Z == Z[0]).all() # files contain only 1 z\n",
    "    \n",
    "        \n",
    "    X_syst_train, X_syst_test, Y_syst_train, Y_syst_test, Z_syst_train, Z_syst_test, weights_train, weights_test  = train_test_split_evtNo(\n",
    "        data, target, Z, weights,evtNo=evtNo,n=3)\n",
    "\n",
    "    del X_syst_train, Y_syst_train, Z_syst_train, weights_train\n",
    "    \n",
    "    ## load the scaler\n",
    "    X_syst_test = scaler.transform(X_syst_test)\n",
    "    \n",
    "    class_weights = weights[target == 0].sum(), weights[target == 1].sum()\n",
    "\n",
    "    class_weights_test = weights_test[Y_syst_test == 0].sum(), weights_test[Y_syst_test == 1].sum(), weights_test[Y_syst_test == 2].sum()\n",
    "    scale_up = 1.\n",
    "    for i in xrange(2):\n",
    "        weights_test[Y_syst_test == i] *= class_weights[i]/class_weights_test[i]\n",
    "        \n",
    "    del data, target, weights, Z\n",
    "    \n",
    "    return X_syst_test, Y_syst_test, Z_syst_test, weights_test\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load classifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Baseline Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"-1\"\n",
    "#os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n",
    "#os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:523: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:524: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:532: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "if not loadAndPlot:\n",
    "    from tensorflow import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    nominal_model = keras.models.load_model(\"HiggsModels/clf.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data Augmented Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "aug_NN = True\n",
    "if not loadAndPlot:\n",
    "    augmented_model = keras.models.load_model(\"HiggsModels/aug.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Up/Down Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    down_model = keras.models.load_model(\"HiggsModels/down_model.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    up_model = keras.models.load_model(\"HiggsModels/up_model.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Syst Aware Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    aware_model = keras.models.load_model(\"HiggsModels/AwareModel.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Pivot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n"
     ]
    }
   ],
   "source": [
    "if not loadAndPlot:\n",
    "    inv_model = keras.models.load_model('HiggsModels/invariant_model.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Likelihoods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "z_std = 0.05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_test = 1.\n",
    "#mu_test = 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nll_stat(N,S,B,mu):\n",
    "    from scipy.special import loggamma\n",
    "    nexp=mu*S+B\n",
    "    nll_stat = - (N* np.log(nexp) - nexp - loggamma(N) ) # Poisson\n",
    "    if np.isinf(nll_stat):\n",
    "        print (N, nexp)\n",
    "    return nll_stat\n",
    "\n",
    "def nll_syst(dTheta, sigma=1):\n",
    "    nll_syst = - (np.log (1/(sigma*np.sqrt(2*np.pi))) + (-0.5 * (dTheta/sigma)**2))\n",
    "    return nll_syst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build templates, 2D NLL "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assumes each HDF file has events for one fixed z value\n",
    "\n",
    "def buildTemplates(model, clfName,nBins=nBins):\n",
    "    sig_hists = []\n",
    "    back_hists = []\n",
    "    for z_val in z_syst:\n",
    "        X_syst_test, Y_syst_test, Z_syst_test, weights_test = loadSystData(z_val)\n",
    "        zEvents = np.array([True] * len(Z_syst_test)) # for legacy reasons\n",
    "        if (clfName == \"Aware\"):\n",
    "            print (\"Not Currently Supported for analyticial aware classifier\")\n",
    "            Y_pred_model = model.predict(x=[X_syst_test,Z_syst_test], batch_size=batch_size).reshape(-1)\n",
    "        elif (clfName == \"Nominal\") or (clfName == \"Augmented\") or (clfName == \"Invariant\") or (clfName == \"Down\") or (clfName == \"Up\") :\n",
    "            if (clfName == \"Augmented\") and (not aug_NN):\n",
    "                Y_pred_model = model.predict_proba(X_syst_test)[:,1].reshape(-1)\n",
    "            else:\n",
    "                Y_pred_model = model.predict(X_syst_test, batch_size=batch_size).reshape(-1)\n",
    "        else:\n",
    "            print (\"Unexpected Clf name!!\")\n",
    "            \n",
    "        hist_sig, bin_array = np.histogram(\n",
    "            Y_pred_model[zEvents &(Y_syst_test==1)], \n",
    "            weights=weights_test[zEvents &(Y_syst_test==1)], range=(0,1), bins=nBins)\n",
    "        hist_back, bin_array = np.histogram(\n",
    "            Y_pred_model[zEvents &(Y_syst_test==0)], \n",
    "            weights=weights_test[zEvents &(Y_syst_test==0)], range=(0,1), bins=nBins)\n",
    "            \n",
    "        sig_hists.append(hist_sig)\n",
    "        back_hists.append(hist_back)\n",
    "        \n",
    "    del X_syst_test, Y_syst_test, Z_syst_test, weights_test\n",
    "    \n",
    "    sig_hists = np.array(sig_hists)\n",
    "    back_hists = np.array(back_hists)\n",
    "    return sig_hists, back_hists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotNLLCurves(x, y_list, label_list, color_list, linestyle_list, testDataLabel,\n",
    "                  ylimRatio=[0.8, 1.2], xlim=[0.5,1.5], legendOrder=None):\n",
    "    # assumes last y is reference\n",
    "    ref_y = y_list[-1]\n",
    "    \n",
    "    fig = plt.figure(figsize=(5, 5)) \n",
    "    gs = gridspec.GridSpec(2, 1, height_ratios=[5, 1]) \n",
    "    gs.update(wspace=0.025, hspace=0.025)\n",
    "    ax0 = plt.subplot(gs[0])\n",
    "    plt.ylabel(r'NLL - min(NLL)', fontsize=15)\n",
    "    \n",
    "    for (y, lab, col, ls) in zip(y_list, label_list, color_list, linestyle_list):\n",
    "        ax0.plot(x,y, label=lab, color=col, linestyle=ls)\n",
    "    ax0.set_ylim([-0.08, 2])\n",
    "    ax0.set_xlim(xlim)\n",
    "    if (legendOrder is None):\n",
    "        plt.legend(prop={'size': 15}, loc=\"lower right\")\n",
    "    else:\n",
    "        handles, labels = ax0.get_legend_handles_labels()\n",
    "        # re-order and legend in one step\n",
    "        ax0.legend([handles[i] for i in legendOrder], [labels[i] for i in legendOrder],\n",
    "                  prop={'size': 14.1}, loc=(-0.175,1.04), handletextpad=0.1, borderpad=0.1,\n",
    "                  handlelength=1, ncol=2 ) \n",
    "    \n",
    "    ax1 = plt.subplot(gs[1], sharex = ax0) # sharing not working\n",
    "    for (y, lab, col, ls) in zip(y_list, label_list, color_list, linestyle_list):\n",
    "        ratio_y = y/ref_y\n",
    "        ax1.plot(x[~np.isnan(ratio_y)],ratio_y[~np.isnan(ratio_y)], label=lab, color=col, linestyle=ls)\n",
    "    ax1.set_ylim(ylimRatio)\n",
    "    ax1.set_xlim(xlim)\n",
    "    plt.xlabel(r'$\\mu$', fontsize=20)\n",
    "    plt.ylabel(r'ratio', fontsize=15)\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Baseline Classifier (trained on Nominal only)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.8.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.84.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.88.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.89.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.9.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.91.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.92.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.93.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.94.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.95.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.96.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.97.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.98.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.99.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.0.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.01.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.02.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.03.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.04.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.05.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.06.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.07.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.08.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.09.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.1.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.11.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.12.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.13.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.14.h5\n"
     ]
    }
   ],
   "source": [
    "if not loadAndPlot:\n",
    "    sig_hists, back_hists = buildTemplates(model=nominal_model, clfName=\"Nominal\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.0.h5\n"
     ]
    }
   ],
   "source": [
    "X_syst_test_nominal, Y_syst_test_nominal, Z_syst_test_nominal, weights_test_nominal = loadSystData(z_val=z_nominal)\n",
    "nominalEvents = np.array([True] * len(Z_syst_test_nominal)) # for legacy reasons\n",
    "\n",
    "#del Y_syst_test_nominal, Z_syst_test_nominal\n",
    "del Z_syst_test_nominal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createHistObs(X, Y_true, weights, mu, model,):\n",
    "    weights[Y_true==1] *= mu \n",
    "    Y_pred = model.predict(X, batch_size=batch_size).reshape(-1)\n",
    "    hist_obs, bin_array = np.histogram(Y_pred, weights=weights, range=(0,1), bins=nBins)\n",
    "    return hist_obs, bin_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "      hist_obs, bin_array = createHistObs(X=X_syst_test_nominal[nominalEvents],\n",
    "                                          Y_true=Y_syst_test_nominal[nominalEvents],\n",
    "                                          weights=weights_test_nominal[nominalEvents], mu=mu_test,\n",
    "                                          model=nominal_model, \n",
    "                                          )"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/ClfSignalTemplates.npy\", sig_hists)\n",
    "    np.save(\"HiggsModels/ClfBackgroundTemplates.npy\", back_hists)\n",
    "    np.save(\"HiggsModels/hist_obs.npy\", hist_obs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sig_hists = np.load(\"HiggsModels/ClfSignalTemplates.npy\")\n",
    "back_hists = np.load(\"HiggsModels/ClfBackgroundTemplates.npy\")\n",
    "hist_obs = np.load(\"HiggsModels/hist_obs.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeNLL2D(obs1D, sH2d, bH2d, mu_values=mu_values):\n",
    "    min_mu, min_z, minnll = 999,999,999\n",
    "    assert len(obs1D) == sH2d.shape[1] == bH2d.shape[1]\n",
    "    nll2D = np.zeros(mu_values.shape[0] * sH2d.shape[0]).reshape(mu_values.shape[0],sH2d.shape[0])    \n",
    "    for i, z_val in enumerate(z_syst):\n",
    "        for k,mu in enumerate(mu_values):\n",
    "            nll2D[k][i] += nll_syst(dTheta=z_val-z_nominal, sigma=z_std)\n",
    "            for n,s,b in zip(obs1D, sH2d[i], bH2d[i]): # over the bins of score histo\n",
    "                bin_nll = nll_stat(N=n,S=s,B=b,mu=mu)\n",
    "                if (not np.isnan(bin_nll)):\n",
    "                    nll2D[k][i] += bin_nll\n",
    "            if nll2D[k][i] < minnll:\n",
    "                minnll = nll2D[k][i]\n",
    "                min_mu = mu\n",
    "                min_z = z_val\n",
    "    print (\"Min at mu,z: \",min_mu, min_z)\n",
    "    return nll2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.0\n"
     ]
    }
   ],
   "source": [
    "nll2D_clf_nom = computeNLL2D(obs1D=hist_obs, sH2d=sig_hists, bH2d=back_hists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot2dNLL(nll2D, dataName, clfName):\n",
    "    xx, yy = np.meshgrid(mu_values,z_syst)\n",
    "    ind = np.unravel_index(np.argmin(nll2D, axis=None), nll2D.shape)\n",
    "    plt.pcolormesh(xx,yy,(nll2D-nll2D.min() + 1).T)\n",
    "    cbar = plt.colorbar()\n",
    "    cbar.ax.tick_params(labelsize=12)\n",
    "    cbar.ax.set_ylabel(r\"NLL - min(NLL) + 1\", labelpad=5, size=20) \n",
    "    cbar.formatter.set_powerlimits((0, 0))\n",
    "    plt.scatter(mu_values[ind[0]],z_syst[ind[1]] , color=\"crimson\", s=200)\n",
    "    plt.xlabel(r\"$\\mu$\", size=25)\n",
    "    plt.xticks(fontsize=15)\n",
    "    plt.yticks(fontsize=15)\n",
    "    plt.ylabel(r\"$z$\", size=25)\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_clf_nom, dataName=\"Nominal\", clfName=\"Clf\")\n",
    "#plt.savefig(plotDir + \"TwoD_NLL_{}_{}.pdf\".format(\"Clf\", \"Nominal\",), bbox_inches='tight',pad_inches = 0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_clf_nom = nll2D_clf_nom.min(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.1.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.8.h5\n"
     ]
    }
   ],
   "source": [
    "X_syst_test_systUp, Y_syst_test_systUp, Z_syst_test_systUp, weights_test_systUp = loadSystData(z_val=systUp)\n",
    "systUpEvents = np.array([True] * len(Z_syst_test_systUp)) # for legacy reasons\n",
    "\n",
    "del Z_syst_test_systUp\n",
    "\n",
    "X_syst_test_systDown, Y_syst_test_systDown, Z_syst_test_systDown, weights_test_systDown = loadSystData(z_val=systDown)\n",
    "systDownEvents = np.array([True] * len(Z_syst_test_systDown)) # for legacy reasons\n",
    "\n",
    "del Z_syst_test_systDown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_systUp, bin_array = createHistObs(X=X_syst_test_systUp[systUpEvents],\n",
    "                                               Y_true=Y_syst_test_systUp[systUpEvents],\n",
    "                                               weights=weights_test_systUp[systUpEvents], mu=mu_test,\n",
    "                                               model=nominal_model)\n",
    "    hist_obs_systDown, bin_array = createHistObs(X=X_syst_test_systDown[systDownEvents],\n",
    "                                                 Y_true=Y_syst_test_systDown[systDownEvents],\n",
    "                                                 weights=weights_test_systDown[systDownEvents], mu=mu_test,\n",
    "              model=nominal_model)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/hist_obs_systUp.npy\", hist_obs_systUp)\n",
    "    np.save(\"HiggsModels/hist_obs_systDown.npy\", hist_obs_systDown)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exists\n"
     ]
    }
   ],
   "source": [
    "if 'bin_array' in globals():\n",
    "    print(\"exists\")\n",
    "else:\n",
    "    assert nBins==30\n",
    "    bin_array = np.array([0.        , 0.03333334, 0.06666667, 0.1       , 0.13333334,\n",
    "       0.16666667, 0.2       , 0.23333333, 0.26666668, 0.3       ,\n",
    "       0.33333334, 0.36666667, 0.4       , 0.43333334, 0.46666667,\n",
    "       0.5       , 0.53333336, 0.56666666, 0.6       , 0.6333333 ,\n",
    "       0.6666667 , 0.7       , 0.73333335, 0.76666665, 0.8       ,\n",
    "       0.8333333 , 0.8666667 , 0.9       , 0.93333334, 0.96666664,\n",
    "       1.        ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist_obs_systUp = np.load(\"HiggsModels/hist_obs_systUp.npy\")\n",
    "hist_obs_systDown = np.load(\"HiggsModels/hist_obs_systDown.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.1\n",
      "Min at mu,z:  1.0 0.8\n"
     ]
    }
   ],
   "source": [
    "nll2D_clf_systUp = computeNLL2D(obs1D=hist_obs_systUp, sH2d=sig_hists, bH2d=back_hists)\n",
    "nll2D_clf_systDown = computeNLL2D(obs1D=hist_obs_systDown, sH2d=sig_hists, bH2d=back_hists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_clf_systUp, dataName=\"SystUp\", clfName=\"Clf\")\n",
    "#plt.savefig(plotDir + \"TwoD_NLL_{}_{}.pdf\".format(\"Clf\", \"SystUp\",), bbox_inches='tight',pad_inches = 0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_clf_systUp = nll2D_clf_systUp.min(axis=1)\n",
    "nll1D_clf_systDown = nll2D_clf_systDown.min(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Augmentation trained classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.8.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.84.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.88.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.89.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.9.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.91.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.92.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.93.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.94.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.95.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.96.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.97.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.98.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.99.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.0.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.01.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.02.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.03.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.04.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.05.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.06.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.07.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.08.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.09.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.1.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.11.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.12.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.13.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.14.h5\n"
     ]
    }
   ],
   "source": [
    "if not loadAndPlot:\n",
    "    sig_hists_aug, back_hists_aug = buildTemplates(model=augmented_model, clfName=\"Augmented\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hist_obs_aug, bin_array = np.histogram(\n",
    "#     augmented_model.predict(X_syst_test_nominal[nominalEvents], batch_size=batch_size).reshape(-1), \n",
    "#     weights=weights_test_nominal[nominalEvents], range=(0,1), bins=nBins)\n",
    "\n",
    "if not loadAndPlot:\n",
    "    hist_obs_aug, bin_array = createHistObs(X=X_syst_test_nominal[nominalEvents],\n",
    "                                            Y_true=Y_syst_test_nominal[nominalEvents],\n",
    "                                            weights=weights_test_nominal[nominalEvents], \n",
    "                                            mu=mu_test,\n",
    "              model=augmented_model)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/AugSignalTemplates.npy\", sig_hists_aug)\n",
    "    np.save(\"HiggsModels/AugBackgroundTemplates.npy\", back_hists_aug)\n",
    "    np.save(\"HiggsModels/hist_obs_Aug.npy\", hist_obs_aug)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sig_hists_aug = np.load(\"HiggsModels/AugSignalTemplates.npy\", )\n",
    "back_hists_aug = np.load(\"HiggsModels/AugBackgroundTemplates.npy\", )\n",
    "hist_obs_aug = np.load(\"HiggsModels/hist_obs_Aug.npy\", )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.0\n"
     ]
    }
   ],
   "source": [
    "nll2D_aug_nom = computeNLL2D(obs1D=hist_obs_aug, sH2d=sig_hists_aug, bH2d=back_hists_aug)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_aug_nom, dataName=\"Nominal\", clfName=\"Aug\")\n",
    "#plt.savefig(plotDir + \"TwoD_NLL_{}_{}.pdf\".format(\"Aug\", \"Nominal\",))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_aug_nom = nll2D_aug_nom.min(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_aug_systUp, bin_array = createHistObs(X=X_syst_test_systUp[systUpEvents],\n",
    "                                                   Y_true=Y_syst_test_systUp[systUpEvents],\n",
    "                                                   weights=weights_test_systUp[systUpEvents], mu=mu_test,\n",
    "              model=augmented_model)\n",
    "    hist_obs_aug_systDown, bin_array = createHistObs(X=X_syst_test_systDown[systDownEvents],\n",
    "                                                     Y_true=Y_syst_test_systDown[systDownEvents],\n",
    "                                                     weights=weights_test_systDown[systDownEvents], \n",
    "              mu=mu_test, model=augmented_model)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/hist_obs_aug_systUp.npy\", hist_obs_aug_systUp)\n",
    "    np.save(\"HiggsModels/hist_obs_aug_systDown.npy\", hist_obs_aug_systDown)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist_obs_aug_systUp = np.load(\"HiggsModels/hist_obs_aug_systUp.npy\", )\n",
    "hist_obs_aug_systDown = np.load(\"HiggsModels/hist_obs_aug_systDown.npy\", )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.1\n",
      "Min at mu,z:  1.0 0.8\n"
     ]
    }
   ],
   "source": [
    "nll2D_aug_systUp = computeNLL2D(obs1D=hist_obs_aug_systUp, sH2d=sig_hists_aug, bH2d=back_hists_aug)\n",
    "nll2D_aug_systDown = computeNLL2D(obs1D=hist_obs_aug_systDown, sH2d=sig_hists_aug, bH2d=back_hists_aug)\n",
    "\n",
    "nll1D_aug_systUp = nll2D_aug_systUp.min(axis=1)\n",
    "nll1D_aug_systDown = nll2D_aug_systDown.min(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_aug_systUp, dataName=\"SystUp\", clfName=\"Aug\")\n",
    "#plt.savefig(plotDir + \"TwoD_NLL_{}_{}.pdf\".format(\"Aug\", \"SystUp\",))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clf trained on SystDown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.8.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.84.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.88.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.89.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.9.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.91.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.92.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.93.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.94.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.95.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.96.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.97.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.98.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.99.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.0.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.01.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.02.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.03.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.04.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.05.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.06.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.07.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.08.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.09.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.1.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.11.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.12.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.13.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.14.h5\n"
     ]
    }
   ],
   "source": [
    "if not loadAndPlot:\n",
    "    sig_hists_down, back_hists_down = buildTemplates(model=down_model, clfName=\"Down\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_down, bin_array = createHistObs(X=X_syst_test_nominal[nominalEvents],\n",
    "                                             Y_true=Y_syst_test_nominal[nominalEvents],\n",
    "                                             weights=weights_test_nominal[nominalEvents], mu=mu_test,\n",
    "              model=down_model)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/DownSignalTemplates.npy\", sig_hists_down)\n",
    "    np.save(\"HiggsModels/DownBackgroundTemplates.npy\", back_hists_down)\n",
    "    np.save(\"HiggsModels/hist_obs_Down.npy\", hist_obs_down)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sig_hists_down = np.load(\"HiggsModels/DownSignalTemplates.npy\", )\n",
    "back_hists_down = np.load(\"HiggsModels/DownBackgroundTemplates.npy\", )\n",
    "hist_obs_down = np.load(\"HiggsModels/hist_obs_Down.npy\", )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.0\n"
     ]
    }
   ],
   "source": [
    "nll2D_down_nom = computeNLL2D(obs1D=hist_obs_down, sH2d=sig_hists_down, bH2d=back_hists_down)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_down_nom, dataName=\"Nominal\", clfName=\"Down\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_down_nom = nll2D_down_nom.min(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_down_systUp, bin_array = createHistObs(X=X_syst_test_systUp[systUpEvents],\n",
    "                                                    Y_true=Y_syst_test_systUp[systUpEvents],\n",
    "                                                    weights=weights_test_systUp[systUpEvents], mu=mu_test,\n",
    "              model=down_model)\n",
    "    hist_obs_down_systDown, bin_array = createHistObs(X=X_syst_test_systDown[systDownEvents],\n",
    "                                                      Y_true=Y_syst_test_systDown[systDownEvents],\n",
    "                                                      weights=weights_test_systDown[systDownEvents], mu=mu_test,\n",
    "              model=down_model)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/hist_obs_down_systUp.npy\", hist_obs_down_systUp)\n",
    "    np.save(\"HiggsModels/hist_obs_down_systDown.npy\", hist_obs_down_systDown)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist_obs_down_systUp = np.load(\"HiggsModels/hist_obs_down_systUp.npy\", )\n",
    "hist_obs_down_systDown = np.load(\"HiggsModels/hist_obs_down_systDown.npy\", )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.1\n",
      "Min at mu,z:  1.0 0.8\n"
     ]
    }
   ],
   "source": [
    "nll2D_down_systUp = computeNLL2D(obs1D=hist_obs_down_systUp, sH2d=sig_hists_down, bH2d=back_hists_down)\n",
    "nll2D_down_systDown = computeNLL2D(obs1D=hist_obs_down_systDown, sH2d=sig_hists_down, bH2d=back_hists_down)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deZhdVZ3u8e+bhAwkJCQgisgYoBG8gsjVBuEigzK1jSBIixMKpsUBWwUvKtgRbK/iBbQRwbQDF1tBmUVABmXKI4MMBgxEBAkoIFMKQkLGqt/9Y+0Dh5NTZx72rno/efaT2muvvc/ap07Vr9ZekyICMzOzvBnT7wKYmZlV4wBlZma55ABlZma55ABlZma55ABlZma55ABlZma55ABlZtZjkn4k6SlJf2wg7xGSnpb0h2w7qhdlzAMHKDOz3jsH2LeJ/D+PiB2y7QddKlPuOECZmfVYRNwELCpPkzRT0q8l3SnpZknb9Kl4ueEAZWaWD3OAT0fEm4Fjge+VHXuPpHskXShp4/4Ur/fkqY7MzHpP0mbAryLiDZKmAE8DfyrLMiEiXi9pPWBJRKyQ9HHgvRGxZ+9L3HsOUGZmfVARoKYCf4qIDeucMxZYFBHTelDEvvMjPjOzPouIxcDDkg4FULJ99nV50Ppn4P4+FLEvHKDMzHpM0nnALcA/SPqbpCOB9wNHSpoHzAcOzLIfI2l+ln4McEQTr/MpSXdIWiHpnDp5Pyvp75Kez7rBT2jh1jrKj/jMzEYoSQcDQ8A+wKSIOGKYfPsA5wJ7Ao8DlwC3RsTxPSpqVa5BmZmNUBFxcURcCjxbJ+uHgR9GxPyIGABOpomaWreM63cBimS8JsREJve7GGaWYy8w8ExEvKrV8/fZY3I8u2iwbr4771lxdUQ0M9i3lu2Ay8r25wGvlrReRNQLbl3jANWEiUzmrdqr38Uwsxy7Li58pJ3zn100yO1Xb1I339gN/7yNpDvKkuZExJwWX3YK8HzZfunrdahf++oaBygzsxwJYIihRrI+ExE7dehllwBTy/ZLX7/Qoeu3xG1QZmY5EgSrYrDu1mHzge3L9rcHnuzn4z1wgDIzy52hBv41QtI4SROBscBYSRMlVXtydi6pi/u2kqYDJ5AmtO0rBygzsxwJgsGovzXoBGAZcDzwgezrEyRtImmJpE0AIuLXwCnA9cAj2fbvnb63ZrkNyswsZ4bozPjUiJgNzB7m8JSKvKcBp3XkhTvEAcrMLEcCWNXgI7yRzgHKzCxHApp5hDeiOUCZmeWM60+JA5SZWY4EwWCH2qCKzgHKzCxHImDVCIxPknYBtoyIcxs9x93MzcxyRQw2sBXQx4AfN3OCa1BmZjkSwNAIrEG1wgHKzCxnilBDkrRFk6es0+xrOECZmeVIAKuiEK0vD0J3e3M4QJmZ5UhQjBoUqajPAfc0mH8bYINmXsAByhhDMF7BihBRjB8MsxErEIPF6L/2F4CI2KORzJJ+DHyomRdwgBqlxhHsOH45+0xayoZjVzNE6tL5xOA4rl42mbtWTmS1g5VZXwxFIX727gYOljQlIpZ04wVyGaYlbSnp+5LmSRqUdEMD54yX9C1JN0taJmnYZ6OSDpR0r6Tlku6TdFhHbyDnNhu3km9Mf4r3TV7MRuNWM0YwTjBGsNG41Rw+eTHfmP4Um45d1e+imo06gVgZY+tuOTCPFEO2r5cxo2xrWC4DFLAdsD/wQLY1Ym3gKOBF4HfDZZK0K3ARaVr5/YArgPMkvbOdAhfFpmNX8dmpi5gyJpg0pnoMnzgmmDIm+Ny0Zx2kzHosrag7pu6WA+cABwEPN5I5Io6IaK73Ry7usorLI2LjiDiUtNJjXRHxHDAjIvYBLqmR9UTgpog4JiKuj4jjgF8DX2m71Dk3juDTUxcxocG/YSYIPj11EeM87YpZTxVhoG5EPBYRl0XE4916jVwGqIhoaa7EiNpTAEuaAOwB/KLi0PnAzpKmtfK6RbHj+OVNNzqOy84zs96IEIMxpu42GoyOu3zZTGAtYEFF+v2k92Lrnpeoh/aZtJSJwzzWG87EMcE+k5Z2qURmVimtBzW27jYajLZefNOz/5+rSB+oOD7iiGDDsatbOnfDsasR4S7oZj2hUVNDqme0BaiSymqEhklH0ixgFsBE1u5ysbpnguKlruTNGsrOX16Mrq9mhVbqJGGjL0CVakrrVqSX9itrVkTEHGAOwFTNKGxvgRWhlj/yY7Lzzaw3Bv3zBoy+NqiHgFWkKTfKbUOqKDTapb1wAvHEYGt/jzwxOM6P98x6JBCrYlzdbTQYVQEqIlaQxj8dWnHoMOCWiHi+96XqnauXTWb5UHOBZtmQuHrZ5C6VyMwqpbn4xtTdRoNchmFJa5MG6gJsBEyVdEi2f2VEvCjpQeDGiDiy7Lz9gMnADtl+6ZzfR8Qj2dcnAzdI+jZwafY6+wP7dvOe8uCulRN57+TFTZ0zmJ1nZr0RyI/4MrkMUKQZby+oSCvtbw4sJJW9sq/lWcCmVc75CGnUMxExNwtcXwOOJo2CPjwirulQ2XNrNeKMxTP43LRnGxqsuyLgjMUzPCefWY+5k0SSywAVEQupM2dTRGzWSNow515Kqj01T8X+4DwyNIHTFq/Pp9d5lnFQdVzUsiExCJzxwno8MjS+ydmz6mhtDLbZqBEhVuVjrr2WSRoEZkfEye1cJ5cByrrrkcHxHP/ca9hx/DL2mbhkzdnMl0/hrpWTXHMy64OAkTAOqumJYatxgBqlViNuX7k2t69cGxFM8HpQZrkxWjpB1OMAZQTyIFyznAhUlPWgus4ByswsRwJGzTinevwumJnlSj6W02iUpB8Nc+jdkjarSIvyoUH1OEA1SWOK88HJp2L3TuqWGCrsLFpWqc1vZQBDxeokccQw6TtkW7kAGg5QhXoXzMxGgyIsWFgSEWMqt+zQ7CrHmvoL1QHKzCxHIsSqoXF1t0ZImiHpEklLJT0i6fBh8k2QdLakJyUtknS5pI06emMtcIAyM8uRtNyG6m4NOhNYCbwaeD9wlqTtquT7DLAz8EbgtaSVHc5o+2ba5ABlZpYrnVnyXdJk4D3AiRGxJCLmAr8EPlgl++bA1RHxZEQsB84HqgWynnKAMjPLkdRJQnU3YH1Jd5RtsyoutTUwGBHlywjNo3rg+SHwNkmvzSbrfj9wVRdurynuxdcESWhsY2187pVlzZA7N44cbU43mdaDaugD8UxE7FTj+BSgcgmh54F1quR9AHgUeIy0iMG9wKcaKcQwvgrc0Mb5gAOUmVnudGg28yXA1Iq0qcALVfKeBUwE1gOWAl8g1aDe2soLR8RXWzmvkh/xmZnlSERa8r3e1oAHgHGStipL2x6YXyXv9sA5EbEoW9j1DOAtktZv+4ba4ABlZpYzDbZB1RQRS4GLgZMkTZb0NuBA4CdVsv8e+JCkaZLWAj4BPB4Rz3TwtprmAGVmliOlNqh6W4M+AUwCngLOA46OiPmSdpO0pCzfscBy4M/A06RVxg/q3F21xm1QZmY5UurF15FrRSwC3l0l/WZSJ4rS/rOknnu54gDVDAEN9uIrVK8s9zg065xV7V5ARZuLr2ty+S5I2lLS9yXNkzQo6YYGz5sm6ceSBiQ9L+mnktaryHOOpKiybdOVmzEza1IHZ5IotLzWoLYjPQO9FRjfxHk/B/4BOIo0GuGbwKXAbhX5FgAfqUhb2EpBzcw6KQJWDRXpEUz35DVAXR4RlwFIuhCo29VR0s7APsDuEXFTlvYYcJukvSPiurLsSyPi1i6U28ysLV5R92W5DFAR0cpY7P2AJ0vBKbvO7ZIezo5dN+yZZmY5UtRHeNn8fxuRKhXLgKci4rFWr5fLANWibUiP7irdnx0rt62kxcAEUv//L0fEjV0un5lZXZ3sxdcLkmYCHwXeAbyJir4Nkp4FrgcuAi6OiNWNXnskBajppCniKw0AW5Tt3w3cBtwHvAr4PHCtpF0j4vbKk7MJGGcBTNTkhufiK5QReEs2csRQm5PbFU2I1QVog5K0E/A1YG9SUFpFmsPv78Ai0vir9Uj9Ag4FDgGelvQd4LRsxoqaRlKAguqLLas8PSK+84qD0hWkYPUlqo8XmAPMAZg2dn33xzazriqtB5Vnkv4fadzU86Tfj+cDt2dLdVTLvxmpj8CHgf8APi7pg+VNMtXkspt5iwaAdaukr0v1mhUAEbEMuBLYsUvlMjNrSiemOuqydwKfA14bEZ+IiJuGC04AEbEwIr4fEbsAOwB3AbvXe5GRVINawJrdySG1P13awPmuHZlZ3xWkDWqL7I/7pkXEPcBBkibVyzuSalBXAa+RtGspIXtGugU1Ft7K3qT9gDu7XkIzszoCsXpoTN2tr2VsIThJep2kNzZzjVzWoLIVHffPdjcCpko6JNu/MiJelPQgcGNEHAkQEbdIuho4V9KxvDxQd25pDJSkacCvgP8GHiR1hfxs9hrv7c3dmZnVlvc2qBadDHyIJrpl5TJAARsAF1SklfY3J836MI41b/RfgNOBH5Fqh78Cjik7voI0U+8J2WssB24hDe69o26pJBi/VhO30QbPj2cjWTT++R6RPWdriUI84uuJXAaoiFgItf+EiIjNqqQ9R5rCqHIao9Lx5cDB7ZfQzKw7CtIG1RO5DFBmZqNVqQ3KHKDMzHInXIMCHKDMzHJnhHaSaJoDlJlZjkRBOklI2qTJU6bUz/JKDlDNkNA4v2UjUhO9ysy6SwwWow1qIV2e4MC/bc3McqYgbVCP4gBlZjZ6FKWbebWhPp3mAGVmlicxMp84S5oIjI+IxY2eU4gHnWZmo8kQqrsV0FmkdaIa5hqUmVmORHE6SbSiqcjqANUMCdbq0Vx81n8j8TmLFYI/eokDlJlZzhSkF1/XOUCZmeVIhANUiQOUmVnODA45QIEDlJlZ7rgGlThAmZnlSKBCBChJg91+DQeoZowRTBjf71Lkj1f/HX1iqN8lGNEK8hPVShRt6tZy2dle0paSvi9pnqRBSTc0eN40ST+WNCDpeUk/lbRelXwHSrpX0nJJ90k6rOM3YWbWioAYUt2tEZJmSLpE0lJJj0g6vEbeHSXdJGmJpCclfaZmMSPGtLCNbeatyGWAArYD9gceyLZG/Rx4O3AUcATwP4FLyzNI2hW4CLge2A+4AjhP0jvbLbSZWSdEqO7WoDOBlcCrgfcDZ0narjKTpPWBXwPfB9YDtgSu6cjNtCGvj/guj4jLACRdCKxf7wRJOwP7ALtHxE1Z2mPAbZL2jojrsqwnAjdFxDHZ/vXZN+wr5OAbYmbWiYG6kiYD7wHeEBFLgLmSfgl8EDi+IvvngKsj4qfZ/grg/vZL0Z5c1qAiWnrAvR/wZCk4Zde5HXg4O4akCcAewC8qzj0f2FnStNZKbGbWGUHDNaj1Jd1Rts2quNTWwGBElD+Fmkd6QlXpH4FFkn4n6SlJl9dbkFDSmFa2Zt6LvNagWrENsKBK+v3ZMYCZwFpV8t1PCtZbA7/vVgHNzOrK2qAa8ExE7FTj+BTg+Yq054F1quR9HbAj8A7gXuAU4DzgbTWuv6qRQlYImog7IylATQeeq5I+AGxRlocq+QYqjr8k+6tkFsDEcVNhvOfi6xlPSDYyuJdn8zrzli0BplakTQVeqJJ3GXBJRPweQNJXgWckTYuIyiBX8tcmSjqF1LbVlJEUoKD6m6Uq6ZX7GiadiJgDzAGYNmlD/6SZWZd1bBzUA8A4SVtFxJ+ztO2B+VXy3sMrf/+Vvh62II0sWChpLeDTwJezpIX1zimXyzaoFg0A61ZJX5eXa0wDZWmVeaB6DczMrLeiga3eJSKWAhcDJ0maLOltwIHAT6pk/zFwkKQdsqByIjA3Ilr+nSjpUFLzybdIge4LwOubucZIClALeLmtqVx529RDpOemlfm2AYZorku7mVnndXAcFPAJYBLwFKlN6eiImC9pN0lLXnrJiN8CXyINu3mK1M182DFTtUjaRdItpM5nGwP/CcyMiP8bESubudZIClBXAa/JxjkBIGknUvvTVQARsYI0/unQinMPA26p8azVzKyH1MBWX0Qsioh3R8TkiNgkIn6Wpd8cEVMq8p4VERtFxPSIeFdE/LWpEqcJFi4EbgbeShpv+vqI+GxEDNQ+u7pctkFJWps0UBdgI2CqpEOy/Ssj4kVJDwI3RsSRABFxi6SrgXMlHUuqEX2TVE29ruzyJwM3SPo2aRDv/tm2b9dvzMysEQVq7ZY0A/h34F+B8cAtwOcj4tZ2r53LAAVsAFxQkVba35zU0DYOqJw241+A04EfkWqHvwKOKc8QEXOzYPc14GjSOKnDI8KDdM0sHwoQoCSNB/4N+CIwjdSEcnxEXNSp18hlgIqIhdSpw1brQZI16H0k22qdeykVUyA1RGJowujuZi53/e4tv9+jT+PjoPrtT8AmwCJSoDozIjo6w3kuA5SZ2ahWjL9LNiWVVMCxwLFS3cAaEbFpoy/gAGVmljcFWA8qI2BGtnWcA5SZWc6oADWoiOh6L3AHKDOzPAlBMdqgus4ByswsbwpQg+qFpgKUpOOBu4DrI6KVmWwLLcaIoUm96cWX195y+SzVMHL6Ho5YXgW+c3L+0ZW0UUQ81uY1NoyIJ2rlafYZ4tdJszJcKMm1LzOzbujAXHxd9qCk0yVt1MxJSg6UdDfwsXr5W2nkEvBPwPn1Fp+StIekjVt4DTOz0SlAQ6q79dm3SMsQLZR0laSPSNqqWkZJUyTtKembpCU6LgaWZ//X1EotaDHwDHAQ8N+S3h8x7LOUnwGvavF1zMxGp/7XkGqKiK9ImgN8hTSp7DsBJL0A/J20csRE0hpQG5IqQwLuBo6NiPMbeZ1WAseLwJ7ATaRJVlcCR9TI3/dQb2ZmnRURfwNmZXOfHg7sTVqBd+uybCuBPwA3ABc1Oz9fSzWbiHhUUilIfVDSyoiY1cq1zMzslYowDqokIhYDZ2dbaZHC9YBl7a4Q0fKjt4j4SxakbgSOzILUp9opTO6NEUMTK+en7aECfWh7zj322lakX4ojWlDocVBZD++/d+JabY0EjogHgL2AZ4GjJZ3aiUKZmY1q+e/F1xNtd16IiPsk7U1aCPDfsprUF9svmpnZ6FTU2qykDYCdgOmsuRwSABFxbqPX60jvuoi4R9I7gN8AX5C0IiJmd+LaZmajTsECVNbudDbwIYZ/MifSnfU2QAFExF2S9gWuBU6U1NTa82ZmlmpPKt6sHCeT1uF7CPgpabzT6nYv2myA2hHYcriDEXGbpP1Js02c3E7BzMxGreIst1FyOPAA8KaIWNapizYVoCLiD6Q+7bXyzJX0z6Tl1ifRQmVV0rbAGcDOwHPAD4Cv1lutUdJ2pCXfdyWN17oAOC4ilpTlOQf4cJXTXx8RC2pdPwSrJzXYi69gVfR2FPV5ed+4x2FTRuXnq3j3vAHwvU4GJ+jSDA8Rcb2kdwNfA97QzLmSpgPXAfcBBwIzgVNJzzVPqHHeNOC3pCh+GKkf/imkUczvrsi+gDWXhV/YTDnNzLqlgEH5UWBqpy/atSmIIuJa4Np68/VV8XFSzevgbADYtZKmArMlnZKlVfOJ7Lx3RcRzAJIWAZdJ2iki7ijLu7TZEc1mZj1RzDaoc4BPSprW7uDccl1fETEimn2r9wOurghE55OCz+41ztsBuKMUnDLXkCrLBzRZBjOz/ineOKhvAHOB67JJwjtSm+p6gGrBNqRHcC+JiEdJbUrb1DhvImnep3KrSavUvL4ifVtJiyWtkDRXUq3AZ2bWW8ULUKuAQ4A3k5poBiQNVtma6tmXx1nGp5M6RlQayI4N50HgcElrlS2m+GbSYLEZZfnuBm4jtXG9Cvg86THirhFxe+VFJc0iTSvPhInrNnkrZmbNK2Ab1M10IWzmMUBB9RvVMOkl/wV8BjhD0mxSJ4nvAYPZli4c8Z1XXFS6ghSsvsSanSmIiDnAHIAp0zeO1ZN6U+ks4Ae0PaPtfiuMuu93u0Z6T8iC3V5EvL0b183jI74BoFpVZRrVa1YAZF3EZwHvA54A7gFuJ3WLf7LGecuAK0ljvMzM+iuywbp1ttEgjzWoBVS0NWWr8k6mom2qUkT8SNLPgK2Ap0gLKz5LGkdVzyj5lptZ7vm3EZDPAHUVcJykdSLihSztMGAZaWmPmiJiOXAvgKQPk2qJvxguv6RJpJ6Dd7ZZbjOzzsh5gJL0FVIpz4yIRdl+IyIiGp5lKI8B6mzgGODibA37LYDZwGnlXc8lPQjcGBFHZvtTgS+TFlFcDexB6gDxsYhYlOWZRprh4r9JnSrWBz4LbAS8txc3Z2ZWiyjEOKjZpAD1c2BRtt+IoIlp8HIXoCJiQNJewHeBy0ntTqez5hswjldO5z4IvAn4GGnM1B+BQyPi0rI8K4CnSTNSbAAsB24Bdq8YyGtm1h8dbGOSNAP4IfBOUpPHFyPiZzXyjye130+JiNfVuPQe2f+PVux3VO4CFKQ1poA96+TZrGJ/KembUOuc5cDBLZdrDKxeu4/9SnJe7W/HaGn0HdZI75XWgOY+A4WbTLU5nfs4nEkaH/pq0mQGV0iaFxHzh8l/HKn9fkrN4kXcWGu/U/LYi8/MbHTrwEBdSZOB9wAnRsSSiJgL/BL44DD5Nwc+APyf9m+gM3JZgzIzG80abINaX1J508ScbNxmydbAYEQ8UJY2j+GnjDuDNB60rRnJJQl4DbBWtePZzEANcYAyM8uTxqcyeiYidqpxfApQOXHr88A6lRklHQSMi4hLJL29sYKucY1DgeOB/8Ewy72T7qzhuOMAZWaWMx1qk13CmktgTAVeKE/IHgWeAuzf6gtJ+iTwn6Qe1HOBx+jDirpmZtZtnQlQDwDjJG0VEX/O0rYHKjtIbAVsBtycns4xHpgm6e/AP0bEwgZe67OkzhW7RMTDHSg74ADVlBgDq9buQu+hgnfgGrE98Hp6X/3vlSb3JMzNz2InxkFFxFJJFwMnSTqK1IvvQGCXiqx/BDYu29+FNMxnR9KwnEZsBPxXJ4MTuBefmVm+NNKDr/FAWlrI9SngPODoiJgvaTdJSwAiYnVE/L20kQbeDmX7g8Nf+hX+CkxouFQNcg3KzCxHROfq09ksOtVWabiZYcY6RcQNQK1ButWcA3y8Yoq6trkGZWaWN8VbsPCbwO9JK+ruLmmNnoKtcA3KzCxnCjAX3ytExKCkM4ELgN8CZB0uqmQNdzM3Myus/NWQapJ0IHAhafzTw8DjuJt5j42B1Wv3uxBVFOzDXE3hewIWvfxAUy0fI+J+15SLz2ExFyScDbwIHJBNqdQRDlBmZnlTvAD1D8C5nQxO4ABlZpY7RWuDIi3lsbLTF3WAMjPLmQI+4rsI2FfSWhGxqlMXdTdzM7M86exA3V45ARgALpC0Wacu6hqUmVne5C8A1XMvaXmNtwLvkvQca86kDqmb+cxGL5rLACVpW9LaJDuTlnz/AfDVetNuSNqOtDz8rqQeJRcAx0XEkop8BwJfI02S+Jfs2j+vV67Iay++aor3AV/TCLiHAj6qeaWil7+WnN6bKOTnZgypW3n5Wk/VuoU2NUlG7gKUpOnAdcB9pIkNZwKnkt6AE2qcN400QOwB4DBgPdIU8htSNtWHpF1Jz0u/BxxDmmL+PEkDEXFNF27JzKwpGipWhIqIzbpx3dwFKODjpMkND46IxcC1kqYCsyWdkqVVU5oU8V0R8RyApEXAZZJ2iojSypMnAjdFxDHZ/vVZzesrgAOUmfVXPtuY+iKPnST2A66uCETnk4LPcEsVQ5pK/o5ScMpcQ/pWHwAgaQKwB/CLinPPB3bOamFmZn2lqL+NBnkMUNsAC8oTsjXsX8yODWcia/bDXw0MAa/P9meSGvIWVOS7n/RebN1akc3MOqh4vfi6Io8BajqpY0SlgezYcB4Etpe0Vlnam0lzQ80ouzZVrj9QcfwlkmZJukPSHatfXFqv7GZmbdNQ/W00yGMbFFT/+0DDpJf8F/AZ4AxJs0mdJL4HDGZbretrmHQiYg4wB2Di6zaOVZPrFb0zClWFL1JZoVDlLdTnYLTp1vdmFD3CqyePNagBYN0q6dOoXrMCICIWALOA9wFPAPcAtwN/AJ4suzZVrl/aH/b6ZmY940d8QD4D1AIq2pokbQxMZs22o1eIiB8BrwbeCLwW+BSwJXBrluUhYFXl9bP9IVIXdTOzvimNg3IniXwGqKuAfSpWZDwMWAbcWO/kiFgeEfdGxJPAB0j3+Ivs2ArgeuDQitMOA26JiGojn83MekpDUXcbDfIYoM4GVgAXS9pb0izSWiOnlXc9l/SgpB+W7U+V9E1JB0jaR9I3SDNQHBMRi8qufzLwdknflvR2SaeQBuue1IN7MzOrrZhz8b2CpM9I+ku718ldJ4mIGJC0F/Bd4HJSu9DppCBVbhyph17JIPAm4GOkMVN/BA6NiEsrrj9X0iGkqY6OJq3+eLhnkTCzvBgBvfTWBTZt9yK5C1AAEXEfsGedPJtV7C8F3tng9S8FLq2bsfK8MbB6Sv4+Obl9Hh1NTbvVX3l9D6spUlnJ8eezUf0of9Hfsw7JZYAyMxu1onhz8XWLA5SZWc4UvtbZIQ5QZmZ5U/wAdSmwsN2LOECZmeVIQdeDeoWImAfMa/c6DlBmZnkSo2ecUz0OUE1Ye+0V7Pjmhzp+3aE+93br9+vnoQx9f/3mFhrtThly8DmopmjlanvwD4yER3wd4QBlZpYzRX/E1ykOUGZmeRKAH/EBDlBmZrkzAmaS6Ig8zsVnZja6RdTfGiBphqRLJC2V9Iikw4fJd5ykP0p6QdLDko7r6P2k13idpDc2c45rUGZmOdPBNqgzgZWkZYh2AK6QNC8i5le+JPAh0jp6M4FrJP01Is7vWEnSRN0f4pVzqNbkGpSZWZ50aDZzSZOB9wAnRsSSiJgL/BL44BovGXFKRNwVEasj4k/AZcDbOnI/bXCAMjPLEQEajLobsL6kO8q2WRWX2hoYjIjyhVjnAdvVfH1JwG5AZS2r5/yIz8wsZ9RYG9MzEbFTjeNTgMpFWJ8H1qmSt9xsUuXlx40UopscoMzM8qRzCxIuAaZWpE0FXhjuBEmfIrUT7ZatQN5XfsRnZpYrDfTga6yG9QAwTtJWZWnbM8yjO0kfBSevBykAAA0YSURBVI4H9oqIv7V9Gx3gGpSZWc50Yi6+iFgq6WLgJElHkXrxHQjsssbrSe8Hvg7sERENzdYkaZMmizSlyfz5rEFJ2lbSbyS9KOlxSSdJqts1UdJOkq6R9KykRZKuk/TWijznSIoq2zbduyMzswZFGqhbb2vQJ4BJwFPAecDRETFf0m6SlpTl+xqwHvB7SUuy7ew6114IPNzEdnDDpc7krgYlaTpwHXAfKdrPBE4lBdMTapy3cXbeXaRnqADHkfrzvzEiHinLvgD4SMUlFnai/GZmbWtwIG79y8Qi4N1V0m+mrEYTEZu3cPlH6fK0trkLUMDHSRH/4IhYDFwraSowW9IpWVo1B5B6pxwcEc8BSPod8AywP3BWWd6lEXFr1+7AzKwdBZiKLyI26/Zr5PER337A1RWB6HxS0Nq9xnlrAatJPVdKlmRp+Zyv38ysCg0N1d2KRtLErLLRsDwGqG1Ij+BeEhGPAi9mx4ZzUZbnVEkbSNoAOB0YAC6oyLutpMWSVkiaK6lW4DMz650AhhrYiucsYFEzJ+TxEd904Lkq6QPZsaoi4nFJewC/Ao7Jkp8A9omIp8uy3g3cRmrjehXwedJjxF0j4vYOlN/MrGUiGh2oW0RNPc3KY4CC6k9gNUx6OihtCFwI3AkclSV/kjQ54i5ZLYyI+E7FeVeQgtWXqNKYmE0fMgtg0qub7iVpZta8kRugmpLHR3wDwLpV0qdRvWZVchwp4B4SEb+OiF+TJkocBI4d7qSIWAZcCew4zPE5EbFTROw0Yd1JDd6CmVmLAhiM+tsokMca1AIq2pqyLuSTqWibqrANMD8iVpUSImKlpPmkrur1jI7vuJnl3gh+xNeUPNagrgL2kVQ+oeFhwDLgxhrnPQK8QdL4UoKkCcAbqDHGSdIkUs/BO9sos5lZ53RowcKiy2OAOhtYAVwsae+sDWg2cFp513NJD0r6Ydl5PwBeC1wi6QBJ/wRcCmwIzMnOmSbpZkn/KmkvSYcB1wMbkab5MDPrs47NxVd4uXvEFxEDkvYCvgtcTmp3Op0UpMqNo2xlxoi4U9K+wL8DP8mS7wXeERHzsv0VwNOkGSk2AJYDtwC7R8QdXbkhM7NmlNqgck7SYLdfI3cBCiAi7gP2rJNnsyppvwF+U+Oc5bQwH1TJzAmLuWCL61o9vSlDXRroMBi9G0Ax1IVmvW69L9UM9vCv1G68V7UM9rnJtZf328vvI6RHNu0qSBtUKxMgNHVjuQxQZmajWgECVER0vYnIAcrMLE8C6MByGyOBA5SZWa4EFHCuvW5wgDIzy5sCPOKT1NIjvojGG8IdoMzM8qQ4j/hW1c+yhqCJuOMAZWaWKwE97G3bhr/SeK+8KaQVe5viAGVmlicBDOY/QDWyYKGktYBPA1/OkhY28xp5nEnCzGx0GwEzSUg6FLgf+BZpzNQXgNc3cw3XoMzM8qYAAWg4knYBTgXeQlrR/D+BkyJioNlrOUCZmeVKMWpIlSRtCXwDOIhUY7oQOD4i/tLqNR2gzMzyJIDBrk9z1zGSZpDmQP1XYDxpftPPR8St7V7bAcrMLG8KUIPKljb6N+CLpAVlHyLVmC7q1Gs4QJmZ5UoUZRzUn4BNgEWkQHVmRHS06ucAZWaWJwFNTLbQT5uSHkgKOBY4Vqo7wXlExKaNvoADlJlZ3hRgHFRGwIxs6zgHKDOzPIliTBbr5TbMzEajAnSS6AUHKDOznIkC1KB6IZdTHUnaVtJvJL0o6XFJJ0ka28B5O0m6RtKzkhZJuk7SW6vkO1DSvZKWS7pP0mHduRMzsyZFpDaoetsokLsAJWk6cB2pd8iBwEnA54Gv1jlv4+y8ccCHgA9mX18jadOyfLsCFwHXA/sBVwDnSXpnx2/GzKwVMVR/GwXy+Ijv48Ak4OCIWAxcK2kqMFvSKVlaNQcA62TnPQcg6XfAM8D+wFlZvhOBmyLimGz/eknbAV8BrunKHZmZNSiAKMY4qK7LXQ2KVKu5uiIQnU8KWrvXOG8t0sSES8rSlmRpApA0AdgD+EXFuecDO0ua1l7RzczaFOEaVCaPAWobYEF5QkQ8CryYHRvORVmeUyVtIGkD4HRgALggyzOTFMgWVJx7P+m92Lrt0puZtSkGB+tuo0EeH/FNB56rkj6QHasqIh6XtAfwK6D0+O4JYJ+IeLrs2lS5/kDF8ZdImgXMynZXjN3wz3+sewfFtD7pcehI4/sqlpFwXw3PlFDNCwxcfV1cuH4DWYv+PtWVxwAF1ZcR1jDp6aC0IWl69zuBo7LkTwJXSNolq4UNd30Nk05EzAHmZK9xR0Ts1NAdFMxIvTffV7GM1PtqRkTs2+8y5EUeA9QAsG6V9GlUr1mVHEe6n0MiYhWApN8CfybNE3UML9eUKq9f2q91fTMz66E8tkEtoKKtKetCPpk1247KbQPMLwUngIhYCcwntT1Bmg5+VeX1s/0h4IG2Sm5mZh2TxwB1FbCPpHXK0g4DlgE31jjvEeAN2RolwEu99t4ALASIiBWk8U+HVpx7GHBLRDxfp2xzGrmBghqp9+b7KpaRel/WAkXO5nzKBureB/wR+CawBXAa8O2IOKEs34PAjRFxZLb/ZuBW0lim75HalT4J7A3sFBHzsny7AjcA3wUuJY2ROhbYNyI8DsrMLCdyV4OKiAFgL2AscDlpBonTSUsKlxuX5SmddyewL2mw7k+Ac4G1gXeUglOWby5wCClwXQ38M3C4g5OZWb7krgZlZmYGOaxB5VGrk9fmnaQtJX1f0jxJg5Ju6HeZ2iXpUEm/lPSYpCWS7pT0vn6Xq12SDpH0u2wi5OWS/iTphPI215FA0kbZ9y0kTel3eay/8tjNPFfKJq+9jzR57UzgVFJwP6HGqUWwHakN7lZgpPyi+xzwMPBZXp6H8WeS1o+IM/pasvasR+rg8y3ScIi3ALOB1wCf6l+xOu5bpCnKJve7INZ/fsRXh6QvAl8ANi3NDyjpC2S/HGpMXpt7ksZEpEm9JF0IrB8Rb+9vqdqTBaJnKtJ+BuwcEZv3qVhdIek/SB2BpscI+EGWtBtwGfB1UqBaJyKW1D7LRjI/4quv1clrc68UnEaSyuCUuRvYoNdl6YFnGSE13+yR+Rmk5XVG/BQ+1hgHqPpanbzW8mMX0iPawpM0VtLa2XCJY4CzRkLtibTMzkTgzH4XxPLDbVD1tTR5reWDpL1IbYcf7XdZOmQpMCH7+lzSFF+FJmk94GTgAxGxSlK9U2yUcA2qMU1PXmv9J2kz4GfAZRFxTl8L0zm7ALuRVpk+kDTgvOj+A7gtIq7sd0EsX1yDqq/VyWutjyTNIE2b9SjwgT4Xp2Mi4q7sy7mSngH+n6RTI+KhfparVdlq1h8F/pek0s/Z2tn/0yQNRsSy/pTO+s0Bqr5WJ6+1PpG0NmldsPHAARGxtM9F6pZSsNqcNBFyEW1FWkT0lirH/gb8kJeXz7FRxgGqvquA4yStExEvZGmNTF5rfSBpHGkF5a2At0XEU30uUje9Lfv/4b6Woj1zgT0q0vYF/jdpDNtfel4iyw0HqPrOJvWWulhSafLa2cBpRR4DBS/VNPbPdjcCpko6JNu/MiJe7E/J2vI90j19Bpgh6R/Ljt2dzWhfOJJ+TRowPh8YJAWnzwM/L+rjPXhpWMAN5WlZ2yHAzR4HNbp5oG4DJG1LaozemdTu9ANgdkQM9rVgbcp+EQz31/fmEbGwZ4XpEEkLGX7J7ULeE4Ckk4GDgM2A1aSaxY+Bs8vXQBsJJB1BujcP1B3lHKDMzCyX3M3czMxyyQHKzMxyyQHKzMxyyQHKzMxyyQHKzMxyyQHKzMxyyQHKzMxyyQHKzMxyyQHKzMxyyQHKrEGSbpQUkk6qkefULM8ve1k2s5HIAcqsAUrLvO6Q7d5VI+uO2f93d7dEZiOfA5RZY2YCU7Ov76yRrxTEHKDM2uQAZdaYN2X/PxMRf62WQdJMXl59uVYty8wa4ABl1pjSo7tatadSEHs2Ih7tcnnMRjwHKLPGlIKP25/MesQByqwxpQBVqwblAGXWQQ5QZnVI2gjYINutVYNqpJZlZg1ygDKrr1Qzej4iHq6WIesgUQpirkGZdYADlFl9pZrRkzXyHJb9vwT4c3eLYzY6OECZ1VeqQb1O0sTKg5I2A47Ldu+JiKEelctsRHOAMquvVINaG/iJpE0BJE2R9C/AXF4e/7RK0jRJ0/pQTrMRRRHR7zKY5Zak9YBnst3LgXdlX68C1sq+vg0YAnbO9gN4TUQ81atymo1ErkGZ1VaqPS0H3gt8DfgrKQg9BHwd2BM4CXg6277v4GTWPtegzGqQ9AXgm8DvI+It/S6P2WjiGpRZbaUalLuOm/WYA5RZbaUefH/oaynMRiEHKLNhSJoCbJntugZl1mMOUGbD2570MzIE3NPnspiNOu4kYWZmueQalJmZ5ZIDlJmZ5ZIDlJmZ5ZIDlJmZ5ZIDlJmZ5ZIDlJmZ5ZIDlJmZ5dL/B8mFbwPT6lIWAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_down_systUp, dataName=\"SystUp\", clfName=\"Down\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_down_systUp = nll2D_down_systUp.min(axis=1)\n",
    "nll1D_down_systDown = nll2D_down_systDown.min(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clf trained on SystUp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.8.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.84.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.88.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.89.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.9.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.91.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.92.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.93.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.94.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.95.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.96.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.97.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.98.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.99.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.0.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.01.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.02.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.03.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.04.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.05.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.06.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.07.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.08.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.09.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.1.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.11.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.12.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.13.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.14.h5\n"
     ]
    }
   ],
   "source": [
    "if not loadAndPlot:\n",
    "    sig_hists_up, back_hists_up = buildTemplates(model=up_model, clfName=\"Up\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_up, bin_array = createHistObs(X=X_syst_test_nominal[nominalEvents],\n",
    "                                           Y_true=Y_syst_test_nominal[nominalEvents],\n",
    "                                           weights=weights_test_nominal[nominalEvents], mu=mu_test,\n",
    "              model=up_model)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/UpSignalTemplates.npy\", sig_hists_up)\n",
    "    np.save(\"HiggsModels/UpBackgroundTemplates.npy\", back_hists_up)\n",
    "    np.save(\"HiggsModels/hist_obs_Up.npy\", hist_obs_up)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sig_hists_up = np.load(\"HiggsModels/UpSignalTemplates.npy\", )\n",
    "back_hists_up = np.load(\"HiggsModels/UpBackgroundTemplates.npy\", )\n",
    "hist_obs_up = np.load(\"HiggsModels/hist_obs_Up.npy\", )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.0\n"
     ]
    }
   ],
   "source": [
    "nll2D_up_nom = computeNLL2D(obs1D=hist_obs_up, sH2d=sig_hists_up, bH2d=back_hists_up)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_up_nom, dataName=\"Nominal\", clfName=\"Up\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_up_nom = nll2D_up_nom.min(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_up_systUp, bin_array = createHistObs(X=X_syst_test_systUp[systUpEvents],\n",
    "                                                  Y_true=Y_syst_test_systUp[systUpEvents],\n",
    "                                                  weights=weights_test_systUp[systUpEvents], mu=mu_test, \n",
    "              model=up_model)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/hist_obs_up_systUp.npy\", hist_obs_up_systUp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist_obs_up_systUp = np.load(\"HiggsModels/hist_obs_up_systUp.npy\", )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.1\n"
     ]
    }
   ],
   "source": [
    "nll2D_up_systUp = computeNLL2D(obs1D=hist_obs_up_systUp, sH2d=sig_hists_up, bH2d=back_hists_up)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_up_systUp, dataName=\"SystUp\", clfName=\"Up\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_up_systUp = nll2D_up_systUp.min(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Syst Aware classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.8.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.84.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.88.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.89.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.9.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.91.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.92.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.93.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.94.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.95.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.96.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.97.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.98.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.99.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.0.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.01.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.02.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.03.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.04.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.05.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.06.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.07.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.08.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.09.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.1.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.11.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.12.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.13.h5\n",
      "Not Currently Supported for analyticial aware classifier\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.14.h5\n",
      "Not Currently Supported for analyticial aware classifier\n"
     ]
    }
   ],
   "source": [
    "if not loadAndPlot:\n",
    "    sig_hists_awe, back_hists_awe = buildTemplates(model=aware_model, clfName=\"Aware\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createHistObsAwe(X,Y_true, mu, weights):\n",
    "    weights[Y_true==1] *= mu\n",
    "    hist_obs_awe2D = []\n",
    "    for hyp_z in z_syst:\n",
    "        #FixMe calling predict multiple times is very slow, try doing it just once or JIT?\n",
    "        Y = aware_model.predict([X, np.ones(X.shape[0]) * hyp_z], batch_size=batch_size).reshape(-1)\n",
    "        hist_obs_awe, bin_array = np.histogram(Y, weights=weights, range=(0,1), bins=nBins)\n",
    "        hist_obs_awe2D.append(hist_obs_awe)\n",
    "    hist_obs_awe2D = np.array(hist_obs_awe2D)\n",
    "    return hist_obs_awe2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_awe2D = createHistObsAwe(X=X_syst_test_nominal[nominalEvents],\n",
    "                                      Y_true=Y_syst_test_nominal[nominalEvents],\n",
    "                                      mu=mu_test,\n",
    "                                      weights=weights_test_nominal[nominalEvents])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/AwareSignalTemplates.npy\", sig_hists_awe)\n",
    "    np.save(\"HiggsModels/AwareBackgroundTemplates.npy\", back_hists_awe)\n",
    "    np.save(\"HiggsModels/hist_obs_awe2D.npy\", hist_obs_awe2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sig_hists_awe = np.load(\"HiggsModels/AwareSignalTemplates.npy\")\n",
    "back_hists_awe = np.load(\"HiggsModels/AwareBackgroundTemplates.npy\")\n",
    "hist_obs_awe2D = np.load(\"HiggsModels/hist_obs_awe2D.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeNLL2D_aware(obs2D, sH2d, bH2d, mu_values=mu_values):\n",
    "    min_mu, min_z, minnll = 999,999,999\n",
    "    assert obs2D.shape[1] == sH2d.shape[1] == bH2d.shape[1]\n",
    "    nll2D = np.zeros(mu_values.shape[0] * sH2d.shape[0]).reshape(mu_values.shape[0],sH2d.shape[0])\n",
    "    for i, z_val in enumerate(z_syst):\n",
    "        for k,mu in enumerate(mu_values):\n",
    "            nll2D[k][i] += nll_syst(dTheta=z_val-z_nominal, sigma=z_std)\n",
    "            for n,s,b in zip(obs2D[i], sH2d[i], bH2d[i]): # over the bins of score histo\n",
    "                bin_nll = nll_stat(N=n,S=s,B=b,mu=mu)\n",
    "                if (not np.isnan(bin_nll)):\n",
    "                    nll2D[k][i] += bin_nll\n",
    "            if nll2D[k][i] < minnll:\n",
    "                minnll = nll2D[k][i]\n",
    "                min_mu = mu\n",
    "                min_z = z_val\n",
    "    print (\"Min at mu,z: \",min_mu, min_z)\n",
    "    return nll2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.0\n"
     ]
    }
   ],
   "source": [
    "nll2D_awe_nom = computeNLL2D_aware(obs2D=hist_obs_awe2D, sH2d=sig_hists_awe, bH2d=back_hists_awe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_awe_nom, dataName=\"Nominal\", clfName=\"Awe\")\n",
    "#plt.savefig(plotDir + \"TwoD_NLL_{}_{}.pdf\".format(\"Awe\", \"Nominal\",))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_awe_nom = nll2D_awe_nom.min(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_awe2D_systUp = createHistObsAwe(X=X_syst_test_systUp[systUpEvents], \n",
    "                                             Y_true=Y_syst_test_systUp[systUpEvents], mu=mu_test,\n",
    "                            weights=weights_test_systUp[systUpEvents])\n",
    "    hist_obs_awe2D_systDown = createHistObsAwe(X=X_syst_test_systDown[systDownEvents], \n",
    "                                            Y_true=Y_syst_test_systDown[systDownEvents], mu=mu_test,   \n",
    "                            weights=weights_test_systDown[systDownEvents])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/hist_obs_awe2D_systUp.npy\", hist_obs_awe2D_systUp)\n",
    "    np.save(\"HiggsModels/hist_obs_awe2D_systDown.npy\", hist_obs_awe2D_systDown)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist_obs_awe2D_systUp = np.load(\"HiggsModels/hist_obs_awe2D_systUp.npy\")\n",
    "hist_obs_awe2D_systDown = np.load(\"HiggsModels/hist_obs_awe2D_systDown.npy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.1\n",
      "Min at mu,z:  1.0 0.8\n"
     ]
    }
   ],
   "source": [
    "nll2D_awe_systUp = computeNLL2D_aware(obs2D=hist_obs_awe2D_systUp, sH2d=sig_hists_awe, bH2d=back_hists_awe)\n",
    "nll2D_awe_systDown = computeNLL2D_aware(obs2D=hist_obs_awe2D_systDown, sH2d=sig_hists_awe, bH2d=back_hists_awe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_awe_systUp, dataName=\"SystUp\", clfName=\"Awe\")\n",
    "#plt.savefig(plotDir + \"TwoD_NLL_{}_{}.pdf\".format(\"Awe\", \"SystUp\",))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_awe_systUp = nll2D_awe_systUp.min(axis=1)\n",
    "nll1D_awe_systDown = nll2D_awe_systDown.min(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adversarially trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.8.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.84.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.88.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.89.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.9.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.91.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.92.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.93.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.94.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.95.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.96.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.97.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.98.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_0.99.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.0.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.01.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.02.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.03.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.04.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.05.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.06.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.07.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.08.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.09.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.1.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.11.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.12.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.13.h5\n",
      "Loading file:  /data1/users/aishik/systcovariant_data/HiggsML_TES_1.14.h5\n"
     ]
    }
   ],
   "source": [
    "if not loadAndPlot:\n",
    "    sig_hists_inv, back_hists_inv = buildTemplates(model=inv_model, clfName=\"Invariant\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_inv, bin_array = createHistObs(X=X_syst_test_nominal[nominalEvents],\n",
    "                                            Y_true=Y_syst_test_nominal[nominalEvents],\n",
    "                                            mu=mu_test,\n",
    "                                            weights=weights_test_nominal[nominalEvents], \n",
    "              model=inv_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/InvSignalTemplates.npy\", sig_hists_inv)\n",
    "    np.save(\"HiggsModels/InvBackgroundTemplates.npy\", back_hists_inv)\n",
    "    np.save(\"HiggsModels/hist_obs_Inv.npy\", hist_obs_inv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sig_hists_inv = np.load(\"HiggsModels/InvSignalTemplates.npy\", )\n",
    "back_hists_inv = np.load(\"HiggsModels/InvBackgroundTemplates.npy\", )\n",
    "hist_obs_inv = np.load(\"HiggsModels/hist_obs_Inv.npy\", )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.0\n"
     ]
    }
   ],
   "source": [
    "nll2D_inv_nom = computeNLL2D(obs1D=hist_obs_inv, sH2d=sig_hists_inv, bH2d=back_hists_inv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_inv_nom, dataName=\"Nominal\", clfName=\"Inv\")\n",
    "#plt.savefig(plotDir + \"TwoD_NLL_{}_{}.pdf\".format(\"Inv\", \"Nominal\",))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "nll1D_inv_nom = nll2D_inv_nom.min(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/ipykernel_launcher.py:27: RuntimeWarning: invalid value encountered in true_divide\n",
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/ipykernel_launcher.py:33: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if mu_test==1:\n",
    "    xlim = [0.5,1.5] # mu=1 study\n",
    "elif mu_test==2:\n",
    "    xlim = [1.5,2.5] # mu=2 study\n",
    "else:\n",
    "    print(\"Unexpected mu value\")\n",
    "plotNLLCurves(x=mu_values, \n",
    "              y_list=[nll1D_aug_nom-nll1D_aug_nom.min(), nll1D_awe_nom-nll1D_awe_nom.min(), \n",
    "                      nll1D_inv_nom-nll1D_inv_nom.min(), nll1D_clf_nom-nll1D_clf_nom.min()],\n",
    "                label_list=[\"Data Augmentation\", \"Uncertainty Aware\", \"Adversarial\",\"Baseline\", ], \n",
    "                color_list=[augCol, aweCol, invCol,clfCol,], \n",
    "                linestyle_list=[\"solid\", \"solid\", \"solid\", \"dotted\", ], \n",
    "              testDataLabel = \"Nominal\", ylimRatio=[0.75, 1.25], xlim=xlim,\n",
    "              legendOrder=[3,1,2,0])\n",
    "#plt.savefig(plotDir + \"NLL_all_on_nominal.pdf\", bbox_inches='tight',pad_inches = 0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadAndPlot:\n",
    "    hist_obs_inv_systUp, bin_array = createHistObs(X=X_syst_test_systUp[systUpEvents],\n",
    "                                                   Y_true=Y_syst_test_systUp[systUpEvents],\n",
    "                                                   mu=mu_test,\n",
    "                                                   weights=weights_test_systUp[systUpEvents], \n",
    "              model=inv_model)\n",
    "    hist_obs_inv_systDown, bin_array = createHistObs(X=X_syst_test_systDown[systDownEvents],\n",
    "                                                     Y_true=Y_syst_test_systDown[systDownEvents],\n",
    "                                                     mu=mu_test,\n",
    "                                                      weights=weights_test_systDown[systDownEvents], \n",
    "              model=inv_model)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if not loadAndPlot:\n",
    "    np.save(\"HiggsModels/hist_obs_inv_systUp.npy\", hist_obs_inv_systUp)\n",
    "    np.save(\"HiggsModels/hist_obs_inv_systDown.npy\", hist_obs_inv_systDown)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist_obs_inv_systUp = np.load(\"HiggsModels/hist_obs_inv_systUp.npy\", )\n",
    "hist_obs_inv_systDown = np.load(\"HiggsModels/hist_obs_inv_systDown.npy\", )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min at mu,z:  1.0 1.1\n",
      "Min at mu,z:  1.0 0.8\n"
     ]
    }
   ],
   "source": [
    "nll2D_inv_systUp = computeNLL2D(obs1D=hist_obs_inv_systUp, sH2d=sig_hists_inv, bH2d=back_hists_inv)\n",
    "nll2D_inv_systDown = computeNLL2D(obs1D=hist_obs_inv_systDown, sH2d=sig_hists_inv, bH2d=back_hists_inv)\n",
    "\n",
    "nll1D_inv_systUp = nll2D_inv_systUp.min(axis=1)\n",
    "nll1D_inv_systDown = nll2D_inv_systDown.min(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot2dNLL(nll2D=nll2D_inv_systUp, dataName=\"SystUp\", clfName=\"Inv\") \n",
    "#plt.savefig(plotDir + \"TwoD_NLL_{}_{}.pdf\".format(\"Inv\", \"SystUp\",))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/ipykernel_launcher.py:27: RuntimeWarning: invalid value encountered in true_divide\n",
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/ipykernel_launcher.py:33: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotNLLCurves(x=mu_values, \n",
    "              y_list=[nll1D_clf_systUp-nll1D_clf_systUp.min(), nll1D_aug_systUp-nll1D_aug_systUp.min(),\n",
    "                      nll1D_awe_systUp-nll1D_awe_systUp.min(), nll1D_inv_systUp-nll1D_inv_systUp.min(),\n",
    "                      nll1D_up_systUp-nll1D_up_systUp.min()],\n",
    "                label_list=[ \"Baseline\", \"Data Augmentation\", \"Uncertainty Aware\", \"Adversarial\", \"Trained on true Z\" ], \n",
    "                color_list=[clfCol, augCol, aweCol,  invCol, clfNomCol], \n",
    "                linestyle_list=[\"solid\", \"solid\", \"solid\", \"solid\", \"dotted\"], \n",
    "              testDataLabel = \"systUp\", ylimRatio=[0.75, 1.25], xlim=xlim,\n",
    "             legendOrder=[4,2,0,3,1]) # legend order tells you which plot should come first, then next, next, ...\n",
    "#plt.savefig(plotDir + \"NLL_all_on_systUp.pdf\", bbox_inches='tight',pad_inches = 0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/ipykernel_launcher.py:27: RuntimeWarning: invalid value encountered in true_divide\n",
      "/opt/anaconda3/envs/shared_env/lib/python3.6/site-packages/ipykernel_launcher.py:33: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotNLLCurves(x=mu_values, \n",
    "              y_list=[nll1D_clf_systDown-nll1D_clf_systDown.min(), nll1D_aug_systDown-nll1D_aug_systDown.min(),\n",
    "                      nll1D_awe_systDown-nll1D_awe_systDown.min(), nll1D_inv_systDown-nll1D_inv_systDown.min(),\n",
    "                      nll1D_down_systDown-nll1D_down_systDown.min()],\n",
    "                label_list=[ \"Baseline\", \"Data Augmentation\", \"Uncertainty Aware\", \"Adversarial\", \"Trained on true Z\" ],\n",
    "                color_list=[ clfCol, augCol, aweCol, invCol, clfNomCol,], \n",
    "                linestyle_list=[\"solid\", \"solid\", \"solid\", \"solid\", \"dotted\" ],\n",
    "              testDataLabel = \"systDown\", ylimRatio=[0.74, 1.26], xlim=xlim,\n",
    "             legendOrder=[4,2,0,3,1])\n",
    "#plt.savefig(plotDir + \"NLL_all_on_systDown.pdf\", bbox_inches='tight',pad_inches = 0)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.6.5"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}