From 92707b9ad34fe77b17f876ae549ffd7753508dd2 Mon Sep 17 00:00:00 2001
From: Riku-Laine <28960190+Riku-Laine@users.noreply.github.com>
Date: Tue, 7 May 2019 10:07:11 +0300
Subject: [PATCH] Renamed files
---
.../Analysis_07MAY2019_new.ipynb | 645 ++++++++++++++++++
...nb => Bachelors_thesis_analyses_OLD.ipynb} | 0
analysis_and_scripts/Untitled.ipynb | 587 ----------------
3 files changed, 645 insertions(+), 587 deletions(-)
create mode 100644 analysis_and_scripts/Analysis_07MAY2019_new.ipynb
rename analysis_and_scripts/{Bachelors_thesis_analyses.ipynb => Bachelors_thesis_analyses_OLD.ipynb} (100%)
delete mode 100644 analysis_and_scripts/Untitled.ipynb
diff --git a/analysis_and_scripts/Analysis_07MAY2019_new.ipynb b/analysis_and_scripts/Analysis_07MAY2019_new.ipynb
new file mode 100644
index 0000000..aabbd42
--- /dev/null
+++ b/analysis_and_scripts/Analysis_07MAY2019_new.ipynb
@@ -0,0 +1,645 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "toc": true
+ },
+ "source": [
+ "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
+ "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Causal-model\" data-toc-modified-id=\"Causal-model-1\"><span class=\"toc-item-num\">1 </span>Causal model</a></span><ul class=\"toc-item\"><li><span><a href=\"#Notes\" data-toc-modified-id=\"Notes-1.1\"><span class=\"toc-item-num\">1.1 </span>Notes</a></span></li></ul></li><li><span><a href=\"#Synthetic-data\" data-toc-modified-id=\"Synthetic-data-2\"><span class=\"toc-item-num\">2 </span>Synthetic data</a></span></li><li><span><a href=\"#Algorithms\" data-toc-modified-id=\"Algorithms-3\"><span class=\"toc-item-num\">3 </span>Algorithms</a></span><ul class=\"toc-item\"><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-3.1\"><span class=\"toc-item-num\">3.1 </span>Contraction algorithm</a></span></li><li><span><a href=\"#Causal-algorithm\" data-toc-modified-id=\"Causal-algorithm-3.2\"><span class=\"toc-item-num\">3.2 </span>Causal algorithm</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-4\"><span class=\"toc-item-num\">4 </span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Predictive-models\" data-toc-modified-id=\"Predictive-models-4.1\"><span class=\"toc-item-num\">4.1 </span>Predictive models</a></span></li><li><span><a href=\"#Visual-comparison\" data-toc-modified-id=\"Visual-comparison-4.2\"><span class=\"toc-item-num\">4.2 </span>Visual comparison</a></span></li></ul></li></ul></div>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Causal model\n",
+ "\n",
+ "Our model is defined by the probabilistic expression \n",
+ "\n",
+ "\\begin{equation}\\label{model_disc}\n",
+ "P(Y=0 | \\text{do}(R=r)) = \\sum_x \\underbrace{P(Y=0|X=x, T=1)}_\\text{1} \n",
+ "\\overbrace{P(T=1|R=r, X=x)}^\\text{2} \n",
+ "\\underbrace{P(X=x)}_\\text{3}\n",
+ "\\end{equation}\n",
+ "\n",
+ "which is equal to \n",
+ "\n",
+ "\\begin{equation}\\label{model_cont}\n",
+ "P(Y=0 | \\text{do}(R=r)) = \\int_x P(Y=0|X=x, T=1)P(T=1|R=r, X=x)P(X=x)\n",
+ "\\end{equation}\n",
+ "\n",
+ "for continuous $x$. Model as a graph (Z is a latent variable, and can be excluded from the expression with do-calculus by showing that $X$ is admissible for adjustment):\n",
+ "\n",
+ "<!--- ![Model as picture](../figures/intervention_model.png \"Intervention model\") --->\n",
+ "\n",
+ "For predicting the probability of negative outcome the following should hold because by Pearl $P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0 | R=r, X=x)$ when $X$ is an admissible set:\n",
+ "\n",
+ "\\begin{equation} \\label{model_pred}\n",
+ "P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0|X=x, T=1)P(T=1|R=r, X=x).\n",
+ "\\end{equation}\n",
+ "\n",
+ "Still it should be noted that this prediction takes into account the probability of the individual to be given a positive decision ($T=1$), see second term in \\ref{model_pred}.\n",
+ "\n",
+ "----\n",
+ "\n",
+ "### Notes\n",
+ "\n",
+ "* Equations \\ref{model_disc} and \\ref{model_cont} describe the whole causal effect in the population (the causal effect of changing $r$ over all strata $X$).\n",
+ "* Prediction should be possible with \\ref{model_pred}. Both terms can be learned from the data. NB: the probability $P(Y=0 | \\text{do}(R=r), X=x)$ is lowest when the individual $x$ is the most dangerous or the least dangerous. How could we infer/predict the counterfactual \"what is the probability of $Y=0$ if we were to let this individual go?\" has yet to be calculated.\n",
+ "* Is the effect of R learned/estimated correctly if it is just plugged in to a predictive model (e.g. logistic regression)?\n",
+ "* $P(Y=0 | do(R=0)) = 0$ only in this application. My predictive models say that when $r=0$ the probability $P(Y=0) \\approx 0.027$ which would be a natural estimate in another application/scenario (e.g. in medicine the probability of an adverse event when a stronger medicine is distributed to everyone. Then the probability will be close to zero but not exactly zero.)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 89,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Imports\n",
+ "\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "from datetime import datetime\n",
+ "import matplotlib.pyplot as plt\n",
+ "import scipy.stats as scs\n",
+ "import scipy.integrate as si\n",
+ "import seaborn as sns\n",
+ "import numpy.random as npr\n",
+ "from sklearn.preprocessing import OneHotEncoder\n",
+ "from sklearn.linear_model import LogisticRegression\n",
+ "from sklearn.ensemble import RandomForestClassifier\n",
+ "\n",
+ "# Settings\n",
+ "\n",
+ "%matplotlib inline\n",
+ "\n",
+ "plt.rcParams.update({'font.size': 16})\n",
+ "plt.rcParams.update({'figure.figsize': (14, 7)})\n",
+ "\n",
+ "# Suppress deprecation warnings.\n",
+ "\n",
+ "import warnings\n",
+ "\n",
+ "def fxn():\n",
+ " warnings.warn(\"deprecated\", DeprecationWarning)\n",
+ "\n",
+ "with warnings.catch_warnings():\n",
+ " warnings.simplefilter(\"ignore\")\n",
+ " fxn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Synthetic data\n",
+ "\n",
+ "In the chunk below, we generate the synthetic data as described by Lakkaraju et al. The default values and definitions of $Y$ and $T$ values follow their description.\n",
+ "\n",
+ "**Parameters**\n",
+ "\n",
+ "* M = `nJudges_M`, number of judges\n",
+ "* N = `nSubjects_N`, number of subjects assigned to each judge\n",
+ "* betas $\\beta_i$ = `beta_i`, where $i \\in \\{X, Z, W\\}$ are coefficients for the respected variables\n",
+ "\n",
+ "**Columns of the data:**\n",
+ "\n",
+ "* `judgeID_J` = judge IDs as running numbering from 0 to `nJudges_M - 1`\n",
+ "* R = `acceptanceRate_R`, acceptance rates\n",
+ "* X = `X`, invidual's features observable to all (models and judges)\n",
+ "* Z = `Z`, information observable for judges only\n",
+ "* W = `W`, unobservable / inaccessible information\n",
+ "* T = `decision_T`, bail-or-jail decisions where $T=0$ represents jail decision and $T=1$ bail decision.\n",
+ "* Y = `result_Y`, result variable, if $Y=0$ person will or would recidivate and if $Y=1$ person will or would not commit a crime."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 90,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set seed for reproducibility\n",
+ "#npr.seed(0)\n",
+ "\n",
+ "def generateData(nJudges_M=100,\n",
+ " nSubjects_N=500,\n",
+ " beta_X=1.0,\n",
+ " beta_Z=1.0,\n",
+ " beta_W=0.2):\n",
+ "\n",
+ " # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
+ " judgeID_J = np.repeat(np.arange(0, nJudges_M, dtype=np.int32), 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",
+ " acceptanceRate_R = np.repeat(acceptance_rates, nSubjects_N)\n",
+ "\n",
+ " # Sample the variables from standard Gaussian distributions.\n",
+ " X = npr.normal(size=nJudges_M * nSubjects_N)\n",
+ " Z = npr.normal(size=nJudges_M * nSubjects_N)\n",
+ " W = npr.normal(size=nJudges_M * nSubjects_N)\n",
+ "\n",
+ " probabilities_Y = 1 / (1 + np.exp(-(beta_X * X + beta_Z * Z + beta_W * W)))\n",
+ "\n",
+ " # 0 if P(Y = 0| X = x; Z = z; W = w) >= 0.5 , 1 otherwise\n",
+ " result_Y = 1 - probabilities_Y.round()\n",
+ " \n",
+ " # For the conditional probabilities of T we add noise ~ N(0, 0.1)\n",
+ " probabilities_T = 1 / (1 + np.exp(-(beta_X * X + beta_Z * Z)))\n",
+ " probabilities_T += npr.normal(0, np.sqrt(0.1), nJudges_M * nSubjects_N)\n",
+ "\n",
+ " # Initialize decision values as 1\n",
+ " decision_T = np.ones(nJudges_M * nSubjects_N)\n",
+ "\n",
+ " # Initialize the dataframe\n",
+ " df_init = pd.DataFrame(np.column_stack(\n",
+ " (judgeID_J, acceptanceRate_R, X, Z, W, result_Y, probabilities_T,\n",
+ " decision_T)),\n",
+ " columns=[\n",
+ " \"judgeID_J\", \"acceptanceRate_R\", \"X\", \"Z\", \"W\",\n",
+ " \"result_Y\", \"probabilities_T\", \"decision_T\"\n",
+ " ])\n",
+ "\n",
+ " # Sort by judges then probabilities\n",
+ " data = df_init.sort_values(by=[\"judgeID_J\", \"probabilities_T\"],\n",
+ " ascending=False)\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",
+ " data.reset_index(drop=True, inplace=True)\n",
+ "\n",
+ " data['decision_T'] = np.where(\n",
+ " (data.index.values % nSubjects_N) <\n",
+ " ((1 - data['acceptanceRate_R']) * nSubjects_N), 0, 1)\n",
+ "\n",
+ " return data\n",
+ "\n",
+ "\n",
+ "df = generateData()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 91,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(25000, 8)\n",
+ "(25000, 8)\n",
+ "(25000, 8)\n",
+ "(25000, 8)\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "<div>\n",
+ "<style scoped>\n",
+ " .dataframe tbody tr th:only-of-type {\n",
+ " vertical-align: middle;\n",
+ " }\n",
+ "\n",
+ " .dataframe tbody tr th {\n",
+ " vertical-align: top;\n",
+ " }\n",
+ "\n",
+ " .dataframe thead th {\n",
+ " text-align: right;\n",
+ " }\n",
+ "</style>\n",
+ "<table border=\"1\" class=\"dataframe\">\n",
+ " <thead>\n",
+ " <tr style=\"text-align: right;\">\n",
+ " <th>decision_T</th>\n",
+ " <th>1</th>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>result_Y</th>\n",
+ " <th></th>\n",
+ " </tr>\n",
+ " </thead>\n",
+ " <tbody>\n",
+ " <tr>\n",
+ " <th>0.0</th>\n",
+ " <td>3911</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>1.0</th>\n",
+ " <td>8759</td>\n",
+ " </tr>\n",
+ " </tbody>\n",
+ "</table>\n",
+ "</div>"
+ ],
+ "text/plain": [
+ "decision_T 1\n",
+ "result_Y \n",
+ "0.0 3911\n",
+ "1.0 8759"
+ ]
+ },
+ "execution_count": 91,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Split the data set to test and train\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "train, test = train_test_split(df, test_size=0.5, random_state=0)\n",
+ "\n",
+ "print(train.shape)\n",
+ "print(test.shape)\n",
+ "\n",
+ "train_labeled = train.copy()\n",
+ "test_labeled = test.copy()\n",
+ "\n",
+ "# Set results as NA if decision is negative.\n",
+ "train_labeled.result_Y = np.where(train.decision_T == 0, np.nan, train.result_Y)\n",
+ "test_labeled.result_Y = np.where(test.decision_T == 0, np.nan, test.result_Y)\n",
+ "\n",
+ "print(train_labeled.shape)\n",
+ "print(test_labeled.shape)\n",
+ "\n",
+ "tab = train_labeled.groupby(['result_Y', 'decision_T']).size()\n",
+ "tab.unstack()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Algorithms\n",
+ "\n",
+ "### Contraction algorithm\n",
+ "\n",
+ "Below is an implementation of Lakkaraju's team's algorithm presented in [their paper](https://helka.finna.fi/PrimoRecord/pci.acm3098066). Relevant parameters to be passed to the function are presented in the description."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 92,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def contraction(df,\n",
+ " judgeIDJ_col,\n",
+ " decisionT_col,\n",
+ " resultY_col,\n",
+ " modelProbS_col,\n",
+ " accRateR_col,\n",
+ " r,\n",
+ " binning=False):\n",
+ " '''\n",
+ " This is an implementation of the algorithm presented by Lakkaraju\n",
+ " et al. in their paper \"The Selective Labels Problem: Evaluating \n",
+ " Algorithmic Predictions in the Presence of Unobservables\" (2017).\n",
+ " \n",
+ " Parameters:\n",
+ " df = The (Pandas) data frame containing the data, judge decisions,\n",
+ " judge IDs, results and probability scores.\n",
+ " judgeIDJ_col = String, the name of the column containing the judges' IDs\n",
+ " in df.\n",
+ " decisionT_col = String, the name of the column containing the judges' decisions\n",
+ " resultY_col = String, the name of the column containing the realization\n",
+ " modelProbS_col = String, the name of the column containing the probability\n",
+ " scores from the black-box model B.\n",
+ " accRateR_col = String, the name of the column containing the judges' \n",
+ " acceptance rates\n",
+ " r = Float between 0 and 1, the given acceptance rate.\n",
+ " binning = Boolean, should judges with same acceptance rate be binned\n",
+ " \n",
+ " Returns:\n",
+ " u = The estimated failure rate at acceptance rate r.\n",
+ " '''\n",
+ " # Sort first by acceptance rate and judge ID.\n",
+ " sorted_df = df.sort_values(by=[accRateR_col, judgeIDJ_col],\n",
+ " ascending=False)\n",
+ "\n",
+ " if binning:\n",
+ " # Get maximum leniency\n",
+ " max_leniency = sorted_df[accRateR_col].values[0].round(1)\n",
+ "\n",
+ " # Get list of judges that are the most lenient\n",
+ " most_lenient_list = sorted_df.loc[sorted_df[accRateR_col].round(1) ==\n",
+ " max_leniency, judgeIDJ_col]\n",
+ "\n",
+ " # Subset to obtain D_q\n",
+ " D_q = sorted_df[sorted_df[judgeIDJ_col].isin(\n",
+ " most_lenient_list.unique())].copy()\n",
+ " else:\n",
+ " # Get most lenient judge\n",
+ " most_lenient_ID = sorted_df[judgeIDJ_col].values[0]\n",
+ "\n",
+ " # Subset\n",
+ " D_q = sorted_df[sorted_df[judgeIDJ_col] == most_lenient_ID].copy()\n",
+ "\n",
+ " # All observations of R_q have observed outcome labels\n",
+ " R_q = D_q[D_q[decisionT_col] == 1]\n",
+ "\n",
+ " # \"Observations deemed as high risk by B are at the top of this list\"\n",
+ " R_sort_q = R_q.sort_values(by=modelProbS_col, ascending=False)\n",
+ "\n",
+ " number_to_remove = int(\n",
+ " round((1.0 - r) * D_q.shape[0] - (D_q.shape[0] - R_q.shape[0])))\n",
+ "\n",
+ " # \"R_B is the list of observations assigned to t = 1 by B\"\n",
+ " R_B = R_sort_q[number_to_remove:R_sort_q.shape[0]]\n",
+ "\n",
+ " return np.sum(R_B[resultY_col] == 0) / D_q.shape[0]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Causal algorithm\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 93,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def f(x, model, class_value):\n",
+ " '''\n",
+ " Parameters:\n",
+ " x = individual features\n",
+ " model = a trained sklearn predictive model. Predicts probabilities for given x.\n",
+ " class_value = the result (class) to predict (usually 0 or 1).\n",
+ " \n",
+ " Returns:\n",
+ " The probabilities (as vector) of class value (class_value) given \n",
+ " individual features (x) and the trained, predictive model (model).\n",
+ " '''\n",
+ " if x.ndim == 1:\n",
+ " # if x is vector, transform to column matrix.\n",
+ " f_values = model.predict_proba(np.array(x).reshape(-1, 1))\n",
+ " else:\n",
+ " f_values = model.predict_proba(x)\n",
+ "\n",
+ " return f_values[:, model.classes_ == class_value].flatten()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Performance comparison\n",
+ "\n",
+ "Below we try to replicate the results obtained by Lakkaraju and compare their model's performance to the one of ours.\n",
+ "\n",
+ "### Predictive models\n",
+ "\n",
+ "Lakkaraju says that they used logistic regression. We construct the models using only *observed observations*, i.e. observations for which labels are available. We then predict the probability of negative outcome for all observations in the test data and attach it to our data set."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 94,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# instantiate the model (using the default parameters)\n",
+ "logreg = LogisticRegression(solver='lbfgs')\n",
+ "\n",
+ "# fit, reshape X to be of shape (n_samples, n_features)\n",
+ "logreg = logreg.fit(\n",
+ " train_labeled.X[train_labeled.decision_T == 1].values.reshape(-1, 1),\n",
+ " train_labeled.result_Y[train_labeled.decision_T == 1])\n",
+ "\n",
+ "# predict probabilities and attach to data\n",
+ "label_probs_logreg = logreg.predict_proba(test.X.values.reshape(-1, 1))\n",
+ "\n",
+ "test = test.assign(B_prob_0_logreg=label_probs_logreg[:, 0])\n",
+ "test_labeled = test_labeled.assign(B_prob_0_logreg=label_probs_logreg[:, 0])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 95,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Train model for predicting the probability of positive decision with a given\n",
+ "# leniency r and indivual features x.\n",
+ "\n",
+ "# Instantiate the model (using the default parameters)\n",
+ "decision_model = LogisticRegression(solver='lbfgs')\n",
+ "\n",
+ "# fit, reshape X to be of shape (n_samples, n_features)\n",
+ "decision_model = decision_model.fit(train[['X', 'acceptanceRate_R']],\n",
+ " train.decision_T)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Visual comparison\n",
+ "\n",
+ "Let's plot the failure rates against the acceptance rates using the difference."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 96,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 1008x576 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "failure_rates = np.zeros((8, 5))\n",
+ "\n",
+ "for r in np.arange(1, 9):\n",
+ " \n",
+ " #### True evaluation\n",
+ " # Sort by failure probabilities, subjects with the smallest risk are first. \n",
+ " df_sorted = test.sort_values(by='B_prob_0_logreg', inplace=False, \n",
+ " ascending=True)\n",
+ "\n",
+ " to_release = int(round(df_sorted.shape[0] * r / 10))\n",
+ "\n",
+ " # Failure was coded as zero.\n",
+ " failure_rates[r - 1, 0] = np.mean(df_sorted.result_Y[0:to_release] == 0)\n",
+ " \n",
+ " #### Labeled outcomes only\n",
+ " # Sort by failure probabilities, subjects with the smallest risk are first. \n",
+ " df_sorted = test_labeled.sort_values(by='B_prob_0_logreg', inplace=False,\n",
+ " ascending=True)\n",
+ " \n",
+ " # Ensure that only labeled outcomes are available\n",
+ " df_sorted = df_sorted[df_sorted.decision_T == 1]\n",
+ " \n",
+ " to_release = int(round(df_sorted.shape[0] * r / 10))\n",
+ "\n",
+ " failure_rates[r - 1, 1] = np.mean(df_sorted.result_Y[0:to_release] == 0)\n",
+ " \n",
+ " #### Human error rate\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[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",
+ " failure_rates[r - 1, 2] = np.sum(\n",
+ " released.result_Y == 0) / correct_leniency_list.shape[0]\n",
+ " # onko jakaja oikein\n",
+ " \n",
+ " #### Contraction, logistic regression\n",
+ " failure_rates[r - 1, 3] = contraction(\n",
+ " test_labeled, 'judgeID_J', 'decision_T', 'result_Y', 'B_prob_0_logreg',\n",
+ " 'acceptanceRate_R', r / 10, False)\n",
+ "\n",
+ " #### P(Y=0 | T=1, X=x)*P(T=1 | R=r, X=x)*P(X=x)\n",
+ " failure_rates[r - 1, 4] = si.quad(lambda x: f(np.array([x]), logreg, 0) * \n",
+ " f(np.array([[x, r/10]]), decision_model, 1) * \n",
+ " scs.norm.pdf(x), -np.inf, np.inf)[0]\n",
+ "\n",
+ "# Error bars TBA\n",
+ "\n",
+ "plt.figure(figsize=(14, 8))\n",
+ "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 0], label='True Evaluation', c='green')\n",
+ "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 1], label='Labeled outcomes', c='lime')\n",
+ "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 2], label='Human evaluation', c='red')\n",
+ "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 3], label='Contraction, log.', c='blue')\n",
+ "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 4], label='Causal effect', c='magenta')\n",
+ "\n",
+ "plt.title('Failure rate vs. Acceptance rate')\n",
+ "plt.xlabel('Acceptance rate')\n",
+ "plt.ylabel('Failure rate')\n",
+ "plt.legend()\n",
+ "plt.grid()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 97,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0.0 (0.018718463137853268, 7.749450073818988e-11)\n",
+ "1.0 (0.33301477999280144, 6.337618003666896e-09)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Below are estimates for P(Y=0 | do(R=0)) and P(Y=0 | do(R=1))\n",
+ "r = 0.0\n",
+ "print(r, si.quad(lambda x: f(np.array([[x, r]]), decision_model, 1) * \\\n",
+ " f(np.array([x]), logreg, 0) * scs.norm.pdf(x), -np.inf, np.inf))\n",
+ "\n",
+ "r = 1.0\n",
+ "print(r, si.quad(lambda x: f(np.array([[x, r]]), decision_model, 1) * \\\n",
+ " f(np.array([x]), logreg, 0) * scs.norm.pdf(x), -np.inf, np.inf))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "So it can be concluded that:\n",
+ "\n",
+ "\\begin{equation*}\n",
+ "P(Y=0 | \\text{do}(R=0)) \\approx 0.018 \\\\\n",
+ "P(Y=0 | \\text{do}(R=1)) \\approx 0.340 \\\\\n",
+ "\\end{equation*}"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.0"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": true,
+ "sideBar": true,
+ "skip_h1_title": true,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": true,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": true
+ },
+ "varInspector": {
+ "cols": {
+ "lenName": 16,
+ "lenType": 16,
+ "lenVar": 40
+ },
+ "kernels_config": {
+ "python": {
+ "delete_cmd_postfix": "",
+ "delete_cmd_prefix": "del ",
+ "library": "var_list.py",
+ "varRefreshCmd": "print(var_dic_list())"
+ },
+ "r": {
+ "delete_cmd_postfix": ") ",
+ "delete_cmd_prefix": "rm(",
+ "library": "var_list.r",
+ "varRefreshCmd": "cat(var_dic_list()) "
+ }
+ },
+ "types_to_exclude": [
+ "module",
+ "function",
+ "builtin_function_or_method",
+ "instance",
+ "_Feature"
+ ],
+ "window_display": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/analysis_and_scripts/Bachelors_thesis_analyses.ipynb b/analysis_and_scripts/Bachelors_thesis_analyses_OLD.ipynb
similarity index 100%
rename from analysis_and_scripts/Bachelors_thesis_analyses.ipynb
rename to analysis_and_scripts/Bachelors_thesis_analyses_OLD.ipynb
diff --git a/analysis_and_scripts/Untitled.ipynb b/analysis_and_scripts/Untitled.ipynb
deleted file mode 100644
index 9bc5b75..0000000
--- a/analysis_and_scripts/Untitled.ipynb
+++ /dev/null
@@ -1,587 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "toc": true
- },
- "source": [
- "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
- "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Causal-model\" data-toc-modified-id=\"Causal-model-1\"><span class=\"toc-item-num\">1 </span>Causal model</a></span><ul class=\"toc-item\"><li><span><a href=\"#Notes\" data-toc-modified-id=\"Notes-1.1\"><span class=\"toc-item-num\">1.1 </span>Notes</a></span></li></ul></li><li><span><a href=\"#Algorithms\" data-toc-modified-id=\"Algorithms-2\"><span class=\"toc-item-num\">2 </span>Algorithms</a></span><ul class=\"toc-item\"><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-2.1\"><span class=\"toc-item-num\">2.1 </span>Contraction algorithm</a></span></li><li><span><a href=\"#Causal-algorithm\" data-toc-modified-id=\"Causal-algorithm-2.2\"><span class=\"toc-item-num\">2.2 </span>Causal algorithm</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-3\"><span class=\"toc-item-num\">3 </span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Predictive-models\" data-toc-modified-id=\"Predictive-models-3.1\"><span class=\"toc-item-num\">3.1 </span>Predictive models</a></span></li><li><span><a href=\"#Visual-comparison\" data-toc-modified-id=\"Visual-comparison-3.2\"><span class=\"toc-item-num\">3.2 </span>Visual comparison</a></span></li></ul></li></ul></div>"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Causal model\n",
- "\n",
- "Our model is defined by the probabilistic expression \n",
- "\n",
- "\\begin{equation}\\label{model_disc}\n",
- "P(Y=0 | \\text{do}(R=r)) = \\sum_x \\underbrace{P(Y=0|X=x, T=1)}_\\text{1} \n",
- "\\overbrace{P(T=1|R=r, X=x)}^\\text{2} \n",
- "\\underbrace{P(X=x)}_\\text{3}\n",
- "\\end{equation}\n",
- "\n",
- "which is equal to \n",
- "\n",
- "\\begin{equation}\\label{model_cont}\n",
- "P(Y=0 | \\text{do}(R=r)) = \\int_x P(Y=0|X=x, T=1)P(T=1|R=r, X=x)P(X=x)\n",
- "\\end{equation}\n",
- "\n",
- "for continuous $x$. Model as a graph (Z is a latent variable, and can be excluded from the expression with do-calculus by showing that $X$ is admissible for adjustment):\n",
- "\n",
- "<!--- ![Model as picture](../figures/intervention_model.png \"Intervention model\") --->\n",
- "\n",
- "For predicting the probability of negative outcome the following should hold because by Pearl $P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0 | R=r, X=x)$ when $X$ is an admissible set:\n",
- "\n",
- "\\begin{equation} \\label{model_pred}\n",
- "P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0|X=x, T=1)P(T=1|R=r, X=x).\n",
- "\\end{equation}\n",
- "\n",
- "Still it should be noted that this prediction takes into account the probability of the individual to be given a positive decision ($T=1$), see second term in \\ref{model_pred}.\n",
- "\n",
- "----\n",
- "\n",
- "### Notes\n",
- "\n",
- "* Equations \\ref{model_disc} and \\ref{model_cont} describe the whole causal effect in the population (the causal effect of changing $r$ over all strata $X$).\n",
- "* Prediction should be possible with \\ref{model_pred}. Both terms can be learned from the data. NB: the probability $P(Y=0 | \\text{do}(R=r), X=x)$ is lowest when the individual $x$ is the most dangerous or the least dangerous. How could we infer/predict the counterfactual \"what is the probability of $Y=0$ if we were to let this individual go?\" has yet to be calculated.\n",
- "* Is the effect of R learned/estimated correctly if it is just plugged in to a predictive model (e.g. logistic regression)?\n",
- "* $P(Y=0 | do(R=0)) = 0$ only in this application. My predictive models say that when $r=0$ the probability $P(Y=0) \\approx 0.027$ which would be a natural estimate in another application/scenario (e.g. in medicine the probability of an adverse event when a stronger medicine is distributed to everyone. Then the probability will be close to zero but not exactly zero.)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
- " from numpy.core.umath_tests import inner1d\n"
- ]
- }
- ],
- "source": [
- "# Imports\n",
- "\n",
- "import numpy as np\n",
- "import pandas as pd\n",
- "from datetime import datetime\n",
- "import matplotlib.pyplot as plt\n",
- "import scipy.stats as scs\n",
- "import scipy.integrate as si\n",
- "import seaborn as sns\n",
- "import numpy.random as npr\n",
- "from sklearn.preprocessing import OneHotEncoder\n",
- "from sklearn.linear_model import LogisticRegression\n",
- "from sklearn.ensemble import RandomForestClassifier\n",
- "\n",
- "# Settings\n",
- "\n",
- "%matplotlib inline\n",
- "\n",
- "plt.rcParams.update({'font.size': 16})\n",
- "plt.rcParams.update({'figure.figsize': (14, 7)})\n",
- "\n",
- "# Suppress deprecation warnings.\n",
- "\n",
- "import warnings\n",
- "\n",
- "def fxn():\n",
- " warnings.warn(\"deprecated\", DeprecationWarning)\n",
- "\n",
- "with warnings.catch_warnings():\n",
- " warnings.simplefilter(\"ignore\")\n",
- " fxn()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Set seed for reproducibility\n",
- "npr.seed(0)\n",
- "\n",
- "def generateData(nJudges_M=100,\n",
- " nSubjects_N=500,\n",
- " beta_X=1.0,\n",
- " beta_Z=1.0,\n",
- " beta_W=0.2):\n",
- "\n",
- " # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
- " judgeID_J = np.repeat(np.arange(0, nJudges_M, dtype=np.int32), 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",
- " acceptanceRate_R = np.repeat(acceptance_rates, nSubjects_N)\n",
- "\n",
- " # Sample the variables from standard Gaussian distributions.\n",
- " X = npr.normal(size=nJudges_M * nSubjects_N)\n",
- " Z = npr.normal(size=nJudges_M * nSubjects_N)\n",
- " W = npr.normal(size=nJudges_M * nSubjects_N)\n",
- "\n",
- " probabilities_Y = 1 / (1 + np.exp(-(beta_X * X + beta_Z * Z + beta_W * W)))\n",
- "\n",
- " # 0 if P(Y = 0| X = x; Z = z; W = w) >= 0.5 , 1 otherwise\n",
- " result_Y = 1 - probabilities_Y.round()\n",
- "\n",
- " probabilities_T = 1 / (1 + np.exp(-(beta_X * X + beta_Z * Z)))\n",
- " probabilities_T += npr.normal(0, np.sqrt(0.1), nJudges_M * nSubjects_N)\n",
- "\n",
- " # Initialize decision values as 1\n",
- " decision_T = np.ones(nJudges_M * nSubjects_N)\n",
- "\n",
- " # Initialize the dataframe\n",
- " df_init = pd.DataFrame(\n",
- " np.column_stack((judgeID_J, acceptanceRate_R, X, Z, W, result_Y,\n",
- " probabilities_T, decision_T)),\n",
- " columns=[\n",
- " \"judgeID_J\", \"acceptanceRate_R\", \"X\", \"Z\", \"W\", \"result_Y\",\n",
- " \"probabilities_T\", \"decision_T\"\n",
- " ])\n",
- "\n",
- " # Sort by judges then probabilities\n",
- " data = df_init.sort_values(\n",
- " by=[\"judgeID_J\", \"probabilities_T\"], ascending=False)\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",
- " data.reset_index(drop=True, inplace=True)\n",
- "\n",
- " data['decision_T'] = np.where(\n",
- " (data.index.values % nSubjects_N) <\n",
- " ((1 - data['acceptanceRate_R']) * nSubjects_N), 0, 1)\n",
- "\n",
- " return data\n",
- "\n",
- "df = generateData()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "(25000, 8)\n",
- "(25000, 8)\n",
- "(25000, 8)\n",
- "(25000, 8)\n"
- ]
- },
- {
- "data": {
- "text/html": [
- "<div>\n",
- "<style scoped>\n",
- " .dataframe tbody tr th:only-of-type {\n",
- " vertical-align: middle;\n",
- " }\n",
- "\n",
- " .dataframe tbody tr th {\n",
- " vertical-align: top;\n",
- " }\n",
- "\n",
- " .dataframe thead th {\n",
- " text-align: right;\n",
- " }\n",
- "</style>\n",
- "<table border=\"1\" class=\"dataframe\">\n",
- " <thead>\n",
- " <tr style=\"text-align: right;\">\n",
- " <th>decision_T</th>\n",
- " <th>1</th>\n",
- " </tr>\n",
- " <tr>\n",
- " <th>result_Y</th>\n",
- " <th></th>\n",
- " </tr>\n",
- " </thead>\n",
- " <tbody>\n",
- " <tr>\n",
- " <th>0.0</th>\n",
- " <td>3650</td>\n",
- " </tr>\n",
- " <tr>\n",
- " <th>1.0</th>\n",
- " <td>8216</td>\n",
- " </tr>\n",
- " </tbody>\n",
- "</table>\n",
- "</div>"
- ],
- "text/plain": [
- "decision_T 1\n",
- "result_Y \n",
- "0.0 3650\n",
- "1.0 8216"
- ]
- },
- "execution_count": 5,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "# Split the data set to test and train\n",
- "from sklearn.model_selection import train_test_split\n",
- "train, test = train_test_split(df, test_size=0.5, random_state=0)\n",
- "\n",
- "print(train.shape)\n",
- "print(test.shape)\n",
- "\n",
- "train_labeled = train.copy()\n",
- "test_labeled = test.copy()\n",
- "\n",
- "# Set results as NA if decision is negative.\n",
- "train_labeled.result_Y = np.where(train.decision_T == 0, np.nan, train.result_Y)\n",
- "test_labeled.result_Y = np.where(test.decision_T == 0, np.nan, test.result_Y)\n",
- "\n",
- "print(train_labeled.shape)\n",
- "print(test_labeled.shape)\n",
- "\n",
- "tab = train_labeled.groupby(['result_Y', 'decision_T']).size()\n",
- "tab.unstack()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Algorithms\n",
- "\n",
- "### Contraction algorithm\n",
- "\n",
- "Below is an implementation of Lakkaraju's team's algorithm presented in [their paper](https://helka.finna.fi/PrimoRecord/pci.acm3098066). Relevant parameters to be passed to the function are presented in the description."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {},
- "outputs": [],
- "source": [
- "def contraction(df,\n",
- " judgeIDJ_col,\n",
- " decisionT_col,\n",
- " resultY_col,\n",
- " modelProbS_col,\n",
- " accRateR_col,\n",
- " r,\n",
- " binning=False):\n",
- " '''\n",
- " This is an implementation of the algorithm presented by Lakkaraju\n",
- " et al. in their paper \"The Selective Labels Problem: Evaluating \n",
- " Algorithmic Predictions in the Presence of Unobservables\" (2017).\n",
- " \n",
- " Parameters:\n",
- " df = The (Pandas) data frame containing the data, judge decisions,\n",
- " judge IDs, results and probability scores.\n",
- " judgeIDJ_col = String, the name of the column containing the judges' IDs\n",
- " in df.\n",
- " decisionT_col = String, the name of the column containing the judges' decisions\n",
- " resultY_col = String, the name of the column containing the realization\n",
- " modelProbS_col = String, the name of the column containing the probability\n",
- " scores from the black-box model B.\n",
- " accRateR_col = String, the name of the column containing the judges' \n",
- " acceptance rates\n",
- " r = Float between 0 and 1, the given acceptance rate.\n",
- " binning = Boolean, should judges with same acceptance rate be binned\n",
- " \n",
- " Returns:\n",
- " u = The estimated failure rate at acceptance rate r.\n",
- " '''\n",
- " # Sort first by acceptance rate and judge ID.\n",
- " sorted_df = df.sort_values(\n",
- " by=[accRateR_col, judgeIDJ_col], ascending=False)\n",
- "\n",
- " if binning:\n",
- " # Get maximum leniency\n",
- " max_leniency = sorted_df[accRateR_col].values[0].round(1)\n",
- "\n",
- " # Get list of judges that are the most lenient\n",
- " most_lenient_list = sorted_df.loc[sorted_df[accRateR_col].round(1) ==\n",
- " max_leniency, judgeIDJ_col]\n",
- "\n",
- " # Subset to obtain D_q\n",
- " D_q = sorted_df[sorted_df[judgeIDJ_col].isin(\n",
- " most_lenient_list.unique())].copy()\n",
- " else:\n",
- " # Get most lenient judge\n",
- " most_lenient_ID = sorted_df[judgeIDJ_col].values[0]\n",
- "\n",
- " # Subset\n",
- " D_q = sorted_df[sorted_df[judgeIDJ_col] == most_lenient_ID].copy()\n",
- "\n",
- " # All observations of R_q have observed outcome labels\n",
- " R_q = D_q[D_q[decisionT_col] == 1]\n",
- "\n",
- " # \"Observations deemed as high risk by B are at the top of this list\"\n",
- " R_sort_q = R_q.sort_values(by=modelProbS_col, ascending=False)\n",
- "\n",
- " number_to_remove = int(\n",
- " round((1.0 - r) * D_q.shape[0] - (D_q.shape[0] - R_q.shape[0])))\n",
- "\n",
- " # \"R_B is the list of observations assigned to t = 1 by B\"\n",
- " R_B = R_sort_q[number_to_remove:R_sort_q.shape[0]]\n",
- "\n",
- " return np.sum(R_B[resultY_col] == 0) / D_q.shape[0]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Causal algorithm\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [],
- "source": [
- "def f(x, model, class_value):\n",
- " '''\n",
- " Parameters:\n",
- " x = individual features\n",
- " model = a trained sklearn predictive model. Predicts probabilities for given x.\n",
- " class_value = the result (class) to predict (usually 0 or 1).\n",
- " \n",
- " Returns:\n",
- " The probabilities (as vector) of class value (class_value) given \n",
- " individual features (x) and the trained, predictive model (model).\n",
- " '''\n",
- " if x.ndim == 1:\n",
- " # if x is vector, transform to column matrix.\n",
- " f_values = model.predict_proba(np.array(x).reshape(-1, 1))\n",
- " else:\n",
- " f_values = model.predict_proba(x)\n",
- "\n",
- " return f_values[:, model.classes_ == class_value].flatten()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Performance comparison\n",
- "\n",
- "Below we try to replicate the results obtained by Lakkaraju and compare their model's performance to the one of ours.\n",
- "\n",
- "### Predictive models\n",
- "\n",
- "Lakkaraju says that they used logistic regression. We construct the models using only *observed observations*, i.e. observations for which labels are available. We then predict the probability of negative outcome for all observations in the test data and attach it to our data set."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {},
- "outputs": [],
- "source": [
- "# instantiate the model (using the default parameters)\n",
- "logreg = LogisticRegression(solver='lbfgs')\n",
- "\n",
- "# fit, reshape X to be of shape (n_samples, n_features)\n",
- "logreg = logreg.fit(\n",
- " train_labeled.X[train_labeled.decision_T == 1].values.reshape(-1, 1),\n",
- " train_labeled.result_Y[train_labeled.decision_T == 1])\n",
- "\n",
- "# predict probabilities and attach to data\n",
- "label_probs_logreg = logreg.predict_proba(test.X.values.reshape(-1, 1))\n",
- "\n",
- "test = test.assign(B_prob_0_logreg=label_probs_logreg[:, 0])\n",
- "test_labeled = test_labeled.assign(B_prob_0_logreg=label_probs_logreg[:, 0])"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Train model for predicting the probability of positive decision with a given\n",
- "# leniency r and indivual features x.\n",
- "\n",
- "# Instantiate the model (using the default parameters)\n",
- "decision_model = LogisticRegression(solver='lbfgs')\n",
- "\n",
- "# fit, reshape X to be of shape (n_samples, n_features)\n",
- "decision_model = decision_model.fit(train[['X', 'acceptanceRate_R']], train.decision_T)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Visual comparison\n",
- "\n",
- "Let's plot the failure rates against the acceptance rates using the difference."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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\n",
- "text/plain": [
- "<Figure size 1008x576 with 1 Axes>"
- ]
- },
- "metadata": {
- "needs_background": "light"
- },
- "output_type": "display_data"
- }
- ],
- "source": [
- "failure_rates = np.zeros((8, 5))\n",
- "\n",
- "for r in np.arange(1, 9):\n",
- " \n",
- " #### True evaluation\n",
- " # Sort by failure probabilities, subjects with the smallest risk are first. \n",
- " df_sorted = test.sort_values(\n",
- " by='B_prob_0_logreg', inplace=False, ascending=True)\n",
- "\n",
- " to_release = int(round(df_sorted.shape[0] * r / 10))\n",
- "\n",
- " # Failure was coded as zero.\n",
- " failure_rates[r - 1, 0] = np.mean(df_sorted.result_Y[0:to_release] == 0)\n",
- " \n",
- " #### Labeled outcomes only\n",
- " # Sort by failure probabilities, subjects with the smallest risk are first. \n",
- " df_sorted = test_labeled.sort_values(\n",
- " by='B_prob_0_logreg', inplace=False, ascending=True)\n",
- " \n",
- " # Ensure that only labeled outcomes are available\n",
- " df_sorted = df_sorted[df_sorted.decision_T == 1]\n",
- " \n",
- " to_release = int(round(df_sorted.shape[0] * r / 10))\n",
- "\n",
- " failure_rates[r - 1, 1] = np.mean(df_sorted.result_Y[0:to_release] == 0)\n",
- " \n",
- " #### Human error rate\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[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",
- " failure_rates[r - 1, 2] = np.sum(\n",
- " released.result_Y == 0) / correct_leniency_list.shape[0]\n",
- " # onko jakaja oikein\n",
- " \n",
- " #### Contraction, logistic regression\n",
- " failure_rates[r - 1, 3] = contraction(\n",
- " test_labeled, 'judgeID_J', 'decision_T', 'result_Y', 'B_prob_0_logreg',\n",
- " 'acceptanceRate_R', r / 10, False)\n",
- "\n",
- " #### P(Y=0 | T=1, X=x)*P(T=1 | R=r, X=x)*P(X=x)\n",
- " failure_rates[r - 1, 4] = si.quad(lambda x: f(np.array([x]), logreg, 0)*f(np.array([[x, r/10]]), decision_model, 1)*scs.norm.pdf(x), -np.inf, np.inf)[0]\n",
- "\n",
- "# klassifikaatioille scipy.stats semin kautta error barit xerr ja yerr argumenttien kautta\n",
- "\n",
- "plt.figure(figsize=(14, 8))\n",
- "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 0], label='True Evaluation', c='green')\n",
- "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 1], label='Labeled outcomes', c='lime')\n",
- "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 2], label='Human evaluation', c='red')\n",
- "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 3], label='Contraction, log.', c='blue')\n",
- "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 4], label='Integrand', c='magenta')\n",
- "\n",
- "plt.title('Failure rate vs. Acceptance rate')\n",
- "plt.xlabel('Acceptance rate')\n",
- "plt.ylabel('Failure rate')\n",
- "plt.legend()\n",
- "plt.grid()\n",
- "plt.show()"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.7.0"
- },
- "toc": {
- "base_numbering": 1,
- "nav_menu": {},
- "number_sections": true,
- "sideBar": true,
- "skip_h1_title": true,
- "title_cell": "Table of Contents",
- "title_sidebar": "Contents",
- "toc_cell": true,
- "toc_position": {},
- "toc_section_display": true,
- "toc_window_display": true
- },
- "varInspector": {
- "cols": {
- "lenName": 16,
- "lenType": 16,
- "lenVar": 40
- },
- "kernels_config": {
- "python": {
- "delete_cmd_postfix": "",
- "delete_cmd_prefix": "del ",
- "library": "var_list.py",
- "varRefreshCmd": "print(var_dic_list())"
- },
- "r": {
- "delete_cmd_postfix": ") ",
- "delete_cmd_prefix": "rm(",
- "library": "var_list.r",
- "varRefreshCmd": "cat(var_dic_list()) "
- }
- },
- "types_to_exclude": [
- "module",
- "function",
- "builtin_function_or_method",
- "instance",
- "_Feature"
- ],
- "window_display": false
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
--
GitLab