diff --git a/analysis_and_scripts/Analysis_07MAY2019_new.ipynb b/analysis_and_scripts/Analysis_07MAY2019_new.ipynb
index 1a2c6bc51ffa9fadc70fa436e21ad662711e14d9..eb0de96a6c4154b5e6e1f5c589c3621c35506a77 100644
--- a/analysis_and_scripts/Analysis_07MAY2019_new.ipynb
+++ b/analysis_and_scripts/Analysis_07MAY2019_new.ipynb
@@ -56,7 +56,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 78,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -127,14 +127,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 90,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [],
    "source": [
     "def sigmoid(x):\n",
     "    '''Return value of sigmoid function (inverse of logit) at x.'''\n",
     "\n",
-    "    return 1 / (1 + np.exp(-x))\n",
+    "    return 1 / (1 + np.exp(-1*x))\n",
     "\n",
     "\n",
     "def dataWithUnobservables(nJudges_M=100,\n",
@@ -166,7 +166,7 @@
     "    df = df.assign(probabilities_Y=probabilities_Y)\n",
     "\n",
     "    # Result is 0 if P(Y = 0| X = x; Z = z; W = w) >= 0.5 , 1 otherwise\n",
-    "    df = df.assign(result_Y=np.where(probabilities_Y >= 0.5, 0, 1))\n",
+    "    df = df.assign(result_Y=np.where(df.probabilities_Y >= 0.5, 0, 1))\n",
     "\n",
     "    # For the conditional probabilities of T we add noise ~ N(0, 0.1)\n",
     "    probabilities_T = sigmoid(beta_X * df.X + beta_Z * df.Z)\n",
@@ -180,10 +180,11 @@
     "                   ascending=False,\n",
     "                   inplace=True)\n",
     "\n",
-    "    # Iterate over the data. Subject is in the top (1-r)*100% if\n",
-    "    # his within-judge-index is over acceptance threshold times\n",
-    "    # the number of subjects assigned to each judge. If subject\n",
-    "    # is over the limit they are assigned a zero, else one.\n",
+    "    # Iterate over the data. Subject will be given a negative decision\n",
+    "    # if they are in the top (1-r)*100% of the individuals the judge will judge.\n",
+    "    # I.e. if their within-judge-index is under 1 - acceptance threshold times\n",
+    "    # the number of subjects assigned to each judge they will receive a\n",
+    "    # negative decision.\n",
     "    df.reset_index(drop=True, inplace=True)\n",
     "\n",
     "    df['decision_T'] = np.where((df.index.values % nSubjects_N) <\n",
@@ -229,11 +230,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 80,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def dataWithoutUnobservables(nJudges_M=100, nSubjects_N=500, beta_X=1.0):\n",
+    "def dataWithoutUnobservables(nJudges_M=100,\n",
+    "                             nSubjects_N=500,\n",
+    "                             sigma=0.0):\n",
     "\n",
     "    df = pd.DataFrame()\n",
     "\n",
@@ -251,11 +254,10 @@
     "    df = df.assign(X=npr.normal(size=nJudges_M * nSubjects_N))\n",
     "\n",
     "    # Calculate P(Y=1|X=x) = 1 / (1 + exp(-beta_X * x)) = sigmoid(beta_X * x)\n",
-    "    df = df.assign(probabilities_Y=sigmoid(beta_X * df.X))\n",
+    "    df = df.assign(probabilities_Y=sigmoid(df.X))\n",
     "\n",
     "    # Draw Y ~ Bernoulli(sigmoid(beta_X * x)) = Bin(1, p)\n",
-    "    results = npr.binomial(n=1,\n",
-    "                           p=df.probabilities_Y,\n",
+    "    results = npr.binomial(n=1, p=df.probabilities_Y,\n",
     "                           size=nJudges_M * nSubjects_N)\n",
     "\n",
     "    df = df.assign(result_Y=results)\n",
@@ -263,9 +265,15 @@
     "    # Invert the probabilities. P(Y=0 | X) = 1 - P(Y=1 | X)\n",
     "    df.probabilities_Y = 1 - df.probabilities_Y\n",
     "\n",
+    "    # Assign the prediction probabilities and add some Gaussian noise\n",
+    "    # if sigma is set to != 0.\n",
+    "    df = df.assign(probabilities_T=df.probabilities_Y)\n",
+    "\n",
+    "    df.probabilities_T += npr.normal(size=nJudges_M * nSubjects_N) * sigma\n",
+    "\n",
     "    # Sort by judges then probabilities in decreasing order\n",
     "    # I.e. the most dangerous for each judge are first.\n",
-    "    df.sort_values(by=[\"judgeID_J\", \"probabilities_Y\"],\n",
+    "    df.sort_values(by=[\"judgeID_J\", \"probabilities_T\"],\n",
     "                   ascending=False,\n",
     "                   inplace=True)\n",
     "\n",
@@ -305,7 +313,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 81,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -395,18 +403,18 @@
     "* Overall: this kind of defendant $(X=x)$ is usually in the $z^{th}$ percentile in dangerousness (sd +- $u$ percentiles). Now, what is the probability that this defendant has $z \\leq 1-r$?\n",
     "\n",
     "\n",
-    "**Proposal**\n",
+    "<!--- **Proposal**\n",
     "\n",
     "1. Train model for $P(Y=0|T=1, X=x)$\n",
     "* Estimate quantile function for $P(T=1|R=r, X=x)$\n",
     "* Calculate $P(Y=0|do(r'), do(x'))=P(Y=0|T=1, X=x') \\cdot P(T=1|R=r', X=x')$ for all instances of the training data\n",
     "* Order in ascending order based on the probabilities obtained from previous step\n",
-    "* Calculate $$\\dfrac{\\sum_{i=0}^{r\\cdot |\\mathcal{D}_{all}|}}{|\\mathcal{D}_{all}|}$$"
+    "* Calculate $$\\dfrac{\\sum_{i=0}^{r\\cdot |\\mathcal{D}_{all}|}}{|\\mathcal{D}_{all}|}$$--->"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 171,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -476,7 +484,7 @@
     "    (2) Calculate recidivism probabilities from test set with the trained \n",
     "        model and assign them to predictions_test.\n",
     "\n",
-    "    (3) Construct a cumulative distribution function of the probabilities in\n",
+    "    (3) Construct a quantile function of the probabilities in\n",
     "        in predictions_train.\n",
     "\n",
     "    (4)\n",
@@ -492,16 +500,17 @@
     "    (1) Boolean list indicating a bail decision (bail = True).\n",
     "    '''\n",
     "\n",
-    "    predictions_train = y_model.predict_proba(x_train)[:, 0]\n",
+    "    predictions_train = getProbabilityForClass(x_train, y_model, 0)\n",
     "\n",
-    "    predictions_test = y_model.predict_proba(x_test)[:, 0]\n",
+    "    predictions_test = getProbabilityForClass(x_test, y_model, 0)\n",
     "\n",
     "    return [\n",
     "        scs.percentileofscore(predictions_train, pred, kind='weak') < r\n",
     "        for pred in predictions_test\n",
     "    ]\n",
     "\n",
-    "def estimatePercentiles(x_train, y_model, N_bootstraps = 2000, N_sample = 100):\n",
+    "\n",
+    "def estimatePercentiles(x_train, y_model, N_bootstraps=2000, N_sample=100):\n",
     "\n",
     "    res = np.zeros((N_bootstraps, 101))\n",
     "\n",
@@ -511,30 +520,45 @@
     "\n",
     "        sample = npr.choice(x_train, size=N_sample)\n",
     "\n",
-    "        predictions_sample = y_model.predict_proba(sample.reshape(-1, 1))[:, 0]\n",
+    "        predictions_sample = getProbabilityForClass(sample, y_model, 0)\n",
     "\n",
     "        res[i, :] = np.percentile(predictions_sample, percs)\n",
-    "    \n",
+    "\n",
     "    return res\n",
     "\n",
-    "def calcReleaseProbabilities(r, x_train, x_test, y_model, N_bootstraps = 2000, N_sample = 100):\n",
-    "    \n",
-    "    percentileMatrix = estimatePercentiles(x_train, y_model, N_bootstraps, N_sample)\n",
+    "\n",
+    "def calcReleaseProbabilities(r,\n",
+    "                             x_train,\n",
+    "                             x_test,\n",
+    "                             y_model,\n",
+    "                             N_bootstraps=2000,\n",
+    "                             N_sample=100,\n",
+    "                             percentileMatrix=None):\n",
+    "    '''\n",
+    "    Similar to bailIndicator, but calculates probabilities for bail decisions by\n",
+    "    bootstrapping the data set.\n",
     "    \n",
+    "    Returns probabilities for positive bail decisions.\n",
+    "    '''\n",
+    "\n",
+    "    if percentileMatrix is None:\n",
+    "        percentileMatrix = estimatePercentiles(x_train, y_model, N_bootstraps,\n",
+    "                                               N_sample)\n",
+    "\n",
     "    probs = np.zeros(len(x_test))\n",
-    "    \n",
+    "\n",
     "    for i in range(len(x_test)):\n",
-    "        \n",
-    "        if np.isnan(x_test.iloc[i]):\n",
-    "            \n",
+    "\n",
+    "        if np.isnan(x_test[i]):\n",
+    "\n",
     "            probs[i] = np.nan\n",
-    "        \n",
+    "\n",
     "        else:\n",
-    "            \n",
-    "            pred = y_model.predict_proba(x_test.iloc[i].reshape(-1, 1))[:, 0]\n",
-    "            \n",
+    "\n",
+    "            pred = getProbabilityForClass(x_test[i], y_model, 0)\n",
+    "\n",
     "            probs[i] = np.mean(pred < percentileMatrix[:, r])\n",
-    "    \n",
+    "\n",
     "    return probs"
    ]
   },
@@ -549,7 +573,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 83,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -575,13 +599,9 @@
     "    else:\n",
     "        logreg = logreg.fit(x_train, y_train)\n",
     "\n",
-    "    # Check shape and predict probabilities.\n",
-    "    if x_test.ndim == 1:\n",
-    "        label_probs_logreg = logreg.predict_proba(x_test.values.reshape(-1, 1))\n",
-    "    else:\n",
-    "        label_probs_logreg = logreg.predict_proba(x_test)\n",
-    "\n",
-    "    return logreg, label_probs_logreg[:, logreg.classes_ == class_value]"
+    "    label_probs_logreg = getProbabilityForClass(x_test, logreg, class_value)\n",
+    "    \n",
+    "    return logreg, label_probs_logreg"
    ]
   },
   {
@@ -595,316 +615,1058 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 181,
+   "execution_count": 51,
    "metadata": {
-    "scrolled": false
+    "scrolled": true
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[1] 0 0.022851848992511387\n",
-      "1 0.020483237187526128\n",
-      "2 0.020183055620746303\n",
-      "3 0.019329788132016544\n",
-      "[2] 0 0.03898668956633748\n",
-      "1 0.04764082628249104\n",
-      "2 0.0431119109947644\n",
-      "3 0.04408070041872859\n",
-      "[3] 0 0.06064179230186137\n",
-      "1 0.06360252468036899\n",
-      "2 0.05671407381554838\n",
-      "3 0.057218838466157676\n",
-      "[4] 0 0.08984014755610206\n",
-      "1 0.08711111111111111\n",
-      "2 0.08695652173913043\n",
-      "3 0.07842291433008368\n",
-      "[5] 0 0.09515710321367828\n",
-      "1 0.10039618983393746\n",
-      "2 0.11445735514979052\n",
-      "3 0.1222790804246544\n",
-      "[6] 0 0.1348079161816065\n",
-      "1 0.12643868510391654\n",
-      "2 0.13631531605200753\n",
-      "3 0.13512183115924195\n",
-      "[7] 0 0.1121176003178387\n",
-      "1 0.10733437121605259\n",
-      "2 0.10501029512697323\n",
-      "3 0.11925484806840739\n",
-      "[8] 0 0.11128836219993923\n",
-      "1 0.10011105822624147\n",
-      "2 0.09712027103331451\n",
-      "3 0.09841954022988506\n"
+      "[1] 0 "
      ]
     },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1008x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[[0.0053     0.00223    0.0117193  0.00503199 0.02071198]\n",
-      " [0.02127    0.00856    0.02685033 0.0236414  0.04345503]\n",
-      " [0.04612    0.01693    0.05093109 0.04188843 0.05954431]\n",
-      " [0.08189    0.03066    0.08607569 0.08402928 0.08558267]\n",
-      " [0.12602    0.04614    0.13164032 0.11320835 0.10807243]\n",
-      " [0.18107    0.06512    0.18510231 0.15827246 0.13317094]\n",
-      " [0.24572    0.08419    0.24934794 0.23819695 0.11092928]\n",
-      " [0.32125    0.11177    0.32030183 0.30027443 0.10173481]]\n"
+      "1 "
      ]
-    }
-   ],
-   "source": [
-    "failure_rates = np.zeros((8, 5))\n",
-    "failure_sems = np.zeros((8, 5))\n",
-    "\n",
-    "nIter = 4\n",
-    "\n",
-    "for r in np.arange(1, 9):\n",
-    "\n",
-    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
-    "\n",
-    "    f_rate_true = np.zeros(nIter)\n",
-    "    f_rate_label = np.zeros(nIter)\n",
-    "    f_rate_human = np.zeros(nIter)\n",
-    "    f_rate_cont = np.zeros(nIter)\n",
-    "    f_rate_caus = np.zeros(nIter)\n",
-    "\n",
-    "    for i in range(nIter):\n",
-    "\n",
-    "        print(i, end=\" \")\n",
-    "\n",
-    "        # Create data\n",
-    "        train_labeled, train, test_labeled, test, df = dataWithUnobservables()\n",
-    "\n",
-    "        # Fit model and calculate predictions\n",
-    "        logreg, predictions = fitLogisticRegression(\n",
-    "            train_labeled.dropna().X,\n",
-    "            train_labeled.dropna().result_Y, test.X, 0)\n",
-    "\n",
-    "        # Attach the predictions to data\n",
-    "        test = test.assign(B_prob_0_logreg=predictions)\n",
-    "\n",
-    "        logreg, predictions_labeled = fitLogisticRegression(\n",
-    "            train_labeled.dropna().X,\n",
-    "            train_labeled.dropna().result_Y, test_labeled.X, 0)\n",
-    "\n",
-    "        test_labeled = test_labeled.assign(B_prob_0_logreg=predictions_labeled)\n",
-    "\n",
-    "        # True evaluation\n",
-    "        #\n",
-    "        # Sort by failure probabilities, subjects with the smallest risk are first.\n",
-    "        test.sort_values(by='B_prob_0_logreg', inplace=True, ascending=True)\n",
-    "\n",
-    "        to_release = int(round(test.shape[0] * r / 10))\n",
-    "\n",
-    "        # Calculate failure rate as the ratio of failures to those who were given a\n",
-    "        # positive decision, i.e. those whose probability of negative outcome was\n",
-    "        # low enough.\n",
-    "        f_rate_true[i] = np.sum(\n",
-    "            test.result_Y[0:to_release] == 0) / test.shape[0]\n",
-    "\n",
-    "        # Labeled outcomes only\n",
-    "        #\n",
-    "        # Sort by failure probabilities, subjects with the smallest risk are first.\n",
-    "        test_labeled.sort_values(by='B_prob_0_logreg',\n",
-    "                                 inplace=True,\n",
-    "                                 ascending=True)\n",
-    "\n",
-    "        to_release = int(round(test_labeled.shape[0] * r / 10))\n",
-    "\n",
-    "        f_rate_label[i] = np.sum(\n",
-    "            test_labeled.result_Y[0:to_release] == 0) / test_labeled.shape[0]\n",
-    "\n",
-    "        # Human evaluation\n",
-    "        #\n",
-    "        # Get judges with correct leniency as list\n",
-    "        correct_leniency_list = test_labeled.judgeID_J[\n",
-    "            test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
-    "\n",
-    "        # Released are the people they judged and released, T = 1\n",
-    "        released = test_labeled[\n",
-    "            test_labeled.judgeID_J.isin(correct_leniency_list)\n",
-    "            & (test_labeled.decision_T == 1)]\n",
-    "\n",
-    "        # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
-    "        f_rate_human[i] = np.sum(\n",
-    "            released.result_Y == 0) / correct_leniency_list.shape[0]\n",
-    "\n",
-    "        # Contraction, logistic regression\n",
-    "        #\n",
-    "        f_rate_cont[i] = contraction(test_labeled, 'judgeID_J', 'decision_T',\n",
-    "                                     'result_Y', 'B_prob_0_logreg',\n",
-    "                                     'acceptanceRate_R', r / 10)\n",
-    "\n",
-    "        # Causal model - empirical performance\n",
-    "        #\n",
-    "        test_labeled['release_probs'] = calcReleaseProbabilities(\n",
-    "            r * 10, train.X.values, test_labeled.X, logreg) * test_labeled.B_prob_0_logreg\n",
-    "\n",
-    "        test_labeled.sort_values(\n",
-    "            by=['release_probs'], ascending=True, inplace=True)\n",
-    "        \n",
-    "        to_release = int(round(test_labeled.dropna().shape[0] * r / 10))\n",
-    "        \n",
-    "        f_rate_caus[i] = np.sum(\n",
-    "            test_labeled.result_Y[0:to_release] == 0) / test_labeled.dropna().shape[0]\n",
-    "        print(f_rate_caus[i])\n",
-    "#         recidivated = test_labeled.dropna().result_Y == 0\n",
-    "\n",
-    "#         released = bailIndicator(r * 10, logreg, train.X.values.reshape(-1, 1),\n",
-    "#                                  test_labeled.dropna().X.values.reshape(-1, 1))\n",
-    "\n",
-    "#         f_rate_caus[i] = np.sum(recidivated\n",
-    "#                                 & released) / test_labeled.dropna().shape[0]\n",
-    "\n",
-    "    failure_rates[r - 1, 0] = np.mean(f_rate_true)\n",
-    "    failure_rates[r - 1, 1] = np.mean(f_rate_label)\n",
-    "    failure_rates[r - 1, 2] = np.mean(f_rate_human)\n",
-    "    failure_rates[r - 1, 3] = np.mean(f_rate_cont)\n",
-    "    failure_rates[r - 1, 4] = np.mean(f_rate_caus)\n",
-    "\n",
-    "    failure_sems[r - 1, 0] = scs.sem(f_rate_true)\n",
-    "    failure_sems[r - 1, 1] = scs.sem(f_rate_label)\n",
-    "    failure_sems[r - 1, 2] = scs.sem(f_rate_human)\n",
-    "    failure_sems[r - 1, 3] = scs.sem(f_rate_cont)\n",
-    "    failure_sems[r - 1, 4] = scs.sem(f_rate_caus)\n",
-    "\n",
-    "x_ax = np.arange(0.1, 0.9, 0.1)\n",
-    "\n",
-    "plt.figure(figsize=(14, 8))\n",
-    "plt.errorbar(x_ax,\n",
-    "             failure_rates[:, 0],\n",
-    "             label='True Evaluation',\n",
-    "             c='green',\n",
-    "             yerr=failure_sems[:, 0])\n",
-    "plt.errorbar(x_ax,\n",
-    "             failure_rates[:, 1],\n",
-    "             label='Labeled outcomes',\n",
-    "             c='magenta',\n",
-    "             yerr=failure_sems[:, 1])\n",
-    "plt.errorbar(x_ax,\n",
-    "             failure_rates[:, 2],\n",
-    "             label='Human evaluation',\n",
-    "             c='red',\n",
-    "             yerr=failure_sems[:, 2])\n",
-    "plt.errorbar(x_ax,\n",
-    "             failure_rates[:, 3],\n",
-    "             label='Contraction, log.',\n",
-    "             c='blue',\n",
-    "             yerr=failure_sems[:, 3])\n",
-    "plt.errorbar(x_ax,\n",
-    "             failure_rates[:, 4],\n",
-    "             label='Causal model, ep',\n",
-    "             c='black',\n",
-    "             yerr=failure_sems[:, 4])\n",
-    "\n",
-    "plt.title('Failure rate vs. Acceptance rate with unobservables')\n",
-    "plt.xlabel('Acceptance rate')\n",
-    "plt.ylabel('Failure rate')\n",
-    "plt.legend()\n",
-    "plt.grid()\n",
-    "plt.show()\n",
-    "\n",
-    "print(failure_rates)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Without unobservables"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 182,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[1] 0 1 2 3 4 [2] 0 1 2 3 4 [3] 0 1 2 3 4 [4] 0 1 2 3 4 [5] 0 1 2 3 4 [6] 0 1 2 3 4 [7] 0 1 2 3 4 [8] 0 1 2 3 4 "
+      "2 "
      ]
     },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1008x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[[0.015656   0.015656   0.02298115 0.01767964 0.015648  ]\n",
-      " [0.042056   0.042056   0.04496511 0.03649814 0.040584  ]\n",
-      " [0.075104   0.075104   0.07347411 0.07351819 0.06688   ]\n",
-      " [0.115576   0.115576   0.1139911  0.10520566 0.094128  ]\n",
-      " [0.163768   0.163768   0.16198788 0.16538057 0.120872  ]\n",
-      " [0.216296   0.216296   0.21643774 0.22866057 0.1486    ]\n",
-      " [0.274608   0.274608   0.28171782 0.27026402 0.164648  ]\n",
-      " [0.340248   0.340248   0.34250089 0.31942495 0.180328  ]]\n"
+      "3 "
      ]
-    }
-   ],
-   "source": [
-    "f_rates = np.zeros((8, 5))\n",
-    "f_sems = np.zeros((8, 5))\n",
-    "\n",
-    "nIter = 5\n",
-    "\n",
-    "for r in np.arange(1, 9):\n",
-    "\n",
-    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
-    "\n",
-    "    s_f_rate_true = np.zeros(nIter)\n",
-    "    s_f_rate_gs = np.zeros(nIter)\n",
-    "    s_f_rate_human = np.zeros(nIter)\n",
-    "    s_f_rate_cont = np.zeros(nIter)\n",
-    "    s_f_rate_caus = np.zeros(nIter)\n",
-    "\n",
-    "    for i in range(nIter):\n",
-    "\n",
-    "        print(i, end=\" \")\n",
-    "\n",
-    "        s_train_labeled, s_train, s_test_labeled, s_test, s_df = dataWithoutUnobservables(\n",
-    "        )\n",
-    "\n",
-    "        s_logreg, predictions = fitLogisticRegression(\n",
-    "            s_train_labeled.dropna().X,\n",
-    "            s_train_labeled.dropna().result_Y, s_test.X, 0)\n",
-    "        s_test = s_test.assign(B_prob_0_logreg=predictions)\n",
-    "\n",
-    "        s_logreg, predictions_labeled = fitLogisticRegression(\n",
-    "            s_train_labeled.dropna().X,\n",
-    "            s_train_labeled.dropna().result_Y, s_test_labeled.X, 0)\n",
-    "        s_test_labeled = s_test_labeled.assign(\n",
-    "            B_prob_0_logreg=predictions_labeled)\n",
-    "\n",
-    "        #### True evaluation\n",
-    "        # Sort by estimated failure probabilities, subjects with the smallest risk are first.\n",
-    "        s_sorted = s_test.sort_values(by='B_prob_0_logreg',\n",
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2] 0 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3] 0 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[4] 0 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[5] 0 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[6] 0 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[7] 0 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[8] 0 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4 "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:107: IntegrationWarning: The maximum number of subdivisions (50) has been achieved.\n",
+      "  If increasing the limit yields no improvement it is advised to analyze \n",
+      "  the integrand in order to determine the difficulties.  If the position of a \n",
+      "  local difficulty can be determined (singularity, discontinuity) one will \n",
+      "  probably gain from splitting up the interval and calling the integrator \n",
+      "  on the subranges.  Perhaps a special-purpose integrator should be used.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0.005328   0.002272   0.01023348 0.00691889 0.00364671]\n",
+      " [0.02048    0.008424   0.02575853 0.02238238 0.01329275]\n",
+      " [0.046816   0.018624   0.04589419 0.0443047  0.02873453]\n",
+      " [0.081288   0.032552   0.08197224 0.07967856 0.05297712]\n",
+      " [0.127056   0.04776    0.12811773 0.11500238 0.08143095]\n",
+      " [0.182616   0.066528   0.18657189 0.17785139 0.11732526]\n",
+      " [0.2438     0.0902     0.24372187 0.22823061 0.17043125]\n",
+      " [0.321096   0.11352    0.32128957 0.33853595 0.23178933]]\n",
+      "\n",
+      "Mean absolute errors:\n",
+      "0.081075\n",
+      "0.0021349209648225077\n",
+      "0.007180198058091217\n",
+      "0.04110651320827825\n"
+     ]
+    }
+   ],
+   "source": [
+    "failure_rates = np.zeros((8, 5))\n",
+    "failure_sems = np.zeros((8, 5))\n",
+    "\n",
+    "nIter = 5\n",
+    "\n",
+    "for r in np.arange(1, 9):\n",
+    "\n",
+    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
+    "\n",
+    "    f_rate_true = np.zeros(nIter)\n",
+    "    f_rate_label = np.zeros(nIter)\n",
+    "    f_rate_human = np.zeros(nIter)\n",
+    "    f_rate_cont = np.zeros(nIter)\n",
+    "    f_rate_caus = np.zeros(nIter)\n",
+    "\n",
+    "    for i in range(nIter):\n",
+    "\n",
+    "        print(i, end=\" \")\n",
+    "\n",
+    "        # Create data\n",
+    "        train_labeled, train, test_labeled, test, df = dataWithUnobservables()\n",
+    "\n",
+    "        # Fit model and calculate predictions\n",
+    "        logreg, predictions = fitLogisticRegression(\n",
+    "            train_labeled.dropna().X,\n",
+    "            train_labeled.dropna().result_Y, test.X, 0)\n",
+    "\n",
+    "        # Attach the predictions to data\n",
+    "        test = test.assign(B_prob_0_logreg=predictions)\n",
+    "\n",
+    "        logreg, predictions_labeled = fitLogisticRegression(\n",
+    "            train_labeled.dropna().X,\n",
+    "            train_labeled.dropna().result_Y, test_labeled.X, 0)\n",
+    "\n",
+    "        test_labeled = test_labeled.assign(B_prob_0_logreg=predictions_labeled)\n",
+    "\n",
+    "        # True evaluation\n",
+    "        #\n",
+    "        # Sort by failure probabilities, subjects with the smallest risk are first.\n",
+    "        test.sort_values(by='B_prob_0_logreg', inplace=True, ascending=True)\n",
+    "\n",
+    "        to_release = int(round(test.shape[0] * r / 10))\n",
+    "\n",
+    "        # Calculate failure rate as the ratio of failures to those who were given a\n",
+    "        # positive decision, i.e. those whose probability of negative outcome was\n",
+    "        # low enough.\n",
+    "        f_rate_true[i] = np.sum(\n",
+    "            test.result_Y[0:to_release] == 0) / test.shape[0]\n",
+    "\n",
+    "        # Labeled outcomes only\n",
+    "        #\n",
+    "        # Sort by failure probabilities, subjects with the smallest risk are first.\n",
+    "        test_labeled.sort_values(by='B_prob_0_logreg',\n",
+    "                                 inplace=True,\n",
+    "                                 ascending=True)\n",
+    "\n",
+    "        to_release = int(round(test_labeled.shape[0] * r / 10))\n",
+    "\n",
+    "        f_rate_label[i] = np.sum(\n",
+    "            test_labeled.result_Y[0:to_release] == 0) / test_labeled.shape[0]\n",
+    "\n",
+    "        # Human evaluation\n",
+    "        #\n",
+    "        # Get judges with correct leniency as list\n",
+    "        correct_leniency_list = test_labeled.judgeID_J[\n",
+    "            test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
+    "\n",
+    "        # Released are the people they judged and released, T = 1\n",
+    "        released = test_labeled[\n",
+    "            test_labeled.judgeID_J.isin(correct_leniency_list)\n",
+    "            & (test_labeled.decision_T == 1)]\n",
+    "\n",
+    "        # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
+    "        f_rate_human[i] = np.sum(\n",
+    "            released.result_Y == 0) / correct_leniency_list.shape[0]\n",
+    "\n",
+    "        # Contraction, logistic regression\n",
+    "        #\n",
+    "        f_rate_cont[i] = contraction(test_labeled, 'judgeID_J', 'decision_T',\n",
+    "                                     'result_Y', 'B_prob_0_logreg',\n",
+    "                                     'acceptanceRate_R', r / 10)\n",
+    "\n",
+    "        # Causal model - empirical performance\n",
+    "        #       \n",
+    "#         recidivated = test_labeled.dropna().result_Y == 0\n",
+    "\n",
+    "#         released = bailIndicator(r * 10, logreg, train.X,\n",
+    "#                                  test_labeled.dropna().X)\n",
+    "\n",
+    "#         f_rate_caus[i] = np.sum(recidivated\n",
+    "#                                 & released) / test_labeled.dropna().shape[0]\n",
+    "        \n",
+    "        percentiles = estimatePercentiles(train_labeled.X, logreg, N_sample=train_labeled.shape[0])\n",
+    "\n",
+    "        def releaseProbability(x):\n",
+    "            return calcReleaseProbabilities(r*10, train_labeled.X, x, logreg, percentileMatrix=percentiles)\n",
+    "\n",
+    "        def integraali(x):\n",
+    "            p_y0 = logreg.predict_proba(x.reshape(-1, 1))[:, 0]\n",
+    "\n",
+    "            p_t1 = releaseProbability(x)\n",
+    "\n",
+    "            p_x = scs.norm.pdf(x)\n",
+    "\n",
+    "            return p_y0 * p_t1 * p_x\n",
+    "\n",
+    "        f_rate_caus[i] = si.quad(lambda x: integraali(np.ones((1, 1))*x), -10, 10)[0]\n",
+    "\n",
+    "    failure_rates[r - 1, 0] = np.mean(f_rate_true)\n",
+    "    failure_rates[r - 1, 1] = np.mean(f_rate_label)\n",
+    "    failure_rates[r - 1, 2] = np.mean(f_rate_human)\n",
+    "    failure_rates[r - 1, 3] = np.mean(f_rate_cont)\n",
+    "    failure_rates[r - 1, 4] = np.mean(f_rate_caus)\n",
+    "\n",
+    "    failure_sems[r - 1, 0] = scs.sem(f_rate_true)\n",
+    "    failure_sems[r - 1, 1] = scs.sem(f_rate_label)\n",
+    "    failure_sems[r - 1, 2] = scs.sem(f_rate_human)\n",
+    "    failure_sems[r - 1, 3] = scs.sem(f_rate_cont)\n",
+    "    failure_sems[r - 1, 4] = scs.sem(f_rate_caus)\n",
+    "\n",
+    "x_ax = np.arange(0.1, 0.9, 0.1)\n",
+    "\n",
+    "plt.figure(figsize=(14, 8))\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 0],\n",
+    "             label='True Evaluation',\n",
+    "             c='green',\n",
+    "             yerr=failure_sems[:, 0])\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 1],\n",
+    "             label='Labeled outcomes',\n",
+    "             c='magenta',\n",
+    "             yerr=failure_sems[:, 1])\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 2],\n",
+    "             label='Human evaluation',\n",
+    "             c='red',\n",
+    "             yerr=failure_sems[:, 2])\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 3],\n",
+    "             label='Contraction, log.',\n",
+    "             c='blue',\n",
+    "             yerr=failure_sems[:, 3])\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 4],\n",
+    "             label='Causal model, ep',\n",
+    "             c='black',\n",
+    "             yerr=failure_sems[:, 4])\n",
+    "\n",
+    "plt.title('Failure rate vs. Acceptance rate with unobservables')\n",
+    "plt.xlabel('Acceptance rate')\n",
+    "plt.ylabel('Failure rate')\n",
+    "plt.legend()\n",
+    "plt.grid()\n",
+    "plt.show()\n",
+    "\n",
+    "print(failure_rates)\n",
+    "print(\"\\nMean absolute errors:\")\n",
+    "for i in range(1, failure_rates.shape[1]):\n",
+    "    print(np.mean(np.abs(failure_rates[:, 0] - failure_rates[:, i])))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Without unobservables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1] 0 1 2 3 4 [2] 0 1 2 3 4 [3] 0 1 2 3 4 [4] 0 1 2 3 4 [5] 0 1 2 3 4 [6] 0 1 2 3 4 [7] 0 1 2 3 4 [8] 0 1 2 3 4 "
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0.015496   0.005712   0.02127184 0.01525861 0.03124425]\n",
+      " [0.041512   0.01536    0.0420505  0.03878719 0.07901708]\n",
+      " [0.074816   0.026368   0.07148129 0.07542401 0.13066169]\n",
+      " [0.115816   0.040512   0.11178727 0.12729332 0.18676773]\n",
+      " [0.16204    0.052912   0.16180877 0.15743246 0.24149321]\n",
+      " [0.215856   0.064248   0.213719   0.20494553 0.29062086]\n",
+      " [0.275936   0.08228    0.27835584 0.27637565 0.32751767]\n",
+      " [0.34184    0.095128   0.34104192 0.35407834 0.35207248]]\n",
+      "\n",
+      "Mean absolute errors:\n",
+      "0.10759899999999999\n",
+      "0.002407990604993744\n",
+      "0.00540544050753119\n",
+      "0.04951037047570979\n"
+     ]
+    }
+   ],
+   "source": [
+    "f_rates = np.zeros((8, 5))\n",
+    "f_sems = np.zeros((8, 5))\n",
+    "\n",
+    "nIter = 5\n",
+    "\n",
+    "for r in np.arange(1, 9):\n",
+    "\n",
+    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
+    "\n",
+    "    s_f_rate_true = np.zeros(nIter)\n",
+    "    s_f_rate_labeled = np.zeros(nIter)\n",
+    "    s_f_rate_human = np.zeros(nIter)\n",
+    "    s_f_rate_cont = np.zeros(nIter)\n",
+    "    s_f_rate_caus = np.zeros(nIter)\n",
+    "\n",
+    "    for i in range(nIter):\n",
+    "\n",
+    "        print(i, end=\" \")\n",
+    "\n",
+    "        s_train_labeled, s_train, s_test_labeled, s_test, s_df = dataWithoutUnobservables(\n",
+    "        )\n",
+    "\n",
+    "        s_logreg, predictions = fitLogisticRegression(\n",
+    "            s_train_labeled.dropna().X,\n",
+    "            s_train_labeled.dropna().result_Y, s_test.X, 0)\n",
+    "        s_test = s_test.assign(B_prob_0_logreg=predictions)\n",
+    "\n",
+    "        s_logreg, predictions_labeled = fitLogisticRegression(\n",
+    "            s_train_labeled.dropna().X,\n",
+    "            s_train_labeled.dropna().result_Y, s_test_labeled.X, 0)\n",
+    "        s_test_labeled = s_test_labeled.assign(\n",
+    "            B_prob_0_logreg=predictions_labeled)\n",
+    "\n",
+    "        #### True evaluation\n",
+    "        # Sort by actual failure probabilities, subjects with the smallest risk are first.\n",
+    "        s_sorted = s_test.sort_values(by='probabilities_Y',\n",
     "                                      inplace=False,\n",
     "                                      ascending=True)\n",
     "\n",
@@ -916,18 +1678,18 @@
     "        s_f_rate_true[i] = np.sum(\n",
     "            s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
     "\n",
-    "        #### \"Golden standard\"\n",
-    "        # Sort by actual failure probabilities, subjects with the smallest risk are first.\n",
-    "        s_sorted = s_test.sort_values(by='probabilities_Y',\n",
-    "                                      inplace=False,\n",
-    "                                      ascending=True)\n",
+    "        #### Labeled outcomes\n",
+    "        # Sort by estimated failure probabilities, subjects with the smallest risk are first.\n",
+    "        s_sorted = s_test_labeled.sort_values(by='probabilities_Y',\n",
+    "                                              inplace=False,\n",
+    "                                              ascending=True)\n",
     "\n",
-    "        to_release = int(round(s_sorted.shape[0] * r / 10))\n",
+    "        to_release = int(round(s_test_labeled.dropna().shape[0] * r / 10))\n",
     "\n",
     "        # Calculate failure rate as the ratio of failures to successes among those\n",
     "        # who were given a positive decision, i.e. those whose probability of negative\n",
     "        # outcome was low enough.\n",
-    "        s_f_rate_gs[i] = np.sum(\n",
+    "        s_f_rate_labeled[i] = np.sum(\n",
     "            s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
     "\n",
     "        #### Human error rate\n",
@@ -950,36 +1712,45 @@
     "                                       'B_prob_0_logreg', 'acceptanceRate_R',\n",
     "                                       r / 10)\n",
     "        #### Causal model\n",
-    "        s_test_labeled['release_probs'] = (1 - calcReleaseProbabilities(\n",
-    "            r * 10, s_train.X.values, s_test_labeled.X, s_logreg)) * s_test_labeled.B_prob_0_logreg\n",
     "\n",
-    "        s_test_labeled.sort_values(\n",
-    "            by=['release_probs'], ascending=True, inplace=True)\n",
-    "        \n",
-    "        to_release = int(round(s_test_labeled.shape[0] * r / 10))\n",
-    "        \n",
+    "        recidivated = s_test_labeled.dropna().result_Y == 0\n",
+    "\n",
+    "        released_for_bail = bailIndicator(r * 10, s_logreg, s_train.X,\n",
+    "                                          s_test_labeled.dropna().X)\n",
+    "\n",
     "        s_f_rate_caus[i] = np.sum(\n",
-    "            s_test_labeled.result_Y[0:to_release] == 0) / s_test_labeled.shape[0]\n",
-    "        \n",
-    "        \n",
-    "        \n",
-    "#         recidivated = s_test_labeled.result_Y == 0\n",
+    "            recidivated & released_for_bail) / s_test_labeled.dropna().shape[0]\n",
+    "\n",
+    "        ########################\n",
+    "#         percentiles = estimatePercentiles(s_train_labeled.X, s_logreg)\n",
+    "\n",
+    "#         def releaseProbability(x):\n",
+    "#             return calcReleaseProbabilities(r * 10,\n",
+    "#                                             s_train_labeled.X,\n",
+    "#                                             x,\n",
+    "#                                             s_logreg,\n",
+    "#                                             percentileMatrix=percentiles)\n",
+    "\n",
+    "#         def integraali(x):\n",
+    "#             p_y0 = s_logreg.predict_proba(x.reshape(-1, 1))[:, 0]\n",
     "\n",
-    "#         released_for_bail = bailIndicator(\n",
-    "#             r * 10, s_logreg, s_train.X.values.reshape(-1, 1),\n",
-    "#             s_test_labeled.X.values.reshape(-1, 1))\n",
+    "#             p_t1 = releaseProbability(x)\n",
     "\n",
-    "#         s_f_rate_caus[i] = np.sum(\n",
-    "#             recidivated & released_for_bail) / s_test_labeled.dropna().shape[0]\n",
+    "#             p_x = scs.norm.pdf(x)\n",
+    "\n",
+    "#             return p_y0 * p_t1 * p_x\n",
+    "\n",
+    "#         s_f_rate_caus[i] = si.quad(lambda x: integraali(np.ones((1, 1)) * x),\n",
+    "#                                    -10, 10)[0]\n",
     "\n",
     "    f_rates[r - 1, 0] = np.mean(s_f_rate_true)\n",
-    "    f_rates[r - 1, 1] = np.mean(s_f_rate_gs)\n",
+    "    f_rates[r - 1, 1] = np.mean(s_f_rate_labeled)\n",
     "    f_rates[r - 1, 2] = np.mean(s_f_rate_human)\n",
     "    f_rates[r - 1, 3] = np.mean(s_f_rate_cont)\n",
     "    f_rates[r - 1, 4] = np.mean(s_f_rate_caus)\n",
     "\n",
     "    f_sems[r - 1, 0] = scs.sem(s_f_rate_true)\n",
-    "    f_sems[r - 1, 1] = scs.sem(s_f_rate_gs)\n",
+    "    f_sems[r - 1, 1] = scs.sem(s_f_rate_labeled)\n",
     "    f_sems[r - 1, 2] = scs.sem(s_f_rate_human)\n",
     "    f_sems[r - 1, 3] = scs.sem(s_f_rate_cont)\n",
     "    f_sems[r - 1, 4] = scs.sem(s_f_rate_caus)\n",
@@ -994,7 +1765,7 @@
     "             yerr=f_sems[:, 0])\n",
     "plt.errorbar(x_ax,\n",
     "             f_rates[:, 1],\n",
-    "             label='\"Golden standard\"',\n",
+    "             label='Labeled outcomes',\n",
     "             c='magenta',\n",
     "             yerr=f_sems[:, 1])\n",
     "plt.errorbar(x_ax,\n",
@@ -1020,45 +1791,10 @@
     "plt.grid()\n",
     "plt.show()\n",
     "\n",
-    "print(f_rates)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 184,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.18632\n",
-      "0.16688\n"
-     ]
-    }
-   ],
-   "source": [
-    "s_test_labeled['release_probs'] = (1 - calcReleaseProbabilities(\n",
-    "            90, s_train.X.values, s_test_labeled.X, s_logreg)) * s_test_labeled.B_prob_0_logreg\n",
-    "\n",
-    "s_test_labeled.sort_values(\n",
-    "    by=['release_probs'], ascending=True, inplace=True)\n",
-    "\n",
-    "to_release = int(round(s_test_labeled.shape[0] * r / 10))\n",
-    "\n",
-    "print(np.sum(\n",
-    "    s_test_labeled.result_Y[0:to_release] == 0) / s_test_labeled.shape[0])\n",
-    "\n",
-    "s_test_labeled['release_probs'] = (1 - calcReleaseProbabilities(\n",
-    "    100, s_train.X.values, s_test_labeled.X, s_logreg)) * s_test_labeled.B_prob_0_logreg\n",
-    "\n",
-    "s_test_labeled.sort_values(\n",
-    "    by=['release_probs'], ascending=True, inplace=True)\n",
-    "\n",
-    "to_release = int(round(s_test_labeled.shape[0] * r / 10))\n",
-    "\n",
-    "print(np.sum(\n",
-    "    s_test_labeled.result_Y[0:to_release] == 0) / s_test_labeled.shape[0])"
+    "print(f_rates)\n",
+    "print(\"\\nMean absolute errors:\")\n",
+    "for i in range(1, f_rates.shape[1]):\n",
+    "    print(np.mean(np.abs(f_rates[:, 0] - f_rates[:, i])))"
    ]
   }
  ],