From c7422ca15a09b2dbd6e2884674b7e2d955aa51f5 Mon Sep 17 00:00:00 2001 From: Saran Ahluwalia Date: Sun, 12 Dec 2021 14:33:45 -0500 Subject: [PATCH] added percentile rank and current percentile comparison --- ...een_methodologies-ranking-percentile.ipynb | 1414 +++++++++++++++++ 1 file changed, 1414 insertions(+) create mode 100644 data/data-pipeline/data_pipeline/ipython/hud_eda_se_12_12_2011_relative_differences_between_methodologies-ranking-percentile.ipynb diff --git a/data/data-pipeline/data_pipeline/ipython/hud_eda_se_12_12_2011_relative_differences_between_methodologies-ranking-percentile.ipynb b/data/data-pipeline/data_pipeline/ipython/hud_eda_se_12_12_2011_relative_differences_between_methodologies-ranking-percentile.ipynb new file mode 100644 index 00000000..ac894cfd --- /dev/null +++ b/data/data-pipeline/data_pipeline/ipython/hud_eda_se_12_12_2011_relative_differences_between_methodologies-ranking-percentile.ipynb @@ -0,0 +1,1414 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Methodology to address fundamental problem 1 itemized in Issue 1024 - follow-up compare tabulations and relative household burden. This time I extend the 12-11 notebook to look at how the percentile ranks affects the proportion of tracts considered as burdened versus the current methodology." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Indicator reviewed: \n", + "\n", + "Socioeconomic Factors Indicator reviewed\n", + "* [Extreme Housing Burden](#housingburden)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import numpy as np\n", + "import os\n", + "import pandas as pd\n", + "\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ETL process for acquiring relevant tables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### NOTE: If you ran the ETL Process to acquire Table 8 in the other notebook of this draft PR you do not need to run the ETL cell block again" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copy and adapt certain sections of code from data_pipeline.utils \n", + "\n", + "def download_hud_dataset():\n", + " DOWNLOAD_FILENAME = \"HUD_ZIPPED.csv\"\n", + " HOUSING_FTP_URL = \"https://www.huduser.gov/portal/datasets/cp/2014thru2018-140-csv.zip\" \n", + " response = requests.get(HOUSING_FTP_URL, verify=True)\n", + " if response.status_code == 200:\n", + " file_contents = response.content\n", + " else:\n", + " sys.exit(\n", + " f\"HTTP response {response.status_code} from url {file_url}. Info: {response.content}\"\n", + " )\n", + "\n", + " # Write the contents to disk.\n", + " file = open(DOWNLOAD_FILENAME, \"wb\")\n", + " file.write(file_contents)\n", + " file.close()\n", + " \n", + "def extract_zipped_download(zip_file_path, unzipped_path):\n", + " with zipfile.ZipFile(zip_file_path, \"r\") as zip_ref:\n", + " zip_ref.extractall(unzipped_path)\n", + " # cleanup temporary file\n", + " os.remove(zip_file_path)\n", + " \n", + "def up_one_directory(path):\n", + " try:\n", + " # from Python 3.6\n", + " parent_dir = Path(path).parents[1]\n", + " # for Python 3.4/3.5, use str to convert the path to string\n", + " # parent_dir = str(Path(path).parents[1])\n", + " shutil.move(path, parent_dir)\n", + " except IndexError:\n", + " # no upper directory\n", + " pass\n", + "\n", + "CURRENT_DIRECTORY = os.getcwd()\n", + "download_hud_dataset()\n", + "extract_zipped_download(CURRENT_DIRECTORY + \"/HUD_ZIPPED.csv\", CURRENT_DIRECTORY) \n", + "up_one_directory(CURRENT_DIRECTORY + \"/140/Table8.csv\")\n", + "shutil.rmtree(\"./140/\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Extreme Housing Burden \n", + "\n", + "The Extreme Housing Burden indicator represents the proportion of low-income households that have to spend more than half their income on rent. These households experience higher levels of stress, report lower health, and may delay medical treatment because of its high cost.\n", + "\n", + "The Extreme Housing Burden indicator measures the percent of households in a census tract that are:\n", + "\n", + "1. Making less than 80% of the Area Median Family Income as determined by the Department of Housing and Urban Development (HUD), and\n", + "2. Paying greater than 50% of their income to housing costs. \n", + "\n", + "This data is sourced from the 2014-2018 Comprehensive Housing Affordability Strategy dataset from the Department of Housing and Urban Development (HUD) using the census tract geographic summary level, and contains cost burdens for households by percent HUD-adjusted median family income (HAMFI) category. This data can be found [here](https://www.huduser.gov/portal/datasets/cp.html). \n", + "\n", + "Because CHAS data is based on American Communities Survey (ACS) estimates, which come from a sample of the population, they may be unreliable if based on a small sample or population size.\n", + "\n", + "The standard error and relative standard error were used to evaluate the reliability of each estimate using CalEnviroScreen’s methodology. \n", + "\n", + "Census tract estimates that met either of the following criteria were considered reliable and included in the analysis [(CalEnviroScreen, 2017, page 129)](https://oehha.ca.gov/media/downloads/calenviroscreen/report/ces3report.pdf ):\n", + "\n", + "- Relative standard error less than 50 (meaning the standard error was less than half of the estimate), OR \n", + "- Standard error less than the mean standard error of all census tract estimates \n", + "\n", + "Formulas for calculating the standard error of sums, proportions, and ratio come from the [American Communities Survey Office](https://www2.census.gov/programs-surveys/acs/tech_docs/accuracy/MultiyearACSAccuracyofData2013.pdf).\n", + "\n", + "Note that this code creates a score and rank by state, for every state." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The relevant variables in table 8 of the CHAS dataset are the following (CHAS data dictionary available [here](https://www.huduser.gov/portal/datasets/cp/CHAS-data-dictionary-14-18.xlsx)):\n", + "\n", + "| Name | Label |\n", + "|---------|-----------------------------------------------------|\n", + "|T1_est1 | Total Occupied housing units | \n", + "|T8_est10 | Owner occupied less than or equal to 30% of HAMFI cost burden greater than 50% |\n", + "|T8_est23 |Owner occupied greater than 30% but less than or equal to 50% of HAMFI\tcost burden greater than 50%|\n", + "|T8_est36 |Owner occupied\tgreater than 50% but less than or equal to 80% of HAMFI\tcost burden greater than 50%|\n", + "|T8_est76 | Renter occupied less than or equal to 30% of HAMFI cost burden greater than 50% |\n", + "|T8_est89 |Renter occupied\tgreater than 30% but less than or equal to 50% of HAMFI\tcost burden greater than 50%|\n", + "|T8_est102|Renter occupied\tgreater than 50% but less than or equal to 80% of HAMFI\tcost burden greater than 50%|\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Below I also propose an alternate means for ranking census tracts\n", + "### These steps are outlined and commented below" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.9/site-packages/pandas/core/arraylike.py:364: RuntimeWarning: invalid value encountered in sqrt\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n", + "/usr/local/lib/python3.9/site-packages/pandas/core/indexing.py:1732: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " self._setitem_single_block(indexer, value, name)\n" + ] + } + ], + "source": [ + "# Read in the data from https://www.huduser.gov/portal/datasets/cp.html\n", + "housing = pd.read_csv(\"Table8.csv\", \n", + " encoding = \"ISO-8859-1\", \n", + " dtype = {'Tract_ID': object, 'st': object, 'geoid': object})\n", + "\n", + "# Remove data for states that aren't included in the census (e.g. American Samoa, Guam, etc.):\n", + "housing.drop(housing.loc[housing['st'] == '72'].index, inplace = True)\n", + "\n", + "# Combine owner and renter occupied low-income households that make less than 80% of HAMFI into one variable\n", + "housing['summed'] = (housing['T8_est10'] + \n", + " housing['T8_est23'] + \n", + " housing['T8_est36'] + \n", + " housing['T8_est76'] + \n", + " housing['T8_est89'] + \n", + " housing['T8_est102'])\n", + "\n", + "# Create a variable for the standard error of the summed variables\n", + "housing['summed_se'] = np.sqrt((housing['T8_moe10'] / 1.645)**2 + \n", + " (housing['T8_moe23'] / 1.645)**2 + \n", + " (housing['T8_moe36'] / 1.645)**2 + \n", + " (housing['T8_moe76'] / 1.645)**2 + \n", + " (housing['T8_moe89'] / 1.645)**2 + \n", + " (housing['T8_moe102'] / 1.645)**2)\n", + "\n", + "# Remove the first 7 digits in the FIPS Census Tract ID \n", + "housing['geoid'] = housing['geoid'].str[-11:]\n", + "\n", + "# Find the estimate of the proportion of the population that is heavily rent burdened\n", + "housing['hbrd_score'] = housing['summed'] / housing['T8_est1']\n", + "\n", + "# Change rates where the population is 0 to nan\n", + "housing['hbrd_score'].replace(np.inf, np.nan, inplace = True)\n", + "\n", + "# Create function for calculating the standard error, using the proportions standard error formula\n", + "# if the value under the radical is negative, use the ratio standard error formula\n", + "def se_prop(x, y, se_x, moe_y): \n", + " se_y = moe_y / 1.645\n", + " test = se_x**2 - (((x**2)/(y**2))*((se_y)**2))\n", + " se = np.where(test < 0,\n", + " (1/y) * np.sqrt(se_x**2 + (((x**2)/(y**2))*(se_y**2))), \n", + " (1/y) * np.sqrt(se_x**2 - (((x**2)/(y**2))*(se_y**2))))\n", + " return se\n", + "\n", + "housing['se'] = se_prop(housing['summed'], housing['T8_est1'], housing['summed_se'], housing['T8_moe1'])\n", + "\n", + "# Calculate the relative standard error\n", + "housing['rse'] = housing['se'] / housing['hbrd_score']*100\n", + "\n", + "# Change infinite rse's where the housing burden is 0 to np.nan\n", + "housing['rse'].replace(np.inf, np.nan, inplace = True)\n", + "\n", + "# Calculate the mean standard error for each state\n", + "housing['mean_state_se'] = np.zeros(len(housing))\n", + "\n", + "for state in housing['st'].unique():\n", + " mean_se = np.mean(housing[housing['st'] == state]['se'])\n", + " housing['mean_state_se'].loc[housing['st'] == state] = mean_se\n", + " \n", + "# Find census tract estimates that meet both of the following criteria and are thus considered unreliable estimates: \n", + "# RSE less than 50 AND\n", + "# SE less than the mean state SE or housing burdened low income households\n", + "# Convert these scores to nan\n", + "housing.loc[(housing['rse'] >= 50) & (housing['rse'] >= housing['mean_state_se']), 'hbrd_score'] = np.nan\n", + "\n", + "# Rename columns\n", + "housing = housing.rename(columns = {'geoid' :'FIPS_tract_id',\n", + " 'st' : 'state'\n", + " })\n", + "\n", + "# Calculate percentile rank for census tracts with a score above 0, set percentile to 0 if score is 0, for each state\n", + "housing['hbrd_rank'] = housing[\n", + " housing['hbrd_score'] != 0][['hbrd_score',\n", + " 'state']].groupby('state').rank( \n", + " na_option = 'keep', \n", + " pct = True) * 100\n", + "\n", + "housing.loc[housing['hbrd_score'] == 0, 'hbrd_rank'] = 0\n", + "\n", + "# Create final housing burden df\n", + "housingburden = housing.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sourcesumlevelFIPS_tract_idnamestatecntytractT8_est1T8_est2T8_est3...T8_moe131T8_moe132T8_moe133summedsummed_sehbrd_scoresersemean_state_sehbrd_rank
02014thru201814001001020100Census Tract 201, Autauga County, Alabama0112010076557050...1212128031.7218070.1045750.04103239.2373140.03660446.298077
12014thru201814001001020200Census Tract 202, Autauga County, Alabama0112020072046565...12121213845.5318740.1916670.06161432.1466590.03660483.269231
22014thru201814001001020300Census Tract 203, Autauga County, Alabama01120300129584060...12121217053.7229210.1312740.04092731.1769990.03660463.653846
32014thru201814001001020400Census Tract 204, Autauga County, Alabama011204001640126015...12121214546.2885100.0884150.02782231.4673970.03660434.615385
42014thru201814001001020500Census Tract 205, Autauga County, Alabama0112050041752320175...171717595147.2216930.1425150.03476024.3901930.03660468.221154
\n", + "

5 rows × 280 columns

\n", + "
" + ], + "text/plain": [ + " source sumlevel FIPS_tract_id \\\n", + "0 2014thru2018 140 01001020100 \n", + "1 2014thru2018 140 01001020200 \n", + "2 2014thru2018 140 01001020300 \n", + "3 2014thru2018 140 01001020400 \n", + "4 2014thru2018 140 01001020500 \n", + "\n", + " name state cnty tract T8_est1 \\\n", + "0 Census Tract 201, Autauga County, Alabama 01 1 20100 765 \n", + "1 Census Tract 202, Autauga County, Alabama 01 1 20200 720 \n", + "2 Census Tract 203, Autauga County, Alabama 01 1 20300 1295 \n", + "3 Census Tract 204, Autauga County, Alabama 01 1 20400 1640 \n", + "4 Census Tract 205, Autauga County, Alabama 01 1 20500 4175 \n", + "\n", + " T8_est2 T8_est3 ... T8_moe131 T8_moe132 T8_moe133 summed summed_se \\\n", + "0 570 50 ... 12 12 12 80 31.721807 \n", + "1 465 65 ... 12 12 12 138 45.531874 \n", + "2 840 60 ... 12 12 12 170 53.722921 \n", + "3 1260 15 ... 12 12 12 145 46.288510 \n", + "4 2320 175 ... 17 17 17 595 147.221693 \n", + "\n", + " hbrd_score se rse mean_state_se hbrd_rank \n", + "0 0.104575 0.041032 39.237314 0.036604 46.298077 \n", + "1 0.191667 0.061614 32.146659 0.036604 83.269231 \n", + "2 0.131274 0.040927 31.176999 0.036604 63.653846 \n", + "3 0.088415 0.027822 31.467397 0.036604 34.615385 \n", + "4 0.142515 0.034760 24.390193 0.036604 68.221154 \n", + "\n", + "[5 rows x 280 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "housingburden.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(73056, 4)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "housingburden.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### As desired we see a uniform distribution for the percentile rank for burdened households" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 8))\n", + "plt.title('Relative Housing Burden (Percentile rank) - CalEnvironScreen Methodology')\n", + "# Set x-axis label\n", + "plt.xlabel('Percentile Rank')\n", + "# Set y-axis label\n", + "plt.ylabel('Relative Frequency in Support')\n", + "\n", + "sns.histplot(housingburden[\"hbrd_rank\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now we compute for a baseline comparison " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Owner occupied numerator fields\n", + "OWNER_OCCUPIED_NUMERATOR_FIELDS = [\n", + " # Column Name\n", + " # Line_Type\n", + " # Tenure\n", + " # Household income\n", + " # Cost burden\n", + " # Facilities\n", + " \"T8_est7\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # less than or equal to 30% of HAMFI\n", + " # greater than 30% but less than or equal to 50%\n", + " # All\n", + " \"T8_est10\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # less than or equal to 30% of HAMFI\n", + " # greater than 50%\n", + " # All\n", + " \"T8_est20\",\n", + " \n", + " # Subtotal\n", + " # Owner occupied\n", + " # greater than 30% but less than or equal to 50% of HAMFI\n", + " # greater than 30% but less than or equal to 50%\n", + " # All\n", + " \"T8_est23\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # greater than 30% but less than or equal to 50% of HAMFI\n", + " # greater than 50%\n", + " # All\n", + " \"T8_est33\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # greater than 50% but less than or equal to 80% of HAMFI\n", + " # greater than 30% but less than or equal to 50%\n", + " # All\n", + " \"T8_est36\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # greater than 50% but less than or equal to 80% of HAMFI\n", + " # greater than 50%\n", + " # All\n", + "]\n", + "\n", + "# These rows have the values where HAMFI was not computed, b/c of no or negative income.\n", + "OWNER_OCCUPIED_NOT_COMPUTED_FIELDS = [\n", + " # Column Name\n", + " # Line_Type\n", + " # Tenure\n", + " # Household income\n", + " # Cost burden\n", + " # Facilities\n", + " \"T8_est13\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # less than or equal to 30% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + " \"T8_est26\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # greater than 30% but less than or equal to 50% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + " \"T8_est39\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # greater than 50% but less than or equal to 80% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + " \"T8_est52\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # greater than 80% but less than or equal to 100% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + " \"T8_est65\",\n", + " # Subtotal\n", + " # Owner occupied\n", + " # greater than 100% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + "]\n", + "\n", + "OWNER_OCCUPIED_POPULATION_FIELD = \"T8_est2\"\n", + "# Subtotal\n", + "# Owner occupied\n", + "# All\n", + "# All\n", + "# All\n", + "\n", + "OWNER_OCCUPIED_POPULATION_HAMFI_FIELD = \"T8_est3\"\n", + "# Subtotal\n", + "# Owner occupied \n", + "# All\n", + "# All\n", + "# All\n", + "\n", + "# Renter occupied numerator fields\n", + "RENTER_OCCUPIED_NUMERATOR_FIELDS = [\n", + " # Column Name\n", + " # Line_Type\n", + " # Tenure\n", + " # Household income\n", + " # Cost burden\n", + " # Facilities\n", + " \"T8_est73\",\n", + " # Subtotal\n", + " # Renter occupied\n", + " # less than or equal to 30% of HAMFI\n", + " # greater than 30% but less than or equal to 50%\n", + " # All\n", + " \"T8_est76\",\n", + " # Subtotal\n", + " # Renter occupied\n", + " # less than or equal to 30% of HAMFI\n", + " # greater than 50%\n", + " # All\n", + " \"T8_est86\",\n", + " # Subtotal\n", + " # Renter occupied\n", + " # greater than 30% but less than or equal to 50% of HAMFI\n", + " # greater than 30% but less than or equal to 50%\n", + " # All\n", + " \"T8_est89\",\n", + " # Subtotal\n", + " # Renter occupied\n", + " # greater than 30% but less than or equal to 50% of HAMFI\n", + " # greater than 50%\n", + " # All\n", + " \"T8_est99\",\n", + " # Subtotal\n", + " # Renter occupied\tgreater than 50% but less than or equal to 80% of HAMFI\n", + " # greater than 30% but less than or equal to 50%\n", + " # All\n", + " \"T8_est102\",\n", + " # Subtotal\n", + " # Renter occupied\n", + " # greater than 50% but less than or equal to 80% of HAMFI\n", + " # greater than 50%\n", + " # All\n", + "]\n", + "\n", + "# These rows have the values where HAMFI was not computed, b/c of no or negative income.\n", + "RENTER_OCCUPIED_NOT_COMPUTED_FIELDS = [\n", + " # Column Name\n", + " # Line_Type\n", + " # Tenure\n", + " # Household income\n", + " # Cost burden\n", + " # Facilities\n", + " \"T8_est79\",\n", + " # Subtotal\n", + " # Renter occupied\tless than or equal to 30% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + " \"T8_est92\",\n", + " # Subtotal\n", + " # Renter occupied\tgreater than 30% but less than or equal to 50% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + " \"T8_est105\",\n", + " # Subtotal\n", + " # Renter occupied\n", + " # greater than 50% but less than or equal to 80% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + " \"T8_est118\",\n", + " # Subtotal\n", + " # Renter occupied\tgreater than 80% but less than or equal to 100% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + " \"T8_est131\",\n", + " # Subtotal\n", + " # Renter occupied\n", + " # greater than 100% of HAMFI\n", + " # not computed (no/negative income)\n", + " # All\n", + "]\n", + "\n", + "# T8_est68\tSubtotalRenter occupied\tAll\tAll\tAll\n", + "RENTER_OCCUPIED_POPULATION_FIELD = \"T8_est68\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "housingburden[\"current_summed_methodology\"] = housingburden[\n", + " OWNER_OCCUPIED_NUMERATOR_FIELDS\n", + "].sum(axis=1) + housingburden[RENTER_OCCUPIED_NUMERATOR_FIELDS].sum(axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "housingburden[\"current_methodology_denominator\"] = (\n", + " housingburden[OWNER_OCCUPIED_POPULATION_FIELD]\n", + " + housingburden[RENTER_OCCUPIED_POPULATION_FIELD]\n", + " - housingburden[OWNER_OCCUPIED_NOT_COMPUTED_FIELDS].sum(axis=1)\n", + " - housingburden[RENTER_OCCUPIED_NOT_COMPUTED_FIELDS].sum(axis=1)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "housingburden[\"current_methodology_percent\"] = np.round(\n", + " (housingburden[\"current_summed_methodology\"] / housingburden[\"current_methodology_denominator\"] ), 2) * 100" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "housingburden[\"absolute_difference\"] = housingburden[\n", + " \"current_summed_methodology\"] - housingburden[\"summed\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "housingburden.to_csv(\"housing_burden_percentiles_12122021.csv\", index=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now we construct the distribution of differences in the number of owned and rented burdened households\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "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.figure(figsize=(12, 8))\n", + "plt.title('Distribution of differences between two methodologies')\n", + "# Set x-axis label\n", + "plt.xlabel('Aggregate total owner and renter occupied low-income households < 80%')\n", + "# Set y-axis label\n", + "plt.ylabel('Relative Frequency in Support')\n", + "\n", + "sns.histplot(housingburden[\"absolute_difference\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting both distributions for accounting for different aggregations of owned and rented burdened households. Red is the revised version; green is the current methodology" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.9/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n", + "/usr/local/lib/python3.9/site-packages/seaborn/distributions.py:2103: FutureWarning: The `axis` variable is no longer used and will be removed. Instead, assign variables directly to `x` or `y`.\n", + " warnings.warn(msg, FutureWarning)\n", + "/usr/local/lib/python3.9/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n", + "/usr/local/lib/python3.9/site-packages/seaborn/distributions.py:2103: FutureWarning: The `axis` variable is no longer used and will be removed. Instead, assign variables directly to `x` or `y`.\n", + " warnings.warn(msg, FutureWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Aggregate total owner and renter occupied low-income households < 80%')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.set_color_codes()\n", + "plt.figure(figsize=(12, 8))\n", + "plt.title('Owner and renter occupied low-income households that make less than 80% of HAMF')\n", + "# Set y-axis label\n", + "plt.ylabel('Kernel density estimate')\n", + "\n", + "sns.distplot(housingburden[\"current_summed_methodology\"], \n", + " rug_kws={\"color\": \"green\"}, rug = True, \n", + " kde_kws={\"color\": \"g\", \"lw\": 3, \"label\": \"KDE\"},\n", + " hist_kws={\"histtype\": \"step\", \"linewidth\": 3,\n", + " \"alpha\": 1, \"color\": \"green\"}\n", + " )\n", + "sns.distplot(housingburden[\"summed\"], \n", + " rug_kws={\"color\": \"red\"}, rug = True, \n", + " kde_kws={\"color\": \"r\", \"lw\": 3, \"label\": \"KDE\"},\n", + " hist_kws={\"histtype\": \"step\", \"linewidth\": 3,\n", + " \"alpha\": 1, \"color\": \"red\"}\n", + " )\n", + "\n", + "plt.xlabel('Aggregate total owner and renter occupied low-income households < 80%')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Now let's focus on West Virginia (FIPS code 54) and perform a nonparametric test to validate that the distributions are different for the health burden across all census tracts within West Virginia\n", + "\n", + "\n", + "Permutation sampling is a method to simulate the hypothesis that two variables have identical probability distributions. We perform this below. The red ECDF is the current tabulation of burdened household. The blue the proposed methodology for tabulation." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def permutation_sample(data1, data2):\n", + " \"\"\"Generate a permutation sample from two data sets.\"\"\"\n", + "\n", + " # Concatenate the data sets: data\n", + " data = np.concatenate((data1, data2))\n", + "\n", + " # Permute the concatenated array: permuted_data\n", + " permuted_data = np.random.permutation(data)\n", + "\n", + " # Split the permuted array into two: perm_sample_1, perm_sample_2\n", + " perm_sample_1 = permuted_data[:len(data1)]\n", + " perm_sample_2 = permuted_data[len(data1):]\n", + "\n", + " return perm_sample_1, perm_sample_2\n", + "\n", + "def ecdf(data):\n", + " \"\"\"Compute ECDF for a one-dimensional array of measurements.\"\"\"\n", + " # Number of data points: n\n", + " n = len(data)\n", + "\n", + " # x-data for the ECDF: x\n", + " x = np.sort(data)\n", + "\n", + " # y-data for the ECDF: y\n", + " y = np.arange(1, n+1) / n\n", + "\n", + " return x, y\n", + "\n", + "\n", + "current_methodology = housingburden[housingburden[\"state\"] == '54'][\"current_summed_methodology\"].values\n", + "revised_methodology = housingburden[housingburden[\"state\"] == '54'][\"summed\"].values\n", + "\n", + "for _ in range(100):\n", + " # Generate permutation samples\n", + " perm_sample_1, perm_sample_2 = permutation_sample(current_methodology, revised_methodology)\n", + "\n", + "\n", + " # Compute ECDFs\n", + " x_1, y_1 = ecdf(perm_sample_1)\n", + " x_2, y_2 = ecdf(perm_sample_2)\n", + "\n", + " # Plot ECDFs of permutation sample\n", + " _ = plt.plot(x_1, y_1, marker='.', linestyle='none',\n", + " color='red', alpha=0.02)\n", + " _ = plt.plot(x_2, y_2, marker='.', linestyle='none',\n", + " color='blue', alpha=0.02)\n", + "\n", + "# Create and plot ECDFs from original data\n", + "x_1, y_1 = ecdf(current_methodology)\n", + "x_2, y_2 = ecdf(revised_methodology)\n", + "_ = plt.plot(x_1, y_1, marker='.', linestyle='none', color='red')\n", + "_ = plt.plot(x_2, y_2, marker='.', linestyle='none', color='blue')\n", + "\n", + "# Label axes, set margin, and show plot\n", + "plt.margins(0.02)\n", + "_ = plt.xlabel('Total number of owner and rental burdened households using both methodologies')\n", + "_ = plt.ylabel('ECDF')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that the permutation samples ECDFs overlap and give a purple haze. None of the ECDFs from the permutation samples overlap with the observed data, suggesting that the hypothesis is not commensurate with the data. Both methodologies for housing burden are not identically distributed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## Nonparametric two-sample bootstrap test for sample mean\n", + "\n", + "We now want to test the hypothesis that both methodologies have the same average housing burden across all census tracts in West Virginia, but not necessarily the same distribution, which is also impossible with a permutation test.\n", + "\n", + "To do the two-sample bootstrap test, we shift both arrays to have the same mean, since we are simulating the hypothesis that their means are, in fact, equal. We then draw bootstrap samples out of the shifted arrays and compute the difference in means. This constitutes a bootstrap replicate, and we generate many of them. The p-value is the fraction of replicates with a difference in means greater than or equal to what was observed.\n", + "\n", + "**Conclusion**:\n", + "\n", + "We actually have evidence that the means are equal and corroborate a similar result as when we performed in the permutation test. Nonetheless, remember that it is important to carefully think about what question we want to ask. Are we only interested in the mean housing burden, or in the distribution of housing burdens across a state's census tract??" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "P Value: 0.0000\n" + ] + } + ], + "source": [ + "def bootstrap_replicate_1d(data, func):\n", + " \"\"\"Generate bootstrap replicate of one dimensional data.\"\"\"\n", + " bs_sample = np.random.choice(data, len(data))\n", + " return func(bs_sample)\n", + "\n", + "def draw_bs_reps(data, func, size=1):\n", + " \"\"\"Draw bootstrap replicates.\"\"\"\n", + " # Initialize array of replicates\n", + " bs_replicates = np.empty(size)\n", + " # Generate replicates\n", + " for i in range(size):\n", + " bs_replicates[i] = bootstrap_replicate_1d(data, func)\n", + " return bs_replicates\n", + "\n", + "def diff_of_means(data_1, data_2):\n", + " \"\"\"Difference in means of two arrays.\"\"\"\n", + "\n", + " # The difference of means of data_1, data_2: diff\n", + " diff = np.mean(data_1) - np.mean(data_2)\n", + "\n", + " return diff\n", + "\n", + "# Compute difference of mean burden from data\n", + "empirical_diff_means = diff_of_means(current_methodology, revised_methodology)\n", + "\n", + "# Compute mean of all burdens (population)\n", + "mean_burden = np.mean(np.append(current_methodology, revised_methodology))\n", + "\n", + "# Generate shifted arrays\n", + "burden_a_shifted = current_methodology - np.mean(current_methodology) + mean_burden\n", + "burden_b_shifted = revised_methodology - np.mean(revised_methodology) + mean_burden\n", + "\n", + "# Compute 10,000 bootstrap replicates from shifted arrays\n", + "bs_replicates_a = draw_bs_reps(burden_a_shifted, np.mean, size=10000)\n", + "bs_replicates_b = draw_bs_reps(burden_b_shifted, np.mean, size=10000)\n", + "\n", + "# Get replicates of difference of means\n", + "bs_replicates = bs_replicates_a - bs_replicates_b\n", + "\n", + "# Compute and print p-value\n", + "p = np.sum(bs_replicates >= empirical_diff_means) / len(bs_replicates)\n", + "print(\"P Value: {:.4f}\".format(round(p, 2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Percentiles Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "final_df = housingburden[['FIPS_tract_id', 'state','hbrd_rank','hbrd_score', 'summed', \n", + " 'current_summed_methodology', 'T8_est1',\n", + " 'current_methodology_denominator', 'current_methodology_percent']]" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False 67811\n", + "True 2\n", + "Name: current_methodology_percent, dtype: int64" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "common_percentile = 90\n", + "\n", + "(final_df['current_methodology_percent'] >= 90).value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/0m/ppxy6yr56jx1mk52p_9sf2sw0000gn/T/ipykernel_40643/3972884231.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " final_df[\"current_threshold_exceeded\"] = (final_df['current_methodology_percent'] >= 90)\n" + ] + } + ], + "source": [ + "final_df[\"current_threshold_exceeded\"] = (final_df['current_methodology_percent'] >= 90)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Only include non-NA tracts for comparison purposes" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "final_df = final_df[~final_df[\"hbrd_rank\"].isna()]" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "final_df[\"new_threshold_exceeded\"] = (final_df['hbrd_rank'] >= 90)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False 61012\n", + "True 6801\n", + "Name: new_threshold_exceeded, dtype: int64" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "final_df[\"new_threshold_exceeded\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "20543 100.0\n", + "71328 100.0\n", + "22446 100.0\n", + "39484 100.0\n", + "61182 100.0\n", + " ... \n", + "40143 0.0\n", + "66932 0.0\n", + "44151 0.0\n", + "46733 0.0\n", + "62933 0.0\n", + "Name: hbrd_rank, Length: 67813, dtype: float64" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "final_df[\"hbrd_rank\"].sort_values(ascending=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FIPS_tract_idstatehbrd_rankhbrd_scoresummedcurrent_summed_methodologyT8_est1current_methodology_denominatorcurrent_methodology_percentcurrent_threshold_exceedednew_threshold_exceeded
50010059507000192.0192310.23414614421861560736.0FalseTrue
66010119521000196.1538460.26976717422264564135.0FalseTrue
78010150002000191.3461540.2298392854751240122539.0FalseTrue
79010150003000191.0576920.2295082804881220117542.0FalseTrue
97010150021010199.5192310.363184365483100597050.0FalseTrue
\n", + "
" + ], + "text/plain": [ + " FIPS_tract_id state hbrd_rank hbrd_score summed \\\n", + "50 01005950700 01 92.019231 0.234146 144 \n", + "66 01011952100 01 96.153846 0.269767 174 \n", + "78 01015000200 01 91.346154 0.229839 285 \n", + "79 01015000300 01 91.057692 0.229508 280 \n", + "97 01015002101 01 99.519231 0.363184 365 \n", + "\n", + " current_summed_methodology T8_est1 current_methodology_denominator \\\n", + "50 218 615 607 \n", + "66 222 645 641 \n", + "78 475 1240 1225 \n", + "79 488 1220 1175 \n", + "97 483 1005 970 \n", + "\n", + " current_methodology_percent current_threshold_exceeded \\\n", + "50 36.0 False \n", + "66 35.0 False \n", + "78 39.0 False \n", + "79 42.0 False \n", + "97 50.0 False \n", + "\n", + " new_threshold_exceeded \n", + "50 True \n", + "66 True \n", + "78 True \n", + "79 True \n", + "97 True " + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "final_df.loc[final_df[\n", + " 'current_threshold_exceeded'] != final_df['new_threshold_exceeded']].head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}