From c11bb7a8b42c57f53348dde27ac077ab4ac1dc8d Mon Sep 17 00:00:00 2001
From: Riku-Laine <28960190+Riku-Laine@users.noreply.github.com>
Date: Fri, 28 Jun 2019 16:15:56 +0300
Subject: [PATCH] Results with MC computed and written

---
 .../Analysis_07MAY2019_old.ipynb              |   4 +-
 .../Analysis_25JUN2019_modular.ipynb          | 742 +++++++++++-------
 analysis_and_scripts/notes.tex                | 210 +++--
 ...Z_10iter_coinflip_quantile_defaults_mc.png | Bin 0 -> 51053 bytes
 4 files changed, 600 insertions(+), 356 deletions(-)
 create mode 100644 figures/sl_with_Z_10iter_coinflip_quantile_defaults_mc.png

diff --git a/analysis_and_scripts/Analysis_07MAY2019_old.ipynb b/analysis_and_scripts/Analysis_07MAY2019_old.ipynb
index afd68c0..e0e53d2 100644
--- a/analysis_and_scripts/Analysis_07MAY2019_old.ipynb
+++ b/analysis_and_scripts/Analysis_07MAY2019_old.ipynb
@@ -56,7 +56,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -221,7 +221,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb b/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb
index 3f50102..7af029a 100644
--- a/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb
+++ b/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb
@@ -7,7 +7,7 @@
    },
    "source": [
     "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
-    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Data-generation-modules\" data-toc-modified-id=\"Data-generation-modules-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Data generation modules</a></span></li><li><span><a href=\"#Decider-modules\" data-toc-modified-id=\"Decider-modules-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Decider modules</a></span></li><li><span><a href=\"#Evaluator-modules\" data-toc-modified-id=\"Evaluator-modules-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Evaluator modules</a></span><ul class=\"toc-item\"><li><span><a href=\"#Convenience-functions\" data-toc-modified-id=\"Convenience-functions-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Convenience functions</a></span></li><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Contraction algorithm</a></span></li><li><span><a href=\"#Evaluators\" data-toc-modified-id=\"Evaluators-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Evaluators</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Without-unobservables-in-the-data\" data-toc-modified-id=\"Without-unobservables-in-the-data-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Without unobservables in the data</a></span></li><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>With unobservables in the data</a></span></li></ul></li></ul></div>"
+    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Data-generation-modules\" data-toc-modified-id=\"Data-generation-modules-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Data generation modules</a></span></li><li><span><a href=\"#Decider-modules\" data-toc-modified-id=\"Decider-modules-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Decider modules</a></span></li><li><span><a href=\"#Evaluator-modules\" data-toc-modified-id=\"Evaluator-modules-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Evaluator modules</a></span><ul class=\"toc-item\"><li><span><a href=\"#Convenience-functions\" data-toc-modified-id=\"Convenience-functions-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Convenience functions</a></span></li><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Contraction algorithm</a></span></li><li><span><a href=\"#Evaluators\" data-toc-modified-id=\"Evaluators-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Evaluators</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Without-unobservables-in-the-data\" data-toc-modified-id=\"Without-unobservables-in-the-data-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Without unobservables in the data</a></span></li><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>With unobservables in the data</a></span></li></ul></li><li><span><a href=\"#Bayesian-sampling\" data-toc-modified-id=\"Bayesian-sampling-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Bayesian sampling</a></span></li></ul></div>"
    ]
   },
   {
@@ -19,7 +19,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -68,14 +68,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 94,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def sigmoid(x):\n",
-    "    '''Return value of sigmoid function (inverse of logit) at x.'''\n",
+    "def inv_logit(x):\n",
+    "    '''Return value of inverse of logit function (logistic / sigmoid) at x.'''\n",
+    "\n",
+    "    return 1.0 / (1.0 + np.exp(-1.0 * x))\n",
     "\n",
-    "    return 1 / (1 + np.exp(-1 * x))\n",
+    "\n",
+    "def logit(p):\n",
+    "    return np.log(p) - np.log(1 - p)\n",
     "\n",
     "\n",
     "def coinFlipDGWithoutUnobservables(N_total=50000):\n",
@@ -85,11 +89,11 @@
     "    # Sample feature X from standard Gaussian distribution, N(0, 1).\n",
     "    df = df.assign(X=npr.normal(size=N_total))\n",
     "\n",
-    "    # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = sigmoid(X)\n",
-    "    df = df.assign(probabilities_Y=sigmoid(df.X))\n",
+    "    # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = inv_logit(X)\n",
+    "    df = df.assign(probabilities_Y=inv_logit(df.X))\n",
     "\n",
-    "    # Draw Y ~ Bernoulli(1 - sigmoid(X))\n",
-    "    # Note: P(Y=1|X=x) = 1 - P(Y=0|X=x) = 1 - sigmoid(X)\n",
+    "    # Draw Y ~ Bernoulli(1 - inv_logit(X))\n",
+    "    # Note: P(Y=1|X=x) = 1 - P(Y=0|X=x) = 1 - inv_logit(X)\n",
     "    results = npr.binomial(n=1, p=1 - df.probabilities_Y, size=N_total)\n",
     "\n",
     "    df = df.assign(result_Y=results)\n",
@@ -107,7 +111,7 @@
     "    df = df.assign(W=npr.normal(size=N_total))\n",
     "\n",
     "    # Calculate P(Y=0|X, Z, W)\n",
-    "    probabilities_Y = sigmoid(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
+    "    probabilities_Y = inv_logit(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
     "\n",
     "    df = df.assign(probabilities_Y=probabilities_Y)\n",
     "\n",
@@ -129,15 +133,13 @@
     "    df = df.assign(Z=npr.normal(size=N_total))\n",
     "    df = df.assign(W=npr.normal(size=N_total))\n",
     "\n",
-    "    # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = sigmoid(X)\n",
-    "    probabilities_Y = sigmoid(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
+    "    # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = inv_logit(X)\n",
+    "    probabilities_Y = inv_logit(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
     "\n",
     "    df = df.assign(probabilities_Y=probabilities_Y)\n",
     "\n",
     "    # Draw Y from Bernoulli distribution\n",
-    "    results = npr.binomial(n=1,\n",
-    "                           p=1 - df.probabilities_Y,\n",
-    "                           size=N_total)\n",
+    "    results = npr.binomial(n=1, p=1 - df.probabilities_Y, size=N_total)\n",
     "\n",
     "    df = df.assign(result_Y=results)\n",
     "\n",
@@ -153,17 +155,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 93,
    "metadata": {},
    "outputs": [],
    "source": [
     "def humanDeciderLakkaraju(df,\n",
     "                          result_Y,\n",
     "                          featureX_col,\n",
-    "                          featureZ_col,\n",
+    "                          featureZ_col=None,\n",
     "                          nJudges_M=100,\n",
     "                          beta_X=1,\n",
     "                          beta_Z=1,\n",
+    "                          add_epsilon=True,\n",
     "                          hide_unobserved=True):\n",
     "\n",
     "    # Assert that every judge will have the same number of subjects.\n",
@@ -182,8 +185,14 @@
     "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
     "    df = df.assign(acceptanceRate_R=np.repeat(acceptance_rates, nSubjects_N))\n",
     "\n",
-    "    probabilities_T = sigmoid(beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
-    "    probabilities_T += np.sqrt(0.1) * npr.normal(size=nJudges_M * nSubjects_N)\n",
+    "    if featureZ_col is None:\n",
+    "        probabilities_T = inv_logit(beta_X * df[featureX_col])\n",
+    "    else:\n",
+    "        probabilities_T = inv_logit(\n",
+    "            beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
+    "\n",
+    "    if add_epsilon:\n",
+    "        probabilities_T += np.sqrt(0.1) * npr.normal(size=df.shape[0])\n",
     "\n",
     "    df = df.assign(probabilities_T=probabilities_T)\n",
     "\n",
@@ -203,7 +212,7 @@
     "    df['decision_T'] = np.where((df.index.values % nSubjects_N) <\n",
     "                                ((1 - df['acceptanceRate_R']) * nSubjects_N),\n",
     "                                0, 1)\n",
-    "    \n",
+    "\n",
     "    if hide_unobserved:\n",
     "        df.loc[df.decision_T == 0, result_Y] = np.nan\n",
     "\n",
@@ -212,10 +221,11 @@
     "\n",
     "def coinFlipDecider(df,\n",
     "                    featureX_col,\n",
-    "                    featureZ_col,\n",
+    "                    featureZ_col=None,\n",
     "                    nJudges_M=100,\n",
     "                    beta_X=1,\n",
     "                    beta_Z=1,\n",
+    "                    add_epsilon=False,\n",
     "                    hide_unobserved=True):\n",
     "\n",
     "    # Assert that every judge will have the same number of subjects.\n",
@@ -227,18 +237,20 @@
     "    # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
     "    df = df.assign(judgeID_J=np.repeat(range(0, nJudges_M), nSubjects_N))\n",
     "\n",
-    "    # Sample acceptance rates uniformly from a closed interval\n",
-    "    # from 0.1 to 0.9 and round to tenth decimal place.\n",
-    "    #acceptance_rates = np.round(npr.uniform(.1, .9, nJudges_M), 10)\n",
-    "    \n",
-    "    # No real leniency here???\n",
-    "    acceptance_rates = np.ones(nJudges_M)*0.5\n",
-    "    \n",
+    "    # No real leniency here -> set to 0.5.\n",
+    "    acceptance_rates = np.ones(nJudges_M) * 0.5\n",
+    "\n",
     "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
     "    df = df.assign(acceptanceRate_R=np.repeat(acceptance_rates, nSubjects_N))\n",
     "\n",
-    "    probabilities_T = sigmoid(beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
-    "    #probabilities_T += np.sqrt(0.1) * npr.normal(size=nJudges_M * nSubjects_N)\n",
+    "    if featureZ_col is None:\n",
+    "        probabilities_T = inv_logit(beta_X * df[featureX_col])\n",
+    "    else:\n",
+    "        probabilities_T = inv_logit(\n",
+    "            beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
+    "\n",
+    "    if add_epsilon:\n",
+    "        probabilities_T += np.sqrt(0.1) * npr.normal(size=df.shape[0])\n",
     "\n",
     "    df = df.assign(probabilities_T=probabilities_T)\n",
     "\n",
@@ -246,10 +258,64 @@
     "    decisions = npr.binomial(n=1, p=1 - df.probabilities_T, size=df.shape[0])\n",
     "\n",
     "    df = df.assign(decision_T=decisions)\n",
-    "    \n",
+    "\n",
     "    if hide_unobserved:\n",
     "        df.loc[df.decision_T == 0, 'result_Y'] = np.nan\n",
+    "\n",
+    "    return df\n",
+    "\n",
+    "\n",
+    "def quantileDecider(df,\n",
+    "                    featureX_col,\n",
+    "                    featureZ_col=None,\n",
+    "                    nJudges_M=100,\n",
+    "                    beta_X=1,\n",
+    "                    beta_Z=1,\n",
+    "                    add_epsilon=False,\n",
+    "                    hide_unobserved=True,\n",
+    "                    N_sim = int(1e7)):\n",
+    "\n",
+    "    # Assert that every judge will have the same number of subjects.\n",
+    "    assert df.shape[0] % nJudges_M == 0, \"Can't assign subjets evenly!\"\n",
+    "\n",
+    "    # Compute the number of subjects allocated for each judge.\n",
+    "    nSubjects_N = int(df.shape[0] / nJudges_M)\n",
+    "\n",
+    "    # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
+    "    df = df.assign(judgeID_J=np.repeat(range(0, nJudges_M), nSubjects_N))\n",
+    "\n",
+    "    # Sample acceptance rates uniformly from a closed interval\n",
+    "    # from 0.1 to 0.9 and round to tenth decimal place.\n",
+    "    acceptance_rates = np.round(npr.uniform(.1, .9, nJudges_M), 10)\n",
+    "\n",
+    "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
+    "    df = df.assign(acceptanceRate_R=np.repeat(acceptance_rates, nSubjects_N))\n",
+    "\n",
+    "    if featureZ_col is None:\n",
+    "        probabilities_T = inv_logit(beta_X * df[featureX_col])\n",
+    "    else:\n",
+    "        probabilities_T = inv_logit(\n",
+    "            beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
+    "\n",
+    "    if add_epsilon:\n",
+    "        probabilities_T += np.sqrt(0.1) * npr.normal(size=df.shape[0])\n",
+    "\n",
+    "    df = df.assign(probabilities_T=probabilities_T)\n",
+    "\n",
+    "    # Construct the quantile function by sampling from two Gaussians and using\n",
+    "    # their sum through the inverse of logit.\n",
+    "    probs = inv_logit(npr.normal(size=N_sim) + npr.normal(size=N_sim))\n",
+    "\n",
+    "    # Now if P(Y=0|X, Z) (named 'probabilities_T') is greater than Q(r), a.k.a\n",
+    "    # the rth quantile of 'probs', T will be 0 and 1 otherwise.\n",
+    "    df = df.assign(quantile_bounds = np.quantile(probs, df.acceptanceRate_R))\n",
     "    \n",
+    "    df = df.assign(decision_T=np.where(\n",
+    "        df.probabilities_T >= df.quantile_bounds, 0, 1))\n",
+    "\n",
+    "    if hide_unobserved:\n",
+    "        df.loc[df.decision_T == 0, 'result_Y'] = np.nan\n",
+    "\n",
     "    return df"
    ]
   },
@@ -264,7 +330,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 94,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -385,7 +451,7 @@
     "    y_values = scs.norm.pdf(x_values)\n",
     "\n",
     "    results = np.zeros(x_0.shape[0])\n",
-    "    print(\"en loop\")\n",
+    "\n",
     "    for i in range(x_0.shape[0]):\n",
     "\n",
     "        y_copy = y_values.copy()\n",
@@ -393,7 +459,7 @@
     "        y_copy[x_preds > prediction_x_0[i]] = 0\n",
     "        \n",
     "        results[i] = si.simps(y_copy, x=x_values)\n",
-    "    print(\"jlk loop\")\n",
+    "\n",
     "    return results\n",
     "\n",
     "\n",
@@ -457,7 +523,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -519,7 +585,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 96,
+   "execution_count": 218,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -559,7 +625,7 @@
     "\n",
     "    test.sort_values(by='B_prob_0_model', inplace=True, ascending=True)\n",
     "\n",
-    "    to_release = int(round(test.shape[0] * r / 10))\n",
+    "    to_release = int(round(test.shape[0] * r))\n",
     "\n",
     "    return np.sum(test[resultY_col][0:to_release] == 0) / test.shape[0]\n",
     "\n",
@@ -581,7 +647,7 @@
     "                                              inplace=False,\n",
     "                                              ascending=True)\n",
     "\n",
-    "    to_release = int(round(test_observed.shape[0] * r / 10))\n",
+    "    to_release = int(round(test_observed.shape[0] * r))\n",
     "\n",
     "    return np.sum(\n",
     "        test_observed[resultY_col][0:to_release] == 0) / test.shape[0]\n",
@@ -591,7 +657,7 @@
     "                             accRateR_col, r):\n",
     "\n",
     "    # Get judges with correct leniency as list\n",
-    "    is_correct_leniency = df[accRateR_col].round(1) == r / 10\n",
+    "    is_correct_leniency = df[accRateR_col].round(1) == r\n",
     "\n",
     "    correct_leniency_list = df.loc[is_correct_leniency, judgeIDJ_col]\n",
     "\n",
@@ -614,9 +680,58 @@
     "\n",
     "    test = test.assign(B_prob_0_model=predictions)\n",
     "\n",
-    "    released = cdf(test[featureX_col], B_model, 0) < r / 10\n",
+    "    released = cdf(test[featureX_col], B_model, 0) < r\n",
     "\n",
-    "    return np.mean(test.B_prob_0_model * released)"
+    "    return np.mean(test.B_prob_0_model * released)\n",
+    "\n",
+    "\n",
+    "def monteCarloEvaluator(df,\n",
+    "                        featureX_col,\n",
+    "                        decisionT_col,\n",
+    "                        resultY_col,\n",
+    "                        accRateR_col,\n",
+    "                        r,\n",
+    "                        N_sim=int(1e6)):\n",
+    "\n",
+    "    train, test = train_test_split(df, test_size=0.5)\n",
+    "\n",
+    "    B_model, predictions = fitPredictiveModel(\n",
+    "        train.loc[train[decisionT_col] == 1, featureX_col],\n",
+    "        train.loc[train[decisionT_col] == 1, resultY_col], test[featureX_col],\n",
+    "        0)\n",
+    "\n",
+    "    test = test.assign(B_prob_0_model=predictions)\n",
+    "\n",
+    "    quants = inv_logit(npr.normal(size=N_sim) + npr.normal(size=N_sim))\n",
+    "\n",
+    "    Z = npr.normal(size=N_sim)\n",
+    "    e = np.sqrt(0.1) * npr.normal(size=N_sim)\n",
+    "    test = test.assign(predicted_Y=np.zeros_like(test[featureX_col]))\n",
+    "\n",
+    "    q_r = np.quantile(quants, test[accRateR_col])\n",
+    "\n",
+    "    test = test.assign(bounds=logit(q_r) - test[featureX_col])\n",
+    "\n",
+    "    for i in range(test.shape[0]):\n",
+    "        Zp = []\n",
+    "        if test[decisionT_col].iloc[i] == 0:\n",
+    "            Zp = Z[Z + e > test.bounds.iloc[i]]\n",
+    "        else:\n",
+    "            Zp = Z[Z + e < test.bounds.iloc[i]]\n",
+    "\n",
+    "        test.iloc[i, test.columns == 'predicted_Y'] = inv_logit(\n",
+    "            test[featureX_col].iloc[i] + np.mean(Zp))\n",
+    "\n",
+    "    predictions = npr.binomial(n=1, p=1-test.predicted_Y, size=test.shape[0])\n",
+    "\n",
+    "    test[resultY_col] = np.where(\n",
+    "        test[decisionT_col] == 0, predictions, test[resultY_col])\n",
+    "\n",
+    "    test.sort_values(by='B_prob_0_model', inplace=True, ascending=True)\n",
+    "\n",
+    "    to_release = int(round(test.shape[0] * r))\n",
+    "\n",
+    "    return np.sum(test[resultY_col][0:to_release] == 0) / test.shape[0]"
    ]
   },
   {
@@ -630,186 +745,182 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true
-   },
+   "metadata": {},
    "source": [
-    "### Without unobservables in the data\n",
-    "\n",
-    "The underlying figure is attached to the preliminary paper. When conducting finalization, last analysis should be conducted with a preset random seed."
+    "### Without unobservables in the data"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 217,
    "metadata": {
-    "hidden": true,
     "scrolled": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1] 0 1 2 3 4 5 6 7 8 9 [2] 0 1 2 3 4 5 6 7 8 9 [3] 0 1 2 3 4 5 6 7 8 9 [4] 0 1 2 3 4 5 6 7 8 9 [5] 0 1 2 3 4 5 6 7 8 9 [6] 0 1 2 3 4 5 6 7 8 9 [7] 0 1 2 3 4 5 6 7 8 9 [8] 0 1 2 3 4 5 6 7 8 9 "
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0.015424   0.005856   0.00700873 0.01609152 0.015964  ]\n",
+      " [0.042124   0.015944   0.02125723 0.04435839 0.043916  ]\n",
+      " [0.075464   0.02872    0.04810652 0.07724867 0.08046   ]\n",
+      " [0.1153     0.043196   0.10059008 0.10665967 0.124604  ]\n",
+      " [0.163496   0.0588     0.16363783 0.15052531 0.177884  ]\n",
+      " [0.216236   0.079128   0.24141272 0.21342228 0.236504  ]\n",
+      " [0.275828   0.101944   0.31497867 0.28211075 0.299696  ]\n",
+      " [0.341464   0.1261     0.40679724 0.33790021 0.37086   ]]\n",
+      "\n",
+      "Mean absolute errors:\n",
+      "0.09820600000000002\n",
+      "0.025143988486187003\n",
+      "0.004869733260249362\n",
+      "0.013068999999999989\n"
+     ]
+    }
+   ],
    "source": [
-    "# f_rates = np.zeros((8, 5))\n",
-    "# f_sems = np.zeros((8, 5))\n",
+    "failure_rates = np.zeros((8, 5))\n",
+    "failure_sems = np.zeros((8, 5))\n",
     "\n",
-    "# nIter = 15\n",
+    "nIter = 10\n",
     "\n",
-    "# #npr.seed(0)\n",
+    "for r in np.arange(1, 9):\n",
     "\n",
-    "# for r in np.arange(1, 9):\n",
+    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
     "\n",
-    "#     print(\"[\", r, \"]\", sep='', end=\" \")\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",
-    "#     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",
+    "    for i in range(nIter):\n",
     "\n",
-    "#     for i in range(nIter):\n",
+    "        print(i, end=\" \")\n",
+    "\n",
+    "        # Create data\n",
+    "        df = coinFlipDGWithoutUnobservables()\n",
+    "\n",
+    "        # Decider\n",
+    "        df_labeled = quantileDecider(df,\n",
+    "                                     featureX_col=\"X\",\n",
+    "                                     featureZ_col=None,\n",
+    "                                     nJudges_M=100,\n",
+    "                                     beta_X=1,\n",
+    "                                     beta_Z=1,\n",
+    "                                     hide_unobserved=True)\n",
+    "\n",
+    "        df_unlabeled = quantileDecider(df,\n",
+    "                                       featureX_col=\"X\",\n",
+    "                                       featureZ_col=None,\n",
+    "                                       nJudges_M=100,\n",
+    "                                       beta_X=1,\n",
+    "                                       beta_Z=1,\n",
+    "                                       hide_unobserved=False)\n",
+    "\n",
+    "        # True evaluation\n",
     "\n",
-    "#         print(i, end=\" \")\n",
+    "        f_rate_true[i] = trueEvaluationEvaluator(df_unlabeled, 'X',\n",
+    "                                                 'decision_T', 'result_Y',\n",
+    "                                                 r / 10)\n",
     "\n",
-    "#         s_train_labeled, s_train, s_test_labeled, s_test, s_df = dataWithoutUnobservables(sigma=2)\n",
+    "        # Labeled outcomes only\n",
     "\n",
-    "#         s_logreg, predictions = fitPredictiveModel(\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_model=predictions)\n",
+    "        f_rate_label[i] = labeledOutcomesEvaluator(df_labeled, 'X',\n",
+    "                                                   'decision_T', 'result_Y',\n",
+    "                                                   r / 10)\n",
     "\n",
-    "#         s_logreg, predictions_labeled = fitPredictiveModel(\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_model=predictions_labeled)\n",
+    "        # Human evaluation\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='B_prob_0_model',\n",
-    "#                                       inplace=False,\n",
-    "#                                       ascending=True)\n",
-    "\n",
-    "#         to_release = int(round(s_sorted.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_true[i] = np.sum(\n",
-    "#             s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
-    "\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='B_prob_0_model',\n",
-    "#                                               inplace=False,\n",
-    "#                                               ascending=True)\n",
-    "\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_labeled[i] = np.sum(\n",
-    "#             s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
-    "\n",
-    "#         #### Human error rate\n",
-    "#         # Get judges with correct leniency as list\n",
-    "#         correct_leniency_list = s_test_labeled.judgeID_J[\n",
-    "#             s_test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
-    "\n",
-    "#         # Released are the people they judged and released, T = 1\n",
-    "#         released = s_test_labeled[\n",
-    "#             s_test_labeled.judgeID_J.isin(correct_leniency_list)\n",
-    "#             & (s_test_labeled.decision_T == 1)]\n",
-    "\n",
-    "#         # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
-    "#         s_f_rate_human[i] = np.sum(\n",
-    "#             released.result_Y == 0) / correct_leniency_list.shape[0]\n",
-    "\n",
-    "#         #### Contraction\n",
-    "#         s_f_rate_cont[i] = contraction(s_test_labeled, 'judgeID_J',\n",
-    "#                                        'decision_T', 'result_Y',\n",
-    "#                                        'B_prob_0_model', 'acceptanceRate_R',\n",
-    "#                                        r / 10)\n",
-    "#         #### Causal model\n",
-    "\n",
-    "#         #released = bailIndicator(r * 10, s_logreg, s_train.X, s_test.X)\n",
-    "#         released=0\n",
-    "#         #released = cdf(s_test.X, s_logreg, 0) < r / 10\n",
-    "\n",
-    "#         s_f_rate_caus[i] = np.mean(s_test.B_prob_0_model * released)\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 integrand(x):\n",
-    "#         #    p_y0 = s_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",
-    "#         #s_f_rate_caus[i] = si.quad(lambda x: integrand(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_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_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",
-    "\n",
-    "# x_ax = np.arange(0.1, 0.9, 0.1)\n",
-    "\n",
-    "# plt.errorbar(x_ax,\n",
-    "#              f_rates[:, 0],\n",
-    "#              label='True Evaluation',\n",
-    "#              c='green',\n",
-    "#              yerr=f_sems[:, 0])\n",
-    "# plt.errorbar(x_ax,\n",
-    "#              f_rates[:, 1],\n",
-    "#              label='Labeled outcomes',\n",
-    "#              c='magenta',\n",
-    "#              yerr=f_sems[:, 1])\n",
-    "# plt.errorbar(x_ax,\n",
-    "#              f_rates[:, 2],\n",
-    "#              label='Human evaluation',\n",
-    "#              c='red',\n",
-    "#              yerr=f_sems[:, 2])\n",
-    "# plt.errorbar(x_ax,\n",
-    "#              f_rates[:, 3],\n",
-    "#              label='Contraction, log.',\n",
-    "#              c='blue',\n",
-    "#              yerr=f_sems[:, 3])\n",
-    "# # plt.errorbar(x_ax,\n",
-    "# #              f_rates[:, 4],\n",
-    "# #              label='Causal model, ep',\n",
-    "# #              c='black',\n",
-    "# #              yerr=f_sems[:, 4])\n",
-    "\n",
-    "# plt.title('Failure rate vs. Acceptance rate without unobservables')\n",
-    "# plt.xlabel('Acceptance rate')\n",
-    "# plt.ylabel('Failure rate')\n",
-    "# plt.legend()\n",
-    "# plt.grid()\n",
-    "# plt.show()\n",
-    "\n",
-    "# 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])))"
+    "        f_rate_human[i] = humanEvaluationEvaluator(df_labeled, 'judgeID_J',\n",
+    "                                                   'decision_T', 'result_Y',\n",
+    "                                                   'acceptanceRate_R', r / 10)\n",
+    "\n",
+    "        # Contraction\n",
+    "\n",
+    "        f_rate_cont[i] = contractionEvaluator(df_labeled, 'X', 'judgeID_J',\n",
+    "                                              'decision_T', 'result_Y',\n",
+    "                                              'acceptanceRate_R', r / 10)\n",
+    "\n",
+    "        # Causal model - empirical performance\n",
+    "\n",
+    "        #f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n",
+    "        #                                 'result_Y', r / 10)\n",
+    "\n",
+    "        f_rate_caus[i] = monteCarloEvaluator(df_labeled, 'X', 'decision_T',\n",
+    "                                             'result_Y', 'acceptanceRate_R',\n",
+    "                                             r / 10, N_sim=int(1e5))\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.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',\n",
+    "             c='blue',\n",
+    "             yerr=failure_sems[:, 3])\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 4],\n",
+    "             label='Monte Carlo',\n",
+    "             c='black',\n",
+    "             yerr=failure_sems[:, 4])\n",
+    "\n",
+    "plt.title('Failure rate vs. Acceptance rate without Z (modular)')\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])))"
    ]
   },
   {
@@ -823,7 +934,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 97,
+   "execution_count": 216,
    "metadata": {
     "scrolled": false
    },
@@ -832,44 +943,39 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[1] 0 en loop\n"
+      "[1] 0 1 2 3 4 5 6 7 8 9 [2] 0 1 2 3 4 5 6 7 8 9 [3] 0 1 2 3 4 5 6 7 8 9 [4] 0 1 2 3 4 5 6 7 8 9 [5] 0 1 2 3 4 5 6 7 8 9 [6] 0 1 2 3 4 5 6 7 8 9 [7] 0 1 2 3 4 5 6 7 8 9 [8] 0 1 2 3 4 5 6 7 8 9 "
      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:78: RuntimeWarning: invalid value encountered in long_scalars\n"
-     ]
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "jlk loop\n",
-      "1 en loop\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:78: RuntimeWarning: invalid value encountered in long_scalars\n"
-     ]
-    },
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-97-03cd8a3c6103>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m         f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n\u001b[0;32m---> 67\u001b[0;31m                                          'result_Y', r / 10)\n\u001b[0m\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[0mfailure_rates\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mr\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_rate_true\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m<ipython-input-96-4ef6c6b281a2>\u001b[0m in \u001b[0;36mcausalEvaluator\u001b[0;34m(df, featureX_col, decisionT_col, resultY_col, r)\u001b[0m\n\u001b[1;32m     90\u001b[0m     \u001b[0mtest\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0massign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mB_prob_0_model\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpredictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     91\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 92\u001b[0;31m     \u001b[0mreleased\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcdf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfeatureX_col\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mB_model\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mr\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     94\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mB_prob_0_model\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mreleased\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m<ipython-input-94-f0303c92af6c>\u001b[0m in \u001b[0;36mcdf\u001b[0;34m(x_0, model, class_value)\u001b[0m\n\u001b[1;32m    123\u001b[0m         \u001b[0my_copy\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx_preds\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mprediction_x_0\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    124\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 125\u001b[0;31m         \u001b[0mresults\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_copy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mx_values\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    126\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"jlk loop\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    127\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/scipy/integrate/quadrature.py\u001b[0m in \u001b[0;36msimps\u001b[0;34m(y, x, dx, axis, even)\u001b[0m\n\u001b[1;32m    477\u001b[0m                 \u001b[0mfirst_dx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    478\u001b[0m             \u001b[0mval\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mfirst_dx\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mslice2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mslice1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 479\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0m_basic_simps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    480\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0meven\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'avg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    481\u001b[0m             \u001b[0mval\u001b[0m \u001b[0;34m/=\u001b[0m \u001b[0;36m2.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/scipy/integrate/quadrature.py\u001b[0m in \u001b[0;36m_basic_simps\u001b[0;34m(y, start, stop, x, dx, axis)\u001b[0m\n\u001b[1;32m    358\u001b[0m         \u001b[0mh0divh1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mh0\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mh1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    359\u001b[0m         tmp = hsum/6.0 * (y[slice0]*(2-1.0/h0divh1) +\n\u001b[0;32m--> 360\u001b[0;31m                           \u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mslice1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mhsum\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mhsum\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mhprod\u001b[0m \u001b[0;34m+\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    361\u001b[0m                           y[slice2]*(2-h0divh1))\n\u001b[1;32m    362\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtmp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+      "[[0.019332   0.007024   0.01164503 0.02060147 0.0186    ]\n",
+      " [0.049196   0.01716    0.02757158 0.04587469 0.048304  ]\n",
+      " [0.0849     0.029032   0.05524133 0.0797729  0.083684  ]\n",
+      " [0.12758    0.04208    0.09012099 0.1207086  0.127128  ]\n",
+      " [0.175592   0.055572   0.14012835 0.17227871 0.173824  ]\n",
+      " [0.22782    0.076412   0.19436587 0.22492832 0.227844  ]\n",
+      " [0.285572   0.09602    0.25768682 0.28237595 0.286128  ]\n",
+      " [0.349356   0.107448   0.32420604 0.34169562 0.354052  ]]\n",
+      "\n",
+      "Mean absolute errors:\n",
+      "0.111075\n",
+      "0.02729774880878927\n",
+      "0.004206334614321109\n",
+      "0.0012920000000000015\n"
      ]
     }
    ],
@@ -877,7 +983,7 @@
     "failure_rates = np.zeros((8, 5))\n",
     "failure_sems = np.zeros((8, 5))\n",
     "\n",
-    "nIter = 8\n",
+    "nIter = 10\n",
     "\n",
     "for r in np.arange(1, 9):\n",
     "\n",
@@ -897,7 +1003,7 @@
     "        df = coinFlipDGWithUnobservables()\n",
     "\n",
     "        # Decider\n",
-    "        df_labeled = coinFlipDecider(df,\n",
+    "        df_labeled = quantileDecider(df,\n",
     "                                     featureX_col=\"X\",\n",
     "                                     featureZ_col=\"Z\",\n",
     "                                     nJudges_M=100,\n",
@@ -905,7 +1011,7 @@
     "                                     beta_Z=1,\n",
     "                                     hide_unobserved=True)\n",
     "\n",
-    "        df_unlabeled = coinFlipDecider(df,\n",
+    "        df_unlabeled = quantileDecider(df,\n",
     "                                       featureX_col=\"X\",\n",
     "                                       featureZ_col=\"Z\",\n",
     "                                       nJudges_M=100,\n",
@@ -939,8 +1045,12 @@
     "\n",
     "        # Causal model - empirical performance\n",
     "\n",
-    "        f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n",
-    "                                         'result_Y', r / 10)\n",
+    "        #f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n",
+    "        #                                 'result_Y', r / 10)\n",
+    "\n",
+    "        f_rate_caus[i] = monteCarloEvaluator(df_labeled, 'X', 'decision_T',\n",
+    "                                             'result_Y', 'acceptanceRate_R',\n",
+    "                                             r / 10, N_sim=int(1e5))\n",
     "\n",
     "    failure_rates[r - 1, 0] = np.mean(f_rate_true)\n",
     "    failure_rates[r - 1, 1] = np.mean(f_rate_label)\n",
@@ -973,16 +1083,16 @@
     "             yerr=failure_sems[:, 2])\n",
     "plt.errorbar(x_ax,\n",
     "             failure_rates[:, 3],\n",
-    "             label='Contraction, log.',\n",
+    "             label='Contraction',\n",
     "             c='blue',\n",
     "             yerr=failure_sems[:, 3])\n",
     "plt.errorbar(x_ax,\n",
     "             failure_rates[:, 4],\n",
-    "             label='Causal model, ep',\n",
+    "             label='Monte Carlo',\n",
     "             c='black',\n",
     "             yerr=failure_sems[:, 4])\n",
     "\n",
-    "plt.title('Failure rate vs. Acceptance rate with unobservables')\n",
+    "plt.title('Failure rate vs. Acceptance rate with Z (modular)')\n",
     "plt.xlabel('Acceptance rate')\n",
     "plt.ylabel('Failure rate')\n",
     "plt.legend()\n",
@@ -995,75 +1105,101 @@
     "    print(np.mean(np.abs(failure_rates[:, 0] - failure_rates[:, i])))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bayesian sampling"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "metadata": {
-    "scrolled": true
+    "scrolled": false
    },
    "outputs": [],
    "source": [
-    "import pystan\n",
-    "\n",
-    "code = \"\"\"\n",
-    "functions{\n",
-    "  // below taken from https://discourse.mc-stan.org/t/quantile-function-in-stan/3642/13\n",
-    "  // as Stan doesn't have a quantile function nor supports real-to-int conversion.\n",
-    "  int ub(real x) {\n",
-    "    int ub = 1;\n",
-    "    while (ub < x) ub *= 2;\n",
-    "    return ub;\n",
-    "  }\n",
-    "\n",
-    "  int closest(real x, int a, int b) {\n",
-    "    return fabs(x - a) < fabs(x - b) ? a : b;\n",
-    "  }\n",
-    "\n",
-    "  // L <= x <= U\n",
-    "  int to_int_bsearch(real x, int L, int U);\n",
-    "\n",
-    "  int to_int_bsearch(real x, int L, int U) {\n",
-    "    int mid = (L + U) / 2;\n",
-    "    if (L == U) return L;\n",
-    "    if (L + 1 == U) return closest(x, L, U);\n",
-    "    return x <= mid? to_int_bsearch(x, L, mid) : to_int_bsearch(x, mid, U);\n",
-    "  }\n",
-    "\n",
-    "  int to_int(real x);\n",
-    "\n",
-    "  int to_int(real x) {\n",
-    "    if (fabs(x) >= 2^31) reject(\"to_int arugment must be < 2^31, found x = \", x);\n",
-    "    if (x < 0) return -to_int(-x);\n",
-    "    return to_int_bsearch(x, 0, ub(x));\n",
-    "  }\n",
-    "}\n",
-    "\n",
-    "data {\n",
-    "  int<lower=0> N;\n",
-    "  int<lower=0> N_quantiles;\n",
-    "  real<lower=0, upper=1> r;\n",
-    "  int<lower=0, upper=1> decision[N];\n",
-    "  real X[N];\n",
-    "  real<lower=0, upper=1> quantiles[N_quantiles];\n",
-    "}\n",
-    "\n",
-    "parameters {\n",
-    "  real Z[N];\n",
-    "}\n",
-    "\n",
-    "model {\n",
-    "  Z ~ normal(0, 1);\n",
+    "# import pystan\n",
+    "\n",
+    "# code = \"\"\"\n",
+    "# functions{\n",
+    "#   // below taken from https://discourse.mc-stan.org/t/quantile-function-in-stan/3642/13\n",
+    "#   // as Stan doesn't have a quantile function nor supports real-to-int conversion.\n",
+    "#   int ub(real x) {\n",
+    "#     int ub = 1;\n",
+    "#     while (ub < x) ub *= 2;\n",
+    "#     return ub;\n",
+    "#   }\n",
+    "\n",
+    "#   int closest(real x, int a, int b) {\n",
+    "#     return fabs(x - a) < fabs(x - b) ? a : b;\n",
+    "#   }\n",
+    "\n",
+    "#   // L <= x <= U\n",
+    "#   int to_int_bsearch(real x, int L, int U);\n",
+    "\n",
+    "#   int to_int_bsearch(real x, int L, int U) {\n",
+    "#     int mid = (L + U) / 2;\n",
+    "#     if (L == U) return L;\n",
+    "#     if (L + 1 == U) return closest(x, L, U);\n",
+    "#     return x <= mid? to_int_bsearch(x, L, mid) : to_int_bsearch(x, mid, U);\n",
+    "#   }\n",
+    "\n",
+    "#   int to_int(real x);\n",
+    "\n",
+    "#   int to_int(real x) {\n",
+    "#     if (fabs(x) >= 2^31) reject(\"to_int arugment must be < 2^31, found x = \", x);\n",
+    "#     if (x < 0) return -to_int(-x);\n",
+    "#     return to_int_bsearch(x, 0, ub(x));\n",
+    "#   }\n",
+    "# }\n",
+    "\n",
+    "# data {\n",
+    "#   int<lower=0> N;\n",
+    "#   int<lower=0> N_quantiles;\n",
+    "#   real<lower=0, upper=1> r[N];\n",
+    "#   int<lower=0, upper=1> decision[N];\n",
+    "#   real X[N];\n",
+    "#   real<lower=0, upper=1> quantiles[N_quantiles];\n",
+    "# }\n",
+    "\n",
+    "# parameters {\n",
+    "#   real Z[N];\n",
+    "#   real<lower=0, upper=1> p;\n",
+    "# }\n",
+    "\n",
+    "# model {\n",
+    "#   Z ~ normal(0, 1);\n",
     "  \n",
-    "  for(i in 1:N){\n",
-    "    decision ~ bernoulli(inv_logit(X[i] + Z[i]) >= quantiles[to_int(r*N_quantiles)] ? 1 : 0);\n",
-    "  }\n",
-    "}\n",
-    "\"\"\"\n",
-    "\n",
-    "dat = dict()\n",
-    "\n",
-    "sm = pystan.StanModel(model_code=code)\n",
-    "fit = sm.sampling(data=dat, iter=4000, chains=4)"
+    "#   for(i in 1:N){\n",
+    "#     if (inv_logit(X[i] + Z[i]) <= quantiles[to_int(r[i]*N_quantiles)])\n",
+    "#       decision ~ bernoulli(p);\n",
+    "#     else\n",
+    "#       decision ~ bernoulli(1-p);\n",
+    "#   }\n",
+    "# }\n",
+    "# \"\"\"\n",
+    "# # Create data\n",
+    "# df = coinFlipDGWithUnobservables(N_total=500)\n",
+    "\n",
+    "# # Decider\n",
+    "# df = quantileDecider(df, featureX_col=\"X\", featureZ_col=\"Z\", nJudges_M=10,\n",
+    "#                              beta_X=1, beta_Z=1, hide_unobserved=True)\n",
+    "\n",
+    "# N_sim = int(1e8)\n",
+    "\n",
+    "# quants = inv_logit(npr.normal(size=N_sim) + npr.normal(size=N_sim))\n",
+    "\n",
+    "# dat = dict(N = df.shape[0],\n",
+    "#            N_quantiles = 100001,\n",
+    "#            r = df.acceptanceRate_R,\n",
+    "#            decision = df.decision_T,\n",
+    "#            X = df.X,\n",
+    "#            quantiles = np.quantile(quants, np.linspace(0, 1, 100001)))\n",
+    "\n",
+    "# sm = pystan.StanModel(model_code=code)\n",
+    "# fit = sm.sampling(data=dat, iter=4000, chains=4)"
    ]
   }
  ],
diff --git a/analysis_and_scripts/notes.tex b/analysis_and_scripts/notes.tex
index 3721511..96667c9 100644
--- a/analysis_and_scripts/notes.tex
+++ b/analysis_and_scripts/notes.tex
@@ -1,8 +1,8 @@
 \documentclass[11pt,a4paper]{amsart}
-\usepackage{geometry}                % See geometry.pdf to learn the layout options. There are lots.
+\usepackage[margin=1in]{geometry}                % See geometry.pdf to learn the layout options. There are lots.
 %\geometry{a4paper}                   % ... or letterpaper or a5paper or ... 
 %\geometry{landscape}                % Activate for for rotated page geometry 
-\usepackage[parfill]{parskip}    % Activate to begin paragraphs with an empty line rather than an indent
+%\usepackage[parfill]{parskip}    % Activate to begin paragraphs with an empty line rather than an indent
 \usepackage{graphicx}
 \usepackage{amssymb}
 \usepackage{epstopdf}
@@ -249,29 +249,28 @@ Given the above framework, the goal is to create an evaluation algorithm that ca
 \end{wrapfigure}
 
 \emph{Below is the framework as was written on the whiteboard, then RL presents his own remarks on how he understood this.}
-
+~ \\
 \begin{description}
 
-\item[Data generation:] ~ \\ 
+\item[Data generation:] 
 	~ \\
-	\hskip 3em \textbf{Input:} [none] \\ ~ \\
-			 \textbf{Output:} $X, Z, W, Y$ as specified by $\M$
+	\hskip 3em \textbf{Input:} [none] \\ 
+			 \textbf{Output:} $X, Z, W, Y$ as specified by $\M$~ \\ 
 
-\item[Decider:] single vs. batch \\ 
+\item[Decider:] single vs. batch 
 	~ \\
 	\hskip 3em \textbf{Input:}  
 		\begin{itemize}  
 			\item one defendant 
 			\item $\M$ 
 		\end{itemize} 
-	
 	\textbf{Output:} 
 		\begin{itemize}  
 			\item argmax likelihood  $y$ 
 			\item $\pr(Y=0~|~input)$
-			\item order
+			\item order \\
 		\end{itemize} 
-\item[Evaluator:] ~ \\ 
+\item[Evaluator:] 
 	~ \\
 	\hskip 3em \textbf{Input:} 
 		\begin{itemize}  
@@ -638,17 +637,59 @@ Given our framework defined in section \ref{sec:framework}, the results presente
     \label{fig:random_predictions}
 \end{figure}
 
+\subsection{Modular framework -- Monte Carlo evaluator} \label{sec:modules_mc}
+
+For these results, data was generated with module in algorithm \ref{alg:dg:coinflip_with_z} ("coin-flip results") and decisions were assigned using module in algorithm \ref{alg:decider:quantile}. Curves were computed with algorithms \ref{alg:eval:true_eval}, \ref{alg:eval:labeled_outcomes}, \ref{alg:eval:human_eval}, \ref{alg:eval:contraction} and \ref{alg:eval:mc} are presented in figure \ref{fig:modules_mc}. The corresponding MAEs are presented in table \ref{tab:modules_mc}.
+
+\begin{table}[H]
+\centering
+\caption{Mean absolute error (MAE) w.r.t true evaluation. See modules used in section \ref{sec:modules_mc}}
+\begin{tabular}{l | c c}
+Method & MAE with Z \\ \hline
+Labeled outcomes 	& 0.111075\\
+Human evaluation 	& 0.027298\\
+Contraction 		& 0.004206\\
+Monte Carlo	 	& 0.001292\\
+\end{tabular}
+\label{tab:modules_mc}
+\end{table}
+
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=0.75\textwidth]{sl_with_Z_10iter_coinflip_quantile_defaults_mc}
+    \caption{Failure rate vs. acceptance rate with varying levels of leniency. Data was generated with unobservables. See modules used in section \ref{sec:modules_mc}}
+    \label{fig:modules_mc}
+\end{figure}
+
+%\begin{figure}[H]
+%    \centering
+%    \begin{subfigure}[b]{0.475\textwidth}
+%        \includegraphics[width=\textwidth]{sl_without_Z_10iter_coinflip_quantile_defaults_mc}
+%        \caption{Data without unobservables. PLACEHOLDER}
+%        \label{fig:modules_mc_without_Z}
+%    \end{subfigure}
+%    \quad %add desired spacing between images, e. g. ~, \quad, \qquad, \hfill etc. 
+%      %(or a blank line to force the subfigure onto a new line)
+%    \begin{subfigure}[b]{0.475\textwidth}
+%        \includegraphics[width=\textwidth]{sl_with_Z_10iter_coinflip_quantile_defaults_mc}
+%        \caption{Data with unobservables.}
+%        \label{fig:modules_mc_with_Z}
+%    \end{subfigure}
+%    \caption{Failure rate vs. acceptance rate with varying levels of leniency. See modules used in section \ref{sec:modules_mc}}
+%    \label{fig:modules_mc}
+%\end{figure}z
+
 \section{Modules}
 
 Different types of modules are presented in this section. Summary table is presented last.
 
-\subsection{Data generation modules}
-
-Data generation modules usually take only some generative parameters as input.
+\begin{itemize}
+\item Data generation modules usually take only some generative parameters as input.
+\end{itemize}
 
-\begin{algorithm}[H] 			% enter the algorithm environment
+\begin{algorithm}[] 			% enter the algorithm environment
 \caption{Data generation module: "coin-flip results" without unobservables} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\label{alg:dg:coinflip_without_z} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Parameters: Total number of subjects $N_{total}$
 \ENSURE
@@ -662,9 +703,9 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithm}
 
 
-\begin{algorithm}[H] 			% enter the algorithm environment
+\begin{algorithm}[] 			% enter the algorithm environment
 \caption{Data generation module: "results by threshold" with unobservables} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\label{alg:dg:threshold_with_Z} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Parameters: Total number of subjects $N_{total},~\beta_X=1,~\beta_Z=1$ and $\beta_W=0.2$.
 \ENSURE
@@ -677,9 +718,9 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\begin{algorithm}[H] 			% enter the algorithm environment
+\begin{algorithm}[] 			% enter the algorithm environment
 \caption{Data generation module: "coin-flip results" with unobservables} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\label{alg:dg:coinflip_with_z} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Parameters: Total number of subjects $N_{total},~\beta_X=1,~\beta_Z=1$ and $\beta_W=0.2$.
 \ENSURE
@@ -692,17 +733,15 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\subsection{Decider modules}
-
 %For decider modules, input as terms of knowledge and parameters should be as explicitly specified as possible.
 
-\begin{algorithm}[H] 			% enter the algorithm environment
-\caption{Decider module: human judge as specified by Lakkaraju et al.} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Decider module: human judge as specified by Lakkaraju et al. \cite{lakkaraju17}} 		% give the algorithm a caption
+\label{alg:decider:human} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent / Parameters: $M=100, \beta_X=1, \beta_Z=1$.
 \ENSURE
-\STATE Sample acceptance rates for each M judges from $U(0.1; 0.9)$ and round to tenth decimal place.
+\STATE Sample acceptance rates for each M judges from Uniform$(0.1; 0.9)$ and round to tenth decimal place.
 \STATE Assign each observation to a judge at random.
 \STATE Calculate $P(T=0|X, Z) = \sigma(\beta_XX+\beta_ZZ) + \epsilon$ for each observation and attach to data.
 \STATE Sort the data by (1) the judges' and (2) by probabilities $P(T=0|X, Z)$ in descending order. 
@@ -713,9 +752,9 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\begin{algorithm}[H] 			% enter the algorithm environment
-\caption{Decider module: "coin-flip decisions"} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Decider module: "coin-flip decisions" (pseudo-leniencies set at 0.5)} 		% give the algorithm a caption
+\label{alg:decider:coinflip} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent / Parameters: $\beta_X=1, \beta_Z=1$.
 \ENSURE
@@ -728,11 +767,33 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\subsection{Evaluator modules}
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Decider module: "quantile decisions"} 		% give the algorithm a caption
+\label{alg:decider:quantile} 			% and a label for \ref{} commands later in the document
+\begin{algorithmic}[1] 		% enter the algorithmic environment
+\REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent / Parameters: $\beta_X=1, \beta_Z=1$.
+\ENSURE
+\STATE Sample acceptance rates for each M judges from Uniform$(0.1; 0.9)$ and round to tenth decimal place.
+\STATE Assign each observation to a judge at random.
+\STATE Calculate $\pr(T=0|X, Z) = \sigma(\beta_XX+\beta_ZZ)$ for each observation and attach to data.
+\FORALL{$i$ in $1, \ldots, N_{total}$}
+	\IF{$\sigma(\beta_XX+\beta_ZZ) \geq F^{-1}_{\pr(T=0|X, Z)}(r)$ \footnotemark} % Footnote text below algorithm
+		\STATE {set $t_i=0$} 
+	\ELSE 
+		\STATE{set $t_i=1$} 
+	\ENDIF
+	\STATE Attach to data.
+\ENDFOR 
+\STATE Set $Y=$ NA if decision is negative ($T=0$). \emph{Might not be performed.}
+\RETURN data with decisions.
+\end{algorithmic}
+\end{algorithm}
+
+\footnotetext{The inverse cumulative distribution function (or quantile function) $F^{-1}$ was constructed by first sampling $10^7$ observations from $N(0, 2)$ (sum of two Gaussians) and applying the inverse of logit function $\sigma(x)$. The value of $F^{-1}(r)$ was computed utilizing the previously computed array and numpy's \texttt{quantile} function.}
 
-\begin{algorithm}[H] 			% enter the algorithm environment
+\begin{algorithm}[] 			% enter the algorithm environment
 \caption{Evaluator module: Contraction algorithm \cite{lakkaraju17}} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\label{alg:eval:contraction} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$, acceptance rate r, knowledge that X affects Y
 \ENSURE
@@ -742,16 +803,12 @@ Data generation modules usually take only some generative parameters as input.
 \STATE Let $q$ be the decision-maker with highest acceptance rate in $\D$.
 \STATE $\D_q = \{(x, j, t, y) \in \D|j=q\}$
 \STATE \hskip3.0em $\rhd$ $\D_q$ is the set of all observations judged by $q$
-\STATE
 \STATE $\RR_q = \{(x, j, t, y) \in \D_q|t=1\}$
 \STATE \hskip3.0em $\rhd$ $\RR_q$ is the set of observations in $\D_q$ with observed outcome labels
-\STATE
 \STATE Sort observations in $\RR_q$ in descending order of confidence scores $\s$ and assign to $\RR_q^{sort}$.
 \STATE \hskip3.0em $\rhd$ Observations deemed as high risk by the black-box model $\mathcal{B}$ are at the top of this list
-\STATE
 \STATE Remove the top $[(1.0-r)|\D_q |]-[|\D_q |-|\RR_q |]$ observations of $\RR_q^{sort}$ and call this list $\mathcal{R_B}$
 \STATE \hskip3.0em $\rhd$ $\mathcal{R_B}$ is the list of observations assigned to $t = 1$ by $\mathcal{B}$
-\STATE
 \STATE Compute $\mathbf{u}=\sum_{i=1}^{|\mathcal{R_B}|} \dfrac{\delta\{y_i=0\}}{| \D_q |}$.
 \RETURN $\mathbf{u}$
 \end{algorithmic}
@@ -759,7 +816,7 @@ Data generation modules usually take only some generative parameters as input.
 
 \begin{algorithm}[] 			% enter the algorithm environment
 \caption{Evaluator module: True evaluation} 		% give the algorithm a caption
-%\label{alg:true_eval} 			% and a label for \ref{} commands later in the document
+\label{alg:eval:true_eval} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data $\D$ with properties $\{x_i, t_i, y_i\}$ and \emph{all outcome labels}, acceptance rate r, knowledge that X affects Y
 \ENSURE
@@ -775,7 +832,7 @@ Data generation modules usually take only some generative parameters as input.
 
 \begin{algorithm}[] 			% enter the algorithm environment
 \caption{Evaluator module: Labeled outcomes} 		% give the algorithm a caption
-%\label{alg:labeled_outcomes} 			% and a label for \ref{} commands later in the document
+\label{alg:eval:labeled_outcomes} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data $\D$ with properties $\{x_i, t_i, y_i\}$, acceptance rate r, knowledge that X affects Y
 \ENSURE
@@ -792,7 +849,7 @@ Data generation modules usually take only some generative parameters as input.
 
 \begin{algorithm}[] 			% enter the algorithm environment
 \caption{Evaluator module: Human evaluation} 		% give the algorithm a caption
-%\label{alg:human_eval} 			% and a label for \ref{} commands later in the document
+\label{alg:eval:human_eval} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$, acceptance rate r
 \ENSURE
@@ -804,25 +861,72 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\subsection{Summary}
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Evaluator module: Causal evaluator (?)} 		% give the algorithm a caption
+\label{alg:eval:causal_eval} 			% and a label for \ref{} commands later in the document
+\begin{algorithmic}[1] 		% enter the algorithmic environment
+\REQUIRE Data $\D$ with properties $\{x_i, t_i, y_i\}$, acceptance rate r
+\ENSURE
+\STATE Split data to test set and training set.
+\STATE Train a predictive model $\B$ on training data.
+\STATE Estimate probability scores $\s$ using $\B$ for all observations in test data and attach to test data.
+\FORALL{$i$ in $1, \ldots, N_{total}$}
+	\STATE Evaluate $F(x_i) = \int_{x\in\mathcal{X}} P_X(x)\delta(f(x)<f(x_i)) ~dx$ and assign to $\mathcal{F}_{predictions}$ 
+\ENDFOR
+\STATE Create boolean array $T_{causal} = \mathcal{F}_{predictions} < r$.
+\RETURN $\frac{1}{|\D_{test}|}\sum_{i=1}^{|\D_{test}|} \s_i \cdot T_{i, causal}$ which is equal to $\frac{1}{|\D|}\sum_{x\in\D} f(x)\delta(F(x) < r)$
+\end{algorithmic}
+\end{algorithm}
 
-\begin{table}[H]
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Evaluator module: Monte Carlo evaluator, imputation} 		% give the algorithm a caption
+\label{alg:eval:mc} 			% and a label for \ref{} commands later in the document
+\begin{algorithmic}[1] 		% enter the algorithmic environment
+\REQUIRE Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$, acceptance rate r
+\ENSURE
+\STATE Split data to test set and training set.
+\STATE Train a predictive model $\B$ on training data.
+\STATE Estimate probability scores $\s$ using $\B$ for all observations in test data and attach to test data.
+\STATE Sample $N_{sim}$ observations from a standard Gaussian and assign to Z.
+\STATE Sample $N_{sim}$ observations from sum of two standard Gaussians (N(0, 2)) and assign to \texttt{quants}.
+\STATE Transform the values of the samples in \texttt{quants} using the inverse of logit function.
+\STATE Compute the values of the inverse cdf of the observations in \texttt{quants} for the acceptance rates r of each judge and assign to $Q_r$.
+\FORALL{$i$ in $1, \ldots, N_{test}$}
+	\IF{$t_i = 0$}
+		\STATE {Take all $Z > logit(Q_{r,i})-x_i$ \footnotemark} 
+	\ELSE 
+		\STATE{Take all $Z < logit(Q_{r,i})-x_i$}
+	\ENDIF
+	\STATE Draw predictions $\hat{p}_{i,y}$ from Bernoulli($1-logit^{-1}(x_i+\bar{Z})$).
+\ENDFOR
+\STATE Impute missing observations using $\hat{p}_y$.
+\STATE Sort the data by the probabilities $\s$ to ascending order.
+\STATE \hskip3.0em $\rhd$ Now the most dangerous subjects are last.
+\STATE Calculate the number to release $N_{free} = |\D_{test}| \cdot r$.
+\RETURN Compute $\frac{1}{|\D_{test}|}\sum_{i=1}^{N_{free}}\delta\{y_i=0\}$ using the observed and imputed observations.
+\end{algorithmic}
+\end{algorithm}
+
+\footnotetext{$logit^{-1}(x+z)>a \Leftrightarrow x+z > logit(a) \Leftrightarrow z > logit(a)-x$}
+
+\begin{table}[h!]
   \centering
+  \caption{Summary of modules (under construction)}
   \begin{tabular}{lll}
     \toprule
     \multicolumn{3}{c}{Module type} \\[.5\normalbaselineskip]
     \textbf{Data generator} & \textbf{Decider} & \textbf{Evaluator}  \\
     \midrule
-    Without unobservables			& Independent decisions	& {\ul Labeled outcomes} \\
-     					 		& \tabitem $P(T=0|X, Z)$	& \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
-    With unobservables        		& \tabitem "threshold rule"	& \tabitem acceptance rate r \\
-    \tabitem $P(Y=0|X, Z, W)$ 		& 					& \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+    {\ul Without unobservables}		& Independent decisions		& {\ul Labeled outcomes} \\
+     					 		& 1. flip a coin by 			& \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
+    {\ul With unobservables}       		& $P(T=0|X, Z)$			& \tabitem acceptance rate r \\
+    \tabitem $P(Y=0|X, Z, W)$ 		& 2. determine with $F^{-1}(r)$	& \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
     
-     With unobservables 		&   & {\ul True evaluation} \\
-     \tabitem "threshold rule"	&   & \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
-     						&   & and \emph{all outcome labels} \\
-     						&   & \tabitem acceptance rate r \\
-     						&   & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+     {\ul With unobservables}	& Non-independent decisions  	& {\ul True evaluation} \\
+     \tabitem assign Y by		& 3. sort by $P(T=0|X, Z)$		& \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
+     "threshold rule"			& and assign $t$ by $r$  		& and \emph{all outcome labels} \\
+     						&   						& \tabitem acceptance rate r \\
+     						&   						& \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
      
      &  & {\ul Human evaluation} \\
      &  & \tabitem Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$ \\
@@ -837,10 +941,14 @@ Data generation modules usually take only some generative parameters as input.
      &  & \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
      &  & \tabitem acceptance rate r \\
      &  & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+     
+     &  & {\ul Monte Carlo evaluator} \\
+     &  & \tabitem Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$ \\
+     &  & \tabitem acceptance rate r \\
+     &  & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
     \bottomrule
   \end{tabular}
-  \caption{Summary table of modules (under construction)}
-  \label{tab:jotain}
+  \label{tab:modules}
 \end{table}
 
 \begin{thebibliography}{9}
diff --git a/figures/sl_with_Z_10iter_coinflip_quantile_defaults_mc.png b/figures/sl_with_Z_10iter_coinflip_quantile_defaults_mc.png
new file mode 100644
index 0000000000000000000000000000000000000000..33df95cc24abfecaa60fb0e241033f236d3dfa58
GIT binary patch
literal 51053
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%0DHDmZrekxq&x_)6weWC8;gw5)?*V)tc0n8;|
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
K;6E!{hyP#CWP|Pi

literal 0
HcmV?d00001

-- 
GitLab