diff --git a/Kandi.pdf b/Kandi.pdf index 2237236eea9472d28b2c7f9fa1641c29bad143a8..8c26754b2706e055c1ed9268df466b2721a8f145 100644 Binary files a/Kandi.pdf and b/Kandi.pdf differ diff --git a/Kandi.synctex.gz b/Kandi.synctex.gz index c08c7a083bb34d3c67204c145a90ba061a9fa6a4..52c4cdd272aac0b8e54defa53832c064b08591a5 100644 Binary files a/Kandi.synctex.gz and b/Kandi.synctex.gz differ diff --git a/Kandi.tex b/Kandi.tex index 85e6fa8c78cecea1bbd46299bede59b32cf2621c..94a18067fcc3d933417cc10e9d32097d387e93eb 100644 --- a/Kandi.tex +++ b/Kandi.tex @@ -20,6 +20,8 @@ \usepackage{graphicx} % kuvat \graphicspath{ {./figures/} } +\usepackage{mdframed} + \newcommand\independent{\protect\mathpalette{\protect\independenT}{\perp}} %riippumattomuus \def\independenT#1#2{\mathrel{\rlap{$#1#2$}\mkern2mu{#1#2}}} @@ -57,7 +59,7 @@ \newtheorem{kor}[equation]{Korollaari} \theoremstyle{definition} -\newtheorem{maar}[equation]{Määritelmä} +\newmdtheoremenv{maar}[equation]{Määritelmä} \newtheorem{konj}[equation]{Konjektuuri} \newtheorem{esim}[equation]{Esimerkki} @@ -165,11 +167,11 @@ Kritiikkiä on esitetty molemmissa maissa osaltaan samoihin asioihin. Suomessa p \section{''Kausaalipäättely uutena paradigmana''}\label{para} % miksi halutaan siirtyä (frekventistisen/bayes-ppäättelyn ongelmat), edut, esiintyminen, erot, käyttö -Kuten Pearl ja Mackenzie esittävät kirjassaan Miksi, ihmisillä on luontainen kausaalisen päättelyn taito \cite{miksi}. Tavalliset tilastollisen päättelyn menetelmät eivät tarjoa tapaa määritellä kausaalista yhteyttä: aineistosta voidaan päätellä erilaisia \emph{korrelaatioita}, mutta päättely B \emph{johtuu} A:sta vaatii uudenlaista näkökulmaa. Käytännön tutimuksessa tarve on olemassa erityisesti lääketieteen alalla, jossa halutaan tietää \emph{johtuuko} paraneminen annetusta suoraan annetusta hoidosta vai vaikuttaako läääke johonkin mittaamattomaan muutujaan, joka on suorassa kausaalisessa yhteydessä paranemisen kanssa. \textbf{Lisää lähteet ja tarkista!} +Kuten Pearl ja Mackenzie esittävät kirjassaan Miksi, ihmisillä on luontainen kausaalisen päättelyn taito \cite{miksi}. Tavalliset tilastollisen päättelyn menetelmät eivät tarjoa tapaa määritellä kausaalista yhteyttä: aineistosta voidaan päätellä erilaisia \emph{korrelaatioita}, mutta päättely \emph{B johtuu A:sta} vaatii uudenlaista näkökulmaa. Käytännön tutkimuksessa tarve on olemassa erityisesti lääketieteen alalla, jossa halutaan tietää \emph{johtuuko} paraneminen annetusta suoraan annetusta hoidosta vai vaikuttaako lääke johonkin mittaamattomaan muuttujaan, joka on suorassa syy-seuraussuhteessa paranemisen kanssa. \textbf{Lisää lähteet ja tarkista!} + +Syy-seuraussuhteen vahvuuden matemaattinen määrittely vaatii uutta lähestymistä myös todennäköisyyslaskennan merkintöihin. Pearl käyttää alkuperäisessä, englanninkielisessä kirjallisuudessa merkintää do ilmaisemaan interventiota. Merkinnällä halutaan erottaa tavanomainen ehdollinen todennäköisyys $\pr(Y|X=x)$ interventiosta, jossa asetamme muuttujan $X$ arvoon $x$: $\pr(Y|\text{do}(X=x)$. Kimmo Pietiläinen käyttää kirjan suomennoksessa käännöstä \emph{tee}, mutta seuraan tässä tutkielmassa Pearlin merkintöjä, ellen erikseen muuta mainitse \cite{miksi}. Esittelen käyttämäni merkinnät tarkemmin kappaleessa \ref{kausaalimerk}. -Syy-seuraussuhteen vahvuuden matemaattinen määrittely vaatii siis uutta lähestymistä todennäköisyyslaskennan merkintöihin. Pearl käyttää alkuperäisessä, englanninkielisessä kirjallisuudessa merkintää do ilmaisemaan interventiota. Merkinnällä halutaan erottaa tavanomainen ehdollinen todennäköisyys $\pr(Y|X=x)$ interventiosta, jossa asetamme muuttujan $X$ arvoon $x$: $\pr(Y|\text{do}(X=x)$. Kimmo Pietiläinen käyttää kirjan suomennoksessa käännöstä \emph{tee}, mutta seuraan tässä tutkielmassa Pearlin merkintöjä, ellen erikseen muuta mainitse \cite{miksi}. Esittelen käyttämäni merkinnät tarkemmin kappaleessa \ref{kausaalimerk}. -* Kausaalipäättely vaatii uutta laskentoa, \emph{do}-laskento (calculus), myös Miksi-kirjan käännöksen tee-laskento. * Päättely nojaa vahvasti / tarvitsee mallin, joka ilmaistaan (usein/aina) verkkona, josta voidaan suoraan lukea muuuttujien väliset riippuvuussuhteet. * Usein funktionaalista muotoa ei määritellä,, lisää tähän ne nuoliversiot yhtälöistä havainnollistamaan, että siirrytään yhtäsuuruudesta määräytymiseen \cite{kalisch14} * Esimerkkejä Miksi-kirjasta väärin määritellyistä malleista? Esimerkkejä aloista, joila jo käytetty, oleellisimmat pointit historiasta diff --git a/analysis_and_scripts/Bachelors_thesis_analyses.ipynb b/analysis_and_scripts/Bachelors_thesis_analyses.ipynb index ca077bb5c65e46bacb7b86610d8f26dc124ec8d7..cbb674516add150bad7ce81909145377954da72d 100644 --- a/analysis_and_scripts/Bachelors_thesis_analyses.ipynb +++ b/analysis_and_scripts/Bachelors_thesis_analyses.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -87,7 +87,7 @@ "(6172, 13)" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -114,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -329,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 5, "metadata": { "scrolled": false }, @@ -527,7 +527,7 @@ " <th>c_jail_in</th>\n", " <td>6172</td>\n", " <td>6172</td>\n", - " <td>2013-05-19 07:00:07</td>\n", + " <td>2013-02-13 05:34:20</td>\n", " <td>1</td>\n", " <td>NaN</td>\n", " <td>NaN</td>\n", @@ -582,7 +582,7 @@ "decile_score 6172 NaN NaN NaN 4.4185 \n", "is_recid 6172 NaN NaN NaN 0.484446 \n", "two_year_recid 6172 NaN NaN NaN 0.45512 \n", - "c_jail_in 6172 6172 2013-05-19 07:00:07 1 NaN \n", + "c_jail_in 6172 6172 2013-02-13 05:34:20 1 NaN \n", "c_jail_out 6172 6161 2013-09-14 05:58:00 3 NaN \n", "length_of_stay 6172 NaN NaN NaN 14.6228 \n", "\n", @@ -603,7 +603,7 @@ "length_of_stay 46.6935 -1 0 1 5 799 " ] }, - "execution_count": 29, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -625,7 +625,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -685,7 +685,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -713,7 +713,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -733,7 +733,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "scrolled": false }, @@ -765,7 +765,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -794,7 +794,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -806,7 +806,7 @@ "Name: score_text, dtype: int64" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -817,7 +817,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -828,7 +828,7 @@ "Name: c_charge_degree, dtype: int64" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -839,7 +839,33 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.001, 0.5] 2085\n", + "(0.5, 5.5] 2866\n", + "(5.5, 10.5] 729\n", + "(10.5, 20.5] 402\n", + "(20.5, 40.5] 90\n", + "Name: priors_count, dtype: int64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "compas.priors_count.value_counts(\n", + " sort=False, bins=[0, 0.5, 5.5, 10.5, 20.5, 40.5])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "metadata": { "scrolled": true }, @@ -912,7 +938,7 @@ "Male 2626 29 1621 427 9 285" ] }, - "execution_count": 12, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -924,7 +950,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": { "scrolled": false }, @@ -980,7 +1006,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": { "scrolled": false }, @@ -1015,7 +1041,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": { "scrolled": false }, @@ -1331,13 +1357,13 @@ "* 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`, decisions where $T=0$ represents decision to deny and if $T=1$ then bail is granted.\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 would not commit a crime." ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 18, "metadata": { "scrolled": false }, @@ -1495,20 +1521,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "\\begin{tabular}{lrrrrrrrr}\n", - "\\hline\n", - " & Määrä & Keskiarvo & Keskihajonta & Minimi & 25\\% & 50\\% & 75\\% & Maksimi \\\\\n", - "\\hline\n", - " judgeID\\_J & 50000.00 & 49.50 & 28.87 & 0.00 & 24.75 & 49.50 & 74.25 & 99.00 \\\\\n", - " acceptanceRate\\_R & 50000.00 & 0.48 & 0.23 & 0.10 & 0.26 & 0.47 & 0.65 & 0.89 \\\\\n", - " X & 50000.00 & -0.00 & 1.00 & -4.66 & -0.67 & -0.00 & 0.67 & 3.83 \\\\\n", - " Z & 50000.00 & 0.01 & 1.00 & -4.85 & -0.67 & 0.00 & 0.68 & 4.24 \\\\\n", - " W & 50000.00 & 0.01 & 1.00 & -4.03 & -0.67 & 0.01 & 0.68 & 4.29 \\\\\n", - " result\\_Y & 50000.00 & 0.50 & 0.50 & 0.00 & 0.00 & 0.00 & 1.00 & 1.00 \\\\\n", - " probabilities\\_T & 50000.00 & 0.50 & 0.28 & -0.34 & 0.28 & 0.50 & 0.72 & 1.30 \\\\\n", - " decision\\_T & 50000.00 & 0.48 & 0.50 & 0.00 & 0.00 & 0.00 & 1.00 & 1.00 \\\\\n", - "\\hline\n", - "\\end{tabular}\n", "0 26137\n", "1 23863\n", "Name: decision_T, dtype: int64\n" @@ -1574,7 +1586,6 @@ "# Set seed for reproducibility\n", "npr.seed(0)\n", "\n", - "\n", "def generateData(nJudges_M=100,\n", " nSubjects_N=500,\n", " beta_X=1.0,\n", @@ -1639,7 +1650,6 @@ "# Basic stats of the created data set.\n", "display(df.describe().T)\n", "\n", - "\n", "print(df.decision_T.value_counts())\n", "\n", "tab = df.groupby(['result_Y', 'decision_T']).size()\n", @@ -1648,7 +1658,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1709,7 +1719,7 @@ "1.0 9371" ] }, - "execution_count": 17, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1745,7 +1755,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -1831,38 +1841,35 @@ "\n", "\n", "\n", - "**Algorithm**\n", + "**Algorithm -- UPDATE!!**\n", "\n", "Our model will be constructed sequentially.\n", "\n", - "Input: Data $(\\mathbf{x}, t, y) \\in \\mathcal{D}$ and acceptance rate $r$. \n", + "Input: Training and test data sets $(\\mathbf{x}, t, y) \\in \\mathcal{D}$ and acceptance rate $r$. \n", "Returns: $P(Y=0 | \\text{do}(R=r))$\n", "\n", "Procedure:\n", "1. Model $P(X=x)$ in a suitable way and assign to $\\mathcal{M}_0$\n", "* Build model $\\mathcal{M}_1$ predicting response $Y$ with predictors $X$ from the labeled observations (where $T=1$) in training data.\n", "* Predict $P(Y=0|X=x)$ for every observation in the test data using model $\\mathcal{M}_1$.\n", - "* Order all observations by the probability score from previous phase in ascending order. Now the \"most harmless\" are at the top of the list.\n", "* Initialize `sum = 0`\n", "* For every point in the parameter space (for every $x$ in $X$)\n", " 1. $p_x \\leftarrow P(X=x)$ from $\\mathcal{M}_0$\n", " * $\\mathcal{D_x} \\leftarrow \\{\\mathcal{D} | X = x\\}$\n", " * Assign first $r\\cdot 100\\%$ observations from $\\mathcal{D_x}$ to $\\mathcal{D}_{rx}$\n", - " * $p_t \\leftarrow \\dfrac{|\\{\\mathcal{D}_{rx}|T=1\\}|}{|\\mathcal{D}_{rx}|}$\n", + " * $p_t \\leftarrow \\dfrac{|\\{\\mathcal{D}_{rx}|T=1\\}|}{|\\mathcal{D}_{rx}|}$ (part 2 of eq. $\\ref{model}$) Pitääkö tähänkin treenaa joku oma luokittelija?\n", " * $p_y$ will be predicted from the model $\\mathcal{M}_1$\n", " * `sum +=` $p_y \\cdot p_t \\cdot p_x$\n", "* Return `sum`\n", "\n", "**Constructing $\\mathcal{M}_0$, preliminary ideas:**\n", "\n", - "* Approximate $P(X=x)$ with frequencies (make variables factors first)\n", - "\n", - "TEE ALLA OLEVASTA FUNKTIO!!! Kaikki sklearnin mallit implementtaa fitin ja predictin https://scikit-learn.org/stable/tutorial/basic/tutorial.html" + "* Approximate $P(X=x)$ with frequencies (make variables factors first)" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": { "scrolled": false }, @@ -1871,62 +1878,47 @@ "name": "stdout", "output_type": "stream", "text": [ - "[0.13017179 0.1265672 0.12309921 0.12101056 0.11946303 0.1163152\n", - " 0.11309497 0.10995003]\n" + "0.9941732247162859\n" ] } ], "source": [ - "r_list = np.linspace(0.1, 0.8, 8, endpoint=True)\n", - "\n", "# 1 For now we don't model f(x), just utilize it's N(0, 1)\n", "\n", - "# 2\n", + "# 2 Initialize model\n", "lr_causal_result = LogisticRegression(solver='lbfgs')\n", "\n", "# fit, reshape X to be of shape (n_samples, n_features)\n", "lr_causal_result.fit(train_labeled['X'].values.reshape(-1, 1),\n", " train_labeled.result_Y)\n", "\n", - "# 3\n", + "# 3 Predict for all observations in test set.\n", "causal_probs = lr_causal_result.predict_proba(test.X.values.reshape(-1, 1))\n", "\n", "test = test.assign(B_prob_0_causal=causal_probs[:, 0])\n", "\n", "# 4\n", - "test_ordered = test.sort_values(by='B_prob_0_causal', ascending=True)\n", - "\n", - "#5\n", - "probability_list = np.zeros_like(r_list)\n", - "i = 0\n", - "for r in r_list:\n", - "\n", - " # 6\n", - " for x in range(-5, 5):\n", - " # A\n", - " p_x = scs.norm.pdf(x)\n", - " # B\n", - " D_x = test_ordered[test_ordered.X.round(0) == x]\n", - "\n", - " if D_x.shape[0] == 0:\n", - " continue\n", - " # C\n", - " if round(r * D_x.shape[0]) == 0:\n", - " continue\n", - "\n", - " D_rx = D_x[0:int(round(r * D_x.shape[0]))]\n", - "\n", - " # D\n", - " p_t = np.sum(D_rx.decision_T == 1) / D_rx.shape[0]\n", - " # E\n", - " p_y = lr_causal_result.predict_proba(np.array(x).reshape(-1, 1))\n", - " # F\n", - " probability_list[i] += p_y[0, 0] * p_t * p_x\n", - "\n", - " i += 1\n", - "\n", - "# 7\n", - "print(probability_list)" + "probability = 0\n", + "\n", + "r = 0.99\n", + "# 5\n", + "for x in range(-60, 60):\n", + " # A\n", + " p_x = scs.norm.pdf(x/10)\n", + "\n", + " D_tx = test[(test.B_prob_0_causal < r) & (test.X.round(1) == x/10)]\n", + " if D_tx.shape[0] == 0: \n", + " continue\n", + " ## D\n", + " p_t = np.sum(D_tx.decision_T == 1) / D_tx.shape[0]\n", + "\n", + " # E\n", + " p_y = lr_causal_result.predict_proba(np.array(x/10).reshape(-1, 1))\n", + " # F\n", + " probability += p_y[0, 0] * p_t * p_x\n", + "\n", + "# 6\n", + "print(probability)" ] }, { @@ -1946,30 +1938,40 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "# instantiate the model (using the default parameters)\n", - "logreg_machine = LogisticRegression(solver='lbfgs')\n", + "logreg = LogisticRegression(solver='lbfgs')\n", "\n", "# fit, reshape X to be of shape (n_samples, n_features)\n", - "logreg_machine.fit(\n", - " train_labeled.X.values.reshape(-1, 1), train_labeled.result_Y)\n", + "logreg.fit(train_labeled.X.values.reshape(-1, 1), train_labeled.result_Y)\n", "\n", "# predict probabilities and attach to data\n", - "label_probabilities_machine = logreg_machine.predict_proba(\n", - " test.X.values.reshape(-1, 1))\n", + "label_probs_logreg = logreg.predict_proba(test.X.values.reshape(-1, 1))\n", + "test = test.assign(B_prob_0_machine=label_probs_logreg[:, 0])\n", "\n", - "test = test.assign(B_prob_0_machine=label_probabilities_machine[:, 0])\n", + "# instantiate decision tree classifier\n", + "dectree = tree.DecisionTreeClassifier()\n", "\n", + "# fit, reshape X to be of shape (n_samples, n_features)\n", + "dectree = dectree.fit(train_labeled.X.values.reshape(-1, 1), train_labeled.result_Y)\n", + "\n", + "# predict probabilities and attach to data\n", + "label_probs_dectree = dectree.predict_proba(test.X.values.reshape(-1, 1))\n", + "test = test.assign(B_prob_0_tree=label_probs_dectree[:, 0])\n", "\n", - "clf = tree.DecisionTreeClassifier()\n", - "clf = clf.fit(train_labeled.X.values.reshape(-1, 1), train_labeled.result_Y)\n", + "from sklearn.ensemble import RandomForestClassifier\n", "\n", - "preds = clf.predict_proba(test.X.values.reshape(-1, 1))\n", + "forest = RandomForestClassifier(n_estimators=100, max_depth=4, random_state=0)\n", "\n", - "test = test.assign(B_prob_0_tree=preds[:, 0])" + "# fit, reshape X to be of shape (n_samples, n_features)\n", + "forest = forest.fit(train_labeled.X.values.reshape(-1, 1), train_labeled.result_Y)\n", + "\n", + "# predict probabilities and attach to data\n", + "label_probs_forest = forest.predict_proba(test.X.values.reshape(-1, 1))\n", + "test = test.assign(B_prob_0_forest=label_probs_forest[:, 0])" ] }, { @@ -1981,11 +1983,36 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 23, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gen perf: 2047.3388927096714\n", + "Rates: [0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8]\n", + "Emp perf: [0.02548 0.09052 0.165 0.24056 0.30824 0.37212 0.42256 0.46524]\n" + ] + } + ], "source": [ - "#probs = causal()" + "def f(x, model):\n", + " f_values = model.predict_proba(np.array(x).reshape(-1, 1))\n", + "\n", + " return f_values[:, 0]\n", + "\n", + "\n", + "def ep(r, df, result_col, feature_cols, model):\n", + " rates = np.zeros_like(r)\n", + " for i in range(len(rates)):\n", + " rates[i] = np.mean((df[result_col] == 0) &\n", + " (f(df[feature_cols], model) < r[i]))\n", + " return rates\n", + "\n", + "print(\"Gen perf:\", np.sum(f(test.X, logreg) * (f(test.X, logreg) < r) * scs.norm.pdf(test.X)))\n", + "print(\"Rates: \", np.arange(1, 9) / 10)\n", + "print(\"Emp perf:\", ep(np.arange(1, 9) / 10, test, 'result_Y', 'X', logreg))" ] }, { @@ -1997,14 +2024,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 24, "metadata": { "scrolled": false }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1008x576 with 1 Axes>" ] @@ -2018,28 +2045,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[0.00455433 0. 0.00457928 0.0325309 ]\n", - " [0.01821731 0.00044435 0.02232398 0.08002602]\n", - " [0.04359141 0.00479042 0.04865484 0.1223162 ]\n", - " [0.07221861 0.01473839 0.08414425 0.15354587]\n", - " [0.11581002 0.05490052 0.12821981 0.18998048]\n", - " [0.16525699 0.12254799 0.18488838 0.22511386]\n", - " [0.2192583 0.19818755 0.24556382 0.26740403]\n", - " [0.28106701 0.30799411 0.32398397 0.32856213]]\n", - "[0.13017179 0.1265672 0.12309921 0.12101056 0.11946303 0.1163152\n", - " 0.11309497 0.10995003]\n" + "[[0.0046 0. 0.0046 0.0325 0.0255 0.0387]\n", + " [0.0182 0.0004 0.0223 0.08 0.0905 0.0675]\n", + " [0.0436 0.0048 0.0487 0.1223 0.165 0.1563]\n", + " [0.0722 0.0147 0.0841 0.1535 0.2406 0.2286]\n", + " [0.1158 0.0549 0.1282 0.19 0.3082 0.2907]\n", + " [0.1653 0.1225 0.1849 0.2251 0.3721 0.3774]\n", + " [0.2193 0.1982 0.2456 0.2674 0.4226 0.4255]\n", + " [0.2811 0.308 0.324 0.3286 0.4652 0.4808]]\n" ] } ], "source": [ - "failure_rates = np.zeros((8, 4))\n", + "failure_rates = np.zeros((8, 6))\n", "\n", "for r in np.arange(1, 9):\n", " failure_rates[r - 1, 0] = contraction(\n", " test[test.decision_T == 1], 'judgeID_J', 'decision_T', 'result_Y',\n", " 'B_prob_0_machine', 'acceptanceRate_R', r / 10, True)\n", "\n", - " ## Human error rate - Jotain väärin viel'\n", + " ## Human error rate - Correct?\n", " # Get judges with correct leniency as list\n", " correct_leniency_list = test.judgeID_J[test['acceptanceRate_R'].round(1) ==\n", " r / 10]\n", @@ -2060,6 +2085,13 @@ " failure_rates[r - 1, 3] = contraction(\n", " test[test.decision_T == 1], 'judgeID_J', 'decision_T', 'result_Y',\n", " 'B_prob_0_tree', 'acceptanceRate_R', r / 10, True)\n", + " \n", + " ## Causal model\n", + " failure_rates[r - 1, 4] = ep([r / 10], test, 'result_Y', 'X', logreg)\n", + " \n", + " ## Causal model\n", + " failure_rates[r - 1, 5] = ep([r / 10], test, 'result_Y', 'X', forest)\n", + " \n", "\n", "# klassifikaatioille scipy.stats semin kautta error barit xerr ja yerr argumenttien kautta\n", "\n", @@ -2067,25 +2099,53 @@ "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 0], label='Contraction')\n", "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 1], label='Human')\n", "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 2], label='True Evaluation')\n", - "plt.plot(np.arange(0.1, 0.9, .1), probability_list, label='Causal model')\n", + "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 3], label='Classification tree')\n", + "\n", + "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 4], label='Causal model, log.')\n", + "plt.plot(np.arange(0.1, 0.9, .1), failure_rates[:, 5], label='Causal model, for.')\n", "\n", - "plt.plot(\n", - " np.arange(0.1, 0.9, .1), failure_rates[:, 3], label='Classification tree')\n", "\n", "plt.title('Failure rate vs. Acceptance rate')\n", "plt.xlabel('Acceptance rate')\n", "plt.ylabel('Failure rate')\n", "plt.legend()\n", "plt.show()\n", - "print(failure_rates)\n", - "print(probability_list)" + "\n", + "with np.printoptions(precision=4, suppress=True):\n", + " print(failure_rates)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Failure rates still too high. Order of curves now correct. Causal model calculates the wrong thing? " + "Failure rates still too high. Order of curves now correct." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "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": [ + "x_vals = np.linspace(0, 1, 1000)\n", + "y_vals = ep(x_vals, test, 'result_Y', 'X', logreg)\n", + "plt.figure(figsize=(14, 8))\n", + "plt.plot(x_vals, y_vals)\n", + "plt.show()" ] }, {