{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import csv\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import pandas as pd\n",
"from sklearn import (\n",
" linear_model, metrics, neural_network, pipeline, model_selection\n",
")\n",
"from sklearn.linear_model import LogisticRegression\n",
"\n",
"import statsmodels.api as sm\n",
"import linearmodels\n",
"\n",
"import seaborn as sns\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Introduction\n",
"\n",
"In this project, I'm further developing my ECON 490 thesis paper, in which I found that centrist Democratic candidates to the House of Representatives were much more likely, and very liberal candidates were much less likely, to win their elections than the baseline group. \n",
"\n",
"What I'm interested in now is not statistical significance, but seeing if I can generalize the models, test for overfitting, and get a good balance of variables to include to balance the various prediction metrics.\n",
"\n",
"It will be structured in the following manner:\n",
"\n",
"\n",
"1. Introducing the dataset\n",
" - Discussion of variables\n",
" \n",
"2. Creating the initial models\n",
" - Linear probability model\n",
" - Logit probability model\n",
" - The \"Unfrazzled no-hassle lasso progressive regression digression\"\n",
" - Testing accuracy\n",
" - Testing precision\n",
" - Testing recall\n",
" \n",
"3. Improving the models\n",
" - Region\n",
" - Race\n",
" - Candidate\n",
" - Urbanization\n",
" - Testing accuracy\n",
" - Picking the best model\n",
"\n",
"4. Counterfactual Predictions\n",
" - What if all Democrats ran as centrists?\n",
" - What if all Democrats ran as liberals?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Phase 1: Introducing the Dataset"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The final dataset created for my paper was `a_m_d_11`, standing for \"aligned model dataset version 11.\" It included data from multiple sources, ranging from an MIT Election Data + Science Lab dataset (acting as the core), to economic and demographic data from the US Census, to political leaning data from the Cook Partisan Voter Index, urbanization data, and others. It is printed below, with a list of columns. "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
states
\n",
"
po
\n",
"
dist
\n",
"
cand
\n",
"
cand_votes
\n",
"
tot_votes
\n",
"
leaning
\n",
"
median_income
\n",
"
mean_income
\n",
"
unemployment_1
\n",
"
...
\n",
"
DICREX
\n",
"
RICDIN
\n",
"
RICDEX
\n",
"
DEXRIN
\n",
"
DINREX
\n",
"
DEXREX
\n",
"
DINRIN
\n",
"
median_income_std
\n",
"
two_party_vote
\n",
"
two_party_vote_share
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
ALABAMA
\n",
"
AL
\n",
"
1
\n",
"
ROBERT KENNEDY JR.
\n",
"
89226
\n",
"
242617
\n",
"
15
\n",
"
47952
\n",
"
66085
\n",
"
6.4
\n",
"
...
\n",
"
0
\n",
"
1
\n",
"
0
\n",
"
0
\n",
"
0
\n",
"
0
\n",
"
0
\n",
"
-0.897518
\n",
"
242454
\n",
"
0.368012
\n",
"
\n",
"
\n",
"
1
\n",
"
ALABAMA
\n",
"
AL
\n",
"
2
\n",
"
TABITHA ISNER
\n",
"
86931
\n",
"
226230
\n",
"
16
\n",
"
46817
\n",
"
63939
\n",
"
7.0
\n",
"
...
\n",
"
0
\n",
"
1
\n",
"
0
\n",
"
0
\n",
"
0
\n",
"
0
\n",
"
0
\n",
"
-0.963925
\n",
"
225810
\n",
"
0.384974
\n",
"
\n",
"
\n",
"
2
\n",
"
ALABAMA
\n",
"
AL
\n",
"
3
\n",
"
MALLORY HAGAN
\n",
"
83996
\n",
"
231915
\n",
"
16
\n",
"
46576
\n",
"
62954
\n",
"
6.9
\n",
"
...
\n",
"
0
\n",
"
1
\n",
"
0
\n",
"
0
\n",
"
0
\n",
"
0
\n",
"
0
\n",
"
-0.978026
\n",
"
231766
\n",
"
0.362417
\n",
"
\n",
" \n",
"
\n",
"
3 rows × 62 columns
\n",
"
"
],
"text/plain": [
" states po dist cand cand_votes tot_votes leaning \\\n",
"0 ALABAMA AL 1 ROBERT KENNEDY JR. 89226 242617 15 \n",
"1 ALABAMA AL 2 TABITHA ISNER 86931 226230 16 \n",
"2 ALABAMA AL 3 MALLORY HAGAN 83996 231915 16 \n",
"\n",
" median_income mean_income unemployment_1 ... DICREX RICDIN RICDEX \\\n",
"0 47952 66085 6.4 ... 0 1 0 \n",
"1 46817 63939 7.0 ... 0 1 0 \n",
"2 46576 62954 6.9 ... 0 1 0 \n",
"\n",
" DEXRIN DINREX DEXREX DINRIN median_income_std two_party_vote \\\n",
"0 0 0 0 0 -0.897518 242454 \n",
"1 0 0 0 0 -0.963925 225810 \n",
"2 0 0 0 0 -0.978026 231766 \n",
"\n",
" two_party_vote_share \n",
"0 0.368012 \n",
"1 0.384974 \n",
"2 0.362417 \n",
"\n",
"[3 rows x 62 columns]"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a_m_d_11 = pd.read_csv(\"https://docs.google.com/spreadsheets/d/e/2PACX-1vRy5Ir4TrmGh77L131Xhkb22GIVWVF-4PF1eNjPOcOOpgtKyfyDcp4P2d8X4olqfifyJqo4SwTqSdH1/pub?gid=422096178&single=true&output=csv\")\n",
"\n",
"a_m_d_11.head(3)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"win = a_m_d_11[\"win\"]"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Index(['states', 'po', 'dist', 'cand', 'cand_votes', 'tot_votes', 'leaning',\n",
" 'median_income', 'mean_income', 'unemployment_1', 'unemployment_2',\n",
" 'white_pct', 'black_pct', 'native_pct', 'asian_pct', 'hispanic_pct',\n",
" 'blue_dog', 'justice_dem', 'dem_vote_pct', 'win', 'south', 'north_east',\n",
" 'mid_west', 'west', 'Incumbent', 'Open_Seat', 'urb_cluster',\n",
" 'Very low density', 'Low density', 'Medium density\\t', 'High density',\n",
" 'pure_rural', 'rural_suburban_mix', 'sparse_suburban', 'dense_suburban',\n",
" 'urban_suburban_mix', 'pure_urban', 'high_ed_pct', 'state_dist', 'stcd',\n",
" 'inc', 'pwin', 'fr', 'po1', 'po2', 'redist', 'dexp', 'rexp',\n",
" 'total_spending', 'dem_spending_share', 'abnormal', 'DICRIN', 'DICREX',\n",
" 'RICDIN', 'RICDEX', 'DEXRIN', 'DINREX', 'DEXREX', 'DINRIN',\n",
" 'median_income_std', 'two_party_vote', 'two_party_vote_share'],\n",
" dtype='object')"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a_m_d_11.columns"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"However, much of the dataset is vestigial and not used in the actual model. Some features and variables are worth explaining:\n",
"\n",
"- The data collection level is at the district and candidate level. Most variables describe the congressional district, but some such as `Incumbent` and the set of onces like `DICRIN`, `DICREX`, etc, describe whether the Democrat in question is an incumbent representative, and the political experience level of them and their Republican opponent. \n",
"\n",
"- `blue_dog` and `justice_dem` are my indicators of political ideology. This was the main point of interest for my paper - did candidates' political ideology being extreme hurt or help them in the general election? `blue_dog` equalled 1 if a candidate was a member of the Blue Dog Coalition (a group of centrist Democrats) or 0 if they didn't, while `justice_dem` equalled 1 if they were a member of the Justice Democrats (a very liberal political organization) and 0 if not. None were members of both; those who were members of neither were assumed to lie in between. \n",
"\n",
"Some evidence of this lies below in a plot created for my paper: \n",
"\n",
"Party and Caucus on DW-NOMINATE.png\n",
"\n",
"\n",
"\n",
"The main separation between the Democratic and Republican parties is the horizontal axis, showing how liberal or conservative (ie. left or right wing) candidates are on issues of economic redistribution. As can be seen, Blue Dogs are the right-most Democrats, while Justice Democrat are among the left-most. \n",
"\n",
"Four Justice Democrats are actually assigned moderate positions, but this is due to them voting against the Democratic Party, from the left but with Republicans, making them get assigned moderate spaces. [The people who created DW-NOMINATE, the scaling system used here, consider it a limitation with the model.](https://voteview.com/articles/ocasio_cortez)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `leaning` is taken from the Cook Partisan Voting Index, which takes each district's average vote between the Democratic and Republican presidential candidates over the past two elections and averages it out, to give approximate partisan leaning. It controls for how liberal or conservative a district is on average. Positive values indicate a leaning towards Republicans, negative values indicate towards Democrats. \n",
"\n",
"- `median_income_std` is household median income by district, standardized. \n",
"\n",
"- `incumbent` equals 1 if the Democrat is an incumbent representative and 0 if not. Later, I will use the `DICREX`, `DICRIN` etc. variables instead, which control for every combination of Democrat or Republican incumbent, and the experience level of either or both challengers (if an open seat). \n",
"\n",
"- I will also introduce variables covering `white_pct`, `black_pct`, and `hispanic_pct`, which indicate the racial breakdown of a district\n",
"\n",
"- `west`, `south`, and `mid_west` indicate the federal region of a district. `north_east` is omitted to prevent perfect multicollinearity.\n",
"\n",
"- Lastly, the `density` variables indicate how much of a district is composed of different levels of den"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Phase 2: Creating the Initial Models\n",
"\n",
"In this project, I'm further developing my ECON 490 thesis paper, in which I found that centrist Democratic candidates to the House of Representatives were much more likely, and very liberal candidates were much less likely, to win their elections than the baseline group. \n",
"\n",
"What I'm interested in now is not statistical significance, but seeing if I can generalize the models, test for overfitting, and get a good balance of variables to include to balance the various prediction metrics."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Creating Train/Test subsets of data, testing for overfitting"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# Making X with urban rates values\n",
"X = pd.DataFrame({\"blue_dog\": a_m_d_11[\"blue_dog\"],\n",
" \"justice_dem\": a_m_d_11[\"justice_dem\"],\n",
" \"leaning\": a_m_d_11[\"leaning\"],\n",
" \"median_income_std\": a_m_d_11[\"median_income_std\"],\n",
" \"incumbent\": a_m_d_11[\"Incumbent\"]\n",
"})\n",
"\n",
"X = sm.add_constant(X)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, win, test_size=0.50)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I will be running a linear probability model (an LPM, using OLS), a logistic probability model (logit), and a linear probability model using Lasso regression.\n",
"\n",
"Note: The division between training and testing datasets is random every time. Your results may vary slightly from what is printed in the cells, though I have made an effort to insert the variable where possible. "
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"const 0.000000\n",
"blue_dog 0.284747\n",
"justice_dem -0.179746\n",
"leaning -0.017555\n",
"median_income_std 0.085229\n",
"incumbent 0.297261\n",
"dtype: float64"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lpm_train = linear_model.LinearRegression()\n",
"lpm_train.fit(X_train, Y_train)\n",
"lpm_coefs_1 = pd.Series(dict(zip(list(X_train), lpm_train.coef_)))\n",
"lpm_coefs_1"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1.77021401e-05, 1.23859734e+00, -3.08421434e-01, -4.41878976e-01,\n",
" 7.28653367e-01, 9.68214737e-01])"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"logit_train = linear_model.LogisticRegression(solver=\"lbfgs\")\n",
"logit_train.fit(X_train, Y_train)\n",
"logit_coefs_1 = pd.Series(dict(zip(list(X_train), logit_train.coef_.round(3))))\n",
"\n",
"\n",
"def ltc_returner(x):\n",
" for number in x:\n",
" return number\n",
"\n",
"\n",
"logit_coef = ltc_returner(logit_train.coef_)\n",
"logit_coef"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## The Unfrazzled, No-Hassle, Lasso Progressive Regression Digression\n",
"\n",
"In the interest of making one very simple model to compare the more elaborate specifications against, I've run a linear probability model using Lasso regression, which shrinks effect sizes and in practice sets many coefficients equal to zero. I run it below as `lasso_model_1`."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"const 0.000000\n",
"blue_dog 0.000000\n",
"justice_dem -0.000000\n",
"leaning -0.020769\n",
"median_income_std 0.000000\n",
"incumbent 0.000000\n",
"dtype: float64"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"lasso_model_1 = linear_model.Lasso()\n",
"lasso_model_1.fit(X_train, Y_train)\n",
"\n",
"lasso_coefs_1 = pd.Series(dict(zip(list(X_train), lasso_model_1.coef_)))\n",
"lasso_coefs_1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Comparing Results"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
lpm
\n",
"
logit
\n",
"
lasso
\n",
"
\n",
" \n",
" \n",
"
\n",
"
const
\n",
"
0.000000
\n",
"
0.000018
\n",
"
0.000000
\n",
"
\n",
"
\n",
"
blue_dog
\n",
"
0.284747
\n",
"
1.238597
\n",
"
0.000000
\n",
"
\n",
"
\n",
"
justice_dem
\n",
"
-0.179746
\n",
"
-0.308421
\n",
"
-0.000000
\n",
"
\n",
"
\n",
"
leaning
\n",
"
-0.017555
\n",
"
-0.441879
\n",
"
-0.020769
\n",
"
\n",
"
\n",
"
median_income_std
\n",
"
0.085229
\n",
"
0.728653
\n",
"
0.000000
\n",
"
\n",
"
\n",
"
incumbent
\n",
"
0.297261
\n",
"
0.968215
\n",
"
0.000000
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" lpm logit lasso\n",
"const 0.000000 0.000018 0.000000\n",
"blue_dog 0.284747 1.238597 0.000000\n",
"justice_dem -0.179746 -0.308421 -0.000000\n",
"leaning -0.017555 -0.441879 -0.020769\n",
"median_income_std 0.085229 0.728653 0.000000\n",
"incumbent 0.297261 0.968215 0.000000"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"coefs = [\"const\", \"blue_dog\", \"justice_dem\", \"leaning\", \"median_income_std\", \"incumbent\"]\n",
"\n",
"coef_results = pd.DataFrame({#\"coefs\": coefs,\n",
" \"lpm\": lpm_coefs_1,\n",
" \"logit\": logit_coef,\n",
" #\"logit\": [-1.0000e-04, 1.7362e+00, -3.2600e-01, -4.8070e-01, 6.8980e-01, 8.0640e-01],\n",
" \"lasso\": lasso_coefs_1})\n",
"coef_results"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Results thus far?\n",
"\n",
"1. LPM and Logit models do show coefficient results on all but `const`\n",
"2. BUT: Lasso shows only `leaning` as having any coefficient\n",
"\n",
"### How do their accuracies look?"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"LPM training dataset accuracy is: 0.7120267695136987\n",
"LPM testing dataset accuracy is: 0.6805910921563088\n"
]
}
],
"source": [
"lpm_train_accuracy = lpm_train.score(X_train, Y_train)\n",
"lpm_test_accuracy = lpm_train.score(X_test, Y_test)\n",
"\n",
"print(f\"LPM training dataset accuracy is: {lpm_train_accuracy}\")\n",
"print(f\"LPM testing dataset accuracy is: {lpm_test_accuracy}\")"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Logit training dataset accuracy is: 0.9489795918367347\n",
"Logit testing dataset accuracy is: 0.9693877551020408\n"
]
}
],
"source": [
"logit_train_accuracy = logit_train.score(X_train, Y_train)\n",
"logit_test_accuracy = logit_train.score(X_test, Y_test)\n",
"\n",
"print(f\"Logit training dataset accuracy is: {logit_train_accuracy}\")\n",
"print(f\"Logit testing dataset accuracy is: {logit_test_accuracy}\")"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Lasso training dataset accuracy is: 0.6069187590068059\n",
"Lasso testing dataset accuracy is: 0.5832168022216864\n"
]
}
],
"source": [
"lasso_train_accuracy = lasso_model_1.score(X_train, Y_train)\n",
"lasso_test_acuracy = lasso_model_1.score(X_test, Y_test)\n",
"\n",
"\n",
"print(f\"Lasso training dataset accuracy is: {lasso_train_accuracy}\")\n",
"print(f\"Lasso testing dataset accuracy is: {lasso_test_acuracy}\")"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
LPM
\n",
"
Logit
\n",
"
Lasso
\n",
"
\n",
"
\n",
"
Type
\n",
"
\n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
"
\n",
"
Training
\n",
"
0.667
\n",
"
0.944
\n",
"
0.555
\n",
"
\n",
"
\n",
"
Testing
\n",
"
0.725
\n",
"
0.969
\n",
"
0.636
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" LPM Logit Lasso\n",
"Type \n",
"Training 0.667 0.944 0.555\n",
"Testing 0.725 0.969 0.636"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"accuracy_df = pd.DataFrame({\"Type\": [\"Training\", \"Testing\"],\n",
" \"LPM\": [0.667, 0.725],\n",
" \"Logit\": [0.944, 0.969],\n",
" \"Lasso\": [0.555, 0.636]})\n",
"accuracy_df = accuracy_df.set_index(\"Type\")\n",
"accuracy_df"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Question: What is the accuracy of just guessing the most likely outcome for both datasets?\n",
"\n",
"Because this is a binary dependent variable, it's worth asking what your baseline accuracy is if you simply guess the more common outcome variable every single time."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Average value in the training dataset is: 0.5051020408163265\n",
"Average value in the testing dataset is: 0.5051020408163265\n"
]
}
],
"source": [
"training_mean = Y_train.mean()\n",
"testing_mean = Y_test.mean()\n",
"\n",
"print(f\"Average value in the training dataset is: {training_mean}\")\n",
"print(f\"Average value in the testing dataset is: {testing_mean}\")"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"# Set up so that if modal_training_value >= 0.5, go with it, if not, go with 1 - modal_training_value\n",
"# likewise for modal_testing_value\n",
"\n",
"modal_training_value = Y_train.mean()\n",
"modal_testing_value = Y_test.mean()\n",
"\n",
"\n",
"if training_mean < 0.5:\n",
" modal_training_value = 1 - modal_training_value\n",
" \n",
"if modal_testing_value < 0.5:\n",
" modal_testing_value = 1 - modal_testing_value"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For example, if 1 makes up 49.5% of the training results, guessing 0 every time will give you an accuracy of (1 - 0.495) = 0.505. Because we want to improve on just guessing the most common result every time, we need to get at least this accuracy value for a model to be any use. \n",
"\n",
"I'll plot the \"guess the same value every time\" accuracy levels and those of the models, and see what we get."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"Types = [\"LPM Train\", \"LPM Test\", \n",
" \"Logit Train\", \"Logit Test\",\n",
" \"Lasso Train\", \"Lasso Test\"]\n",
"\n",
"Accuracy = [lpm_train_accuracy, lpm_test_accuracy, logit_train_accuracy, logit_test_accuracy, lasso_train_accuracy, lasso_test_acuracy]"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"\n",
"plt.stem(Accuracy)\n",
"plt.xticks(ticks = range(len(Types)), \n",
" labels = [\"LPM Train\", \"LPM Test\", \"Logit Train\", \"Logit Test\", \"Lasso Train\", \"Lasso Test\"], \n",
" )\n",
"plt.ylabel(\"Accuracy Rating\")\n",
"plt.xlabel(\"Models\")\n",
"plt.title(\"Accuracy Ratings of LPM, Logit, and Lasso models on Training, Testing Datasets\")\n",
"plt.ylim([0.4, 1])\n",
"\n",
"# Green Line is accuracy of guessing most common result (0) in Training dataset\n",
"plt.axhline(y=modal_training_value, color='g', linestyle='-')\n",
"\n",
"# Yellow line is accuracy of guessing most common result (1) in Testing dataset\n",
"plt.axhline(y=modal_testing_value, color='y', linestyle='-')\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Green Line is accuracy of guessing most common result in the Training dataset\n",
"#### Yellow line is accuracy of guessing most common result in the Testing dataset\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### A note on false positives versus false negatives\n",
"\n",
"Due to the nature of this experiment, we're wanting to predict if candidates are elected or not. A bit more than half were: `win.mean()` equals ~0.505. The breakdowns for the testing and training datasets will vary slightly, however. \n",
"\n",
"- A False Positive is when the model predicts 1 but the result is 0; ie. predicting a win but the candidate lost. \n",
"- A False Negative is when the model predicts 0 but the result is 1; ie. predicting a loss but the candidate won.\n",
"\n",
"In my opinion, we aren't particularly concerned with one of these more than the other. We aren't trying to catch a small number of disease cases out of a large number of healthy subjects (in which case a False Negative could kill someone!) or, say, deciding where to invest a lot of money to excavate a valuable resource (where a false positive causes a large amount of waste). \n",
"\n",
"Because of this, I think a good way to approach this is to make as accurate a model as we can, without overfitting. As said in the Classification lecture (\\# 22), when testing accuracy is equivalent or greater to training accuracy, we may be underfitting, and can use a more powerful model. \n",
"\n",
"Because of this, the next thing we do will be developing the `LPM` and `Logit` models, adding some more variables to increase accuracy without overfitting. Our \"unfrazzled no-hassle lasso progressive regression digression\" was fun, but `Lasso` performed little better than just guessing the most common result. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Precision and Recall\n",
"\n",
"While I think Accuracy should be the main focus, there's no harm in seeing if there's any notable trend in other classification metrics.\n",
"\n",
"Precision: Number of true positive predictions divided by the total number of positive predictions. In other words, of the times the model guesses positive, how often was it correct?\n",
"\n",
"Recall: Number of true positives divided by number of actual positives. In other words, of all positive result cases, how many did we predict?\n",
"\n",
"\n",
"I will assign \"Positive\" predictions as those with predicted probability equal to or greater than 0.5, and \"Negative\" predictions as those with predicted probability less than 0.5."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"pred_round = []\n",
"\n",
"\n",
"def round_series(x):\n",
" X_round = []\n",
" for prediction in x:\n",
" if float(prediction) < 0.5:\n",
" X_round.append(0)\n",
" elif float(prediction) >= 0.5:\n",
" X_round.append(1)\n",
" return X_round"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"lpm_train_round = []\n",
"lpm_train_round = round_series(lpm_train.predict(X_train))\n",
"lpm_test_round = round_series(lpm_train.predict(X_test))\n",
"\n",
"\n",
"logit_train_round = []\n",
"logit_train_round = round_series(logit_train.predict(X_train))\n",
"logit_test_round = round_series(logit_train.predict(X_test))\n",
"\n",
"lasso_train_round = []\n",
"lasso_train_round = round_series(lasso_model_1.predict(X_train))\n",
"lasso_test_round = round_series(lasso_model_1.predict(X_test))"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" precision recall f1-score support\n",
"\n",
" Loss 0.89 0.96 0.93 97\n",
" Win 0.96 0.89 0.92 99\n",
"\n",
" accuracy 0.92 196\n",
" macro avg 0.93 0.92 0.92 196\n",
"weighted avg 0.93 0.92 0.92 196\n",
"\n"
]
}
],
"source": [
"report_lpm = metrics.classification_report(\n",
" Y_train, lpm_train_round,\n",
" target_names = [\"Loss\", \"Win\"])\n",
"\n",
"print(report_lpm)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" precision recall f1-score support\n",
"\n",
" Loss 0.94 0.96 0.95 97\n",
" Win 0.96 0.94 0.95 99\n",
"\n",
" accuracy 0.95 196\n",
" macro avg 0.95 0.95 0.95 196\n",
"weighted avg 0.95 0.95 0.95 196\n",
"\n"
]
}
],
"source": [
"report_log = metrics.classification_report(\n",
" Y_train, logit_train_round,\n",
" target_names = [\"Loss\", \"Win\"])\n",
"\n",
"print(report_log)\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" precision recall f1-score support\n",
"\n",
" Loss 0.86 0.98 0.92 97\n",
" Win 0.98 0.85 0.91 99\n",
"\n",
" accuracy 0.91 196\n",
" macro avg 0.92 0.91 0.91 196\n",
"weighted avg 0.92 0.91 0.91 196\n",
"\n"
]
}
],
"source": [
"report_lasso = metrics.classification_report(\n",
" Y_train, lasso_train_round,\n",
" target_names = [\"Loss\", \"Win\"])\n",
"\n",
"print(report_lasso)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### So, when we round our predictions, `lpm` and `lasso` both do a lot better. \n",
"\n",
"However, `logit` still gets the highest precision and recall values; therefore also the greateset f1-score. \n",
"\n",
"Due to the poor showings of the `lasso` and `lpm` models in un-rounded accuracy tests, I'm going to discard them for now and move forward with just the `logit` model. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Conclusions from Phase 2:\n",
"\n",
"- Logit model is far more accurate than the LPM, which is more accurate than the Lasso model\n",
"\n",
"- All three have training accuracy values slightly lower than their testing dataset accuracy levels: this implies they could be slightly underfitted.\n",
"\n",
"- When un-rounded, the Lasso model is barely any more accurate than just guessing the most common outcome variable!\n",
"\n",
"- Rounding predictions to 0 or 1 improves results for `lpm` and `lasso`, but `logit` is still reliably the best."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Phase 3: Improving on `logit` performance\n",
"\n",
"\n",
"In my project, I used a more extensive specification for my models, also counting a variety of democraphic controls. Including all of these would lead to problems with a singular matrix when splitting into testing and training datasets - while my sample includes nearly all House of Representatives elections in the 2018 Midterms, splitting it up makes the sample size too small. It also relies on a large number of dummy variables, which can become linearly dependent easily. \n",
"\n",
"So, I'm going to take the above specification, and add one set of controls at a time. These are:\n",
"\n",
"- Federal Region\n",
"- Urbanization\n",
"- Racial composition\n",
"- An expanded set of candidate traits\n",
"\n",
"We're going to see how the additions impact prediction quality. I want to increase Accuracy on both the testing and training datasets, but not have testing accuracy significantly exceed training accuracy. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## First setting up the dataframes, splitting into training/testing sets"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"X_reg = pd.DataFrame({\"blue_dog\": a_m_d_11[\"blue_dog\"],\n",
" \"justice_dem\": a_m_d_11[\"justice_dem\"],\n",
" \"leaning\": a_m_d_11[\"leaning\"],\n",
" \"median_income_std\": a_m_d_11[\"median_income_std\"],\n",
" \"incumbent\": a_m_d_11[\"Incumbent\"],\n",
" \"west\": a_m_d_11[\"west\"],\n",
" \"south\": a_m_d_11[\"south\"],\n",
" \"mid_west\": a_m_d_11[\"mid_west\"]\n",
"})\n",
"\n",
"X_reg = sm.add_constant(X_reg)\n",
"\n",
"X_race = pd.DataFrame({\"blue_dog\": a_m_d_11[\"blue_dog\"],\n",
" \"justice_dem\": a_m_d_11[\"justice_dem\"],\n",
" \"leaning\": a_m_d_11[\"leaning\"],\n",
" \"incumbent\": a_m_d_11[\"Incumbent\"],\n",
" \"median_income_std\": a_m_d_11[\"median_income_std\"],\n",
" \"white_pct\": a_m_d_11[\"white_pct\"],\n",
" \"black_pct\": a_m_d_11[\"black_pct\"],\n",
" \"hispanic_pct\": a_m_d_11[\"hispanic_pct\"]\n",
"})\n",
"\n",
"X_race = sm.add_constant(X_race)\n",
"\n",
"X_inc = pd.DataFrame({\"blue_dog\": a_m_d_11[\"blue_dog\"],\n",
" \"justice_dem\": a_m_d_11[\"justice_dem\"],\n",
" \"leaning\": a_m_d_11[\"leaning\"],\n",
" \"median_income_std\": a_m_d_11[\"median_income_std\"],\n",
" \"DICRIN\": a_m_d_11[\"DICRIN\"],\n",
" \"DICREX\": a_m_d_11[\"DICREX\"],\n",
" \"RICDIN\": a_m_d_11[\"RICDIN\"],\n",
" \"RICDEX\": a_m_d_11[\"RICDEX\"],\n",
" \"DEXRIN\": a_m_d_11[\"DEXRIN\"],\n",
" \"DINREX\": a_m_d_11[\"DINREX\"],\n",
" \"DEXREX\": a_m_d_11[\"DEXREX\"]\n",
"})\n",
"\n",
"X_inc = sm.add_constant(X_inc)\n",
"\n",
"\n",
"X_urb_rates = pd.DataFrame({\"blue_dog\": a_m_d_11[\"blue_dog\"],\n",
" \"justice_dem\": a_m_d_11[\"justice_dem\"],\n",
" \"leaning\": a_m_d_11[\"leaning\"],\n",
" \"median_income_std\": a_m_d_11[\"median_income_std\"],\n",
" \"incumbent\": a_m_d_11[\"Incumbent\"],\n",
" \"very_low_urb\": a_m_d_11[\"Very low density\"],\n",
" \"low_urb\": a_m_d_11[\"Low density\"],\n",
" \"medium_urb\": a_m_d_11[\"Medium density\\t\"],\n",
"})\n",
"\n",
"X_urb_rates = sm.add_constant(X_urb_rates)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"X_reg_train, X_reg_test, Y_reg_train, Y_reg_test = model_selection.train_test_split(X_reg, win, test_size=0.50)\n",
"X_race_train, X_race_test, Y_race_train, Y_race_test = model_selection.train_test_split(X_race, win, test_size=0.50)\n",
"X_inc_train, X_inc_test, Y_inc_train, Y_inc_test = model_selection.train_test_split(X_inc, win, test_size=0.50)\n",
"X_urb_train, X_urb_test, Y_urb_train, Y_urb_test = model_selection.train_test_split(X_urb_rates, win, test_size=0.50)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Next, running each model"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.stem(Accuracy)\n",
"plt.xticks(ticks = range(len(Types)), \n",
" labels = Types, rotation = 45)\n",
"\n",
"plt.ylim([0.9, 1])\n",
"plt.ylabel(\"Accuracy Rating\")\n",
"plt.xlabel(\"Models\")\n",
"plt.title(\"Accuracy Ratings of Regional, Race Proportion, Candidate Characteristics, and Urbanization \\n models on Training, Testing Datasets\")\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that the axis is from 0.9 to 1: the accuracy ratings are all closer than they appear. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Results will not impress: accuracy values are likely slightly higher on average than the basic logit model, but not much, and many will likely have higher accuracy values in the training than testing case. This implies the extra variables are just causing the model to overfit to the variance in the training data. \n",
"\n",
"Most likely, there's just not much more accuracy to gain from adding more variables, as the variables already included in the basic logit function already have high predictive power. \n",
"\n",
"So, I'm going to just stick with the basic logit model from this point onwards."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Part Four: Counterfactuals\n",
"\n",
"\n",
"A big motivator for the paper was seeing if there was a causal effect of candidate ideology (ie. if a Democratic candidate was very moderate and centrist, or very liberal, or in between) on election win probability. In my paper, I found large and significant coefficients on the `Blue_Dog` and `Justice_Democrat` variables (signifying if a candidate was a centrist or a liberal, respectively), and of comparable size to other results found in the literature. I will assume this change in win probability was causal.\n",
"\n",
"So, now I want to play around with it, and see what differences we might expect in the US House of Representatives if more candidate had run as liberals or centrists. "
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The number of Democrats who win in the real election was: 198\n"
]
}
],
"source": [
"print(\"The number of Democrats who win in the real election was:\", win.sum())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Prediction: If all Democrats ran as Blue Dogs or Justice Democrats\n",
"\n",
"First, I will take the full dataset for `X`, set all `blue_dog` variables to 1, and set all `justice_dem` variables to 0. This implies the whole Democratic Party running as centrists.\n",
"\n",
"In order for `predict` to work, there have to be some rows with different values in each colum. I set row 390's Blue Dog value to 0, and row 391's Blue Dog value to 0 and Justice Democrat value to 1, so that we don't have perfect multicollearity. Both of these were in fairly Republican-leaning districts, so I wouldn't expect either to be winnable. "
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [],
"source": [
"X_BD = pd.DataFrame({\"blue_dog\": 1,\n",
" \"justice_dem\": 0,\n",
" \"leaning\": a_m_d_11[\"leaning\"],\n",
" \"median_income_std\": a_m_d_11[\"median_income_std\"],\n",
" \"incumbent\": a_m_d_11[\"Incumbent\"]\n",
"})\n",
"\n",
"X_BD.at[391, \"blue_dog\"] = 0\n",
"X_BD.at[390, \"blue_dog\"] = 0\n",
"X_BD.at[390, \"justice_dem\"] = 1\n",
"\n",
"X_BD = sm.add_constant(X_BD)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" const blue_dog justice_dem leaning median_income_std incumbent\n",
"387 1.0 0 1 13 0.410261 0\n",
"388 1.0 0 1 8 -0.224496 0\n",
"389 1.0 0 1 8 -0.484215 0\n",
"390 1.0 0 0 7 -0.182897 0\n",
"391 1.0 1 0 25 -0.059912 0"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X_JD.tail()"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [],
"source": [
"logit_jd_predictions = logit_train.predict(X_JD)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [],
"source": [
"pred_jd_wins = logit_jd_predictions.mean() * 392"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The number of winning Democrats in the sample is: 198\n",
"The number of predicted Democrat wins, if all ran as centrists, is 209.0\n",
"The number of predicted Democrat wins, if all ran as liberals, is 182.0\n"
]
}
],
"source": [
"print(f\"The number of winning Democrats in the sample is: {round(dem_wins)}\")\n",
"print(f\"The number of predicted Democrat wins, if all ran as centrists, is {pred_bd_wins}\")\n",
"print(f\"The number of predicted Democrat wins, if all ran as liberals, is {pred_jd_wins}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The real-life outcome of the election was the Democrats winning 235 of 435 seats. The sample was reduced to 392 because of 43 seats with abnormal elections - candidates running unopposed, against a weak independent or third party, or with many candidates running under a [Jungle Primary ruleset](https://en.wikipedia.org/wiki/Nonpartisan_blanket_primary). These were removed; most had lopsided results and would likely not change.\n",
"\n",
"\n",
"You can observe how many seats the Demcrats in the sample are expected to win. I'd expect that the centrist case increases their hold on the House, but doesn't reach a supermajority, while the liberal case weakens their hold but won't result in enough losses to lose them the chamber. Simply subtract 198 from the number of Centrist/Liberal case wins to see what the difference will be.\n",
"\n",
"Due to the heavily nationalized media environment, candidates often struggle to distinguish themselves from their party. I would expect that the whole Democratic Party moving towards the center to have a much larger effect due to this. The predictions here essentially take the effect for a candidate on the margin, if he changed from a normal Democrat to a centrist, and apply it to everyone. The party changing how it's perceived by voters would cause an additional increase in electability.\n"
]
}
],
"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.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}