diff --git a/data/data-pipeline/data_pipeline/ipython/hud_eda_se_12_26_2011_relative_differences_between_methodologies-ranking-percentile.ipynb b/data/data-pipeline/data_pipeline/ipython/hud_eda_se_12_26_2011_relative_differences_between_methodologies-ranking-percentile.ipynb new file mode 100644 index 00000000..41ec1ecb --- /dev/null +++ b/data/data-pipeline/data_pipeline/ipython/hud_eda_se_12_26_2011_relative_differences_between_methodologies-ranking-percentile.ipynb @@ -0,0 +1,2549 @@ +{ + "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": 2, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'requests' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mCURRENT_DIRECTORY\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetcwd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mdownload_hud_dataset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0mextract_zipped_download\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mCURRENT_DIRECTORY\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"/HUD_ZIPPED.csv\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCURRENT_DIRECTORY\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0mup_one_directory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mCURRENT_DIRECTORY\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"/140/Table8.csv\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mdownload_hud_dataset\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mDOWNLOAD_FILENAME\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"HUD_ZIPPED.csv\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mHOUSING_FTP_URL\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"https://www.huduser.gov/portal/datasets/cp/2014thru2018-140-csv.zip\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrequests\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mHOUSING_FTP_URL\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverify\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus_code\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m200\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mfile_contents\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'requests' is not defined" + ] + } + ], + "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": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sarahluw/.pyenv/versions/3.6.2/envs/my-virtual-env-3.6.2/lib/python3.6/site-packages/pandas/core/series.py:726: RuntimeWarning: invalid value encountered in sqrt\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n", + "/Users/sarahluw/.pyenv/versions/3.6.2/envs/my-virtual-env-3.6.2/lib/python3.6/site-packages/pandas/core/indexing.py:670: 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", + " iloc._setitem_with_indexer(indexer, value)\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": 4, + "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": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "housingburden.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(73056, 280)" + ] + }, + "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": "markdown", + "metadata": {}, + "source": [ + "### Now we compute for a baseline comparison " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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": 7, + "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": 8, + "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": 9, + "metadata": {}, + "outputs": [], + "source": [ + "housingburden[\"current_methodology_denominator_sans_not_computed\"] = (\n", + " housingburden[OWNER_OCCUPIED_POPULATION_FIELD]\n", + " + housingburden[RENTER_OCCUPIED_POPULATION_FIELD]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "housingburden[\"current_methodology_percent\"] = np.round(\n", + " (housingburden[\"current_summed_methodology\"] / housingburden[\"current_methodology_denominator\"] ), 2) * 100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now we construct the distribution of differences in the number of owned and rented burdened households\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Percentiles Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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_sans_not_computed\",\n", + " 'current_methodology_denominator', 'current_methodology_percent']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### First notice here that **T8_est1** and **current_methodology_denominator** should represent same or similar aggregates. In general, we cen see that the current computation performed results in a differerntial that undercounts the total occupied and rental households." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sarahluw/.pyenv/versions/3.6.2/envs/my-virtual-env-3.6.2/lib/python3.6/site-packages/ipykernel_launcher.py:2: 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", + " \n" + ] + } + ], + "source": [ + "final_df[\"differences_aggregate_denominator\"] = (\n", + " final_df[\"current_methodology_denominator\"] - final_df[\"T8_est1\"] \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sarahluw/.pyenv/versions/3.6.2/envs/my-virtual-env-3.6.2/lib/python3.6/site-packages/ipykernel_launcher.py:2: 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", + " \n" + ] + } + ], + "source": [ + "final_df[\"differences_aggregate_denominator_sans_not_computed\"] = (\n", + " final_df[\"current_methodology_denominator\"] - final_df[\"T8_est1\"] \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "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('Distribution of differences between aggregate totals that normalizes tabulation of poverty households')\n", + "# Set x-axis label\n", + "plt.xlabel('Aggregate differences in 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(final_df[\"differences_aggregate_denominator\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "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('Distribution of differences between aggregate totals that normalizes tabulation of poverty households (with removal of not computed fields) ')\n", + "# Set x-axis label\n", + "plt.xlabel('Aggregate differences in total owner and renter occupied low-income households')\n", + "# Set y-axis label\n", + "plt.ylabel('Relative Frequency in Support')\n", + "\n", + "sns.histplot(final_df[\"differences_aggregate_denominator_sans_not_computed\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sarahluw/.pyenv/versions/3.6.2/envs/my-virtual-env-3.6.2/lib/python3.6/site-packages/ipykernel_launcher.py:4: 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", + " after removing the cwd from sys.path.\n" + ] + } + ], + "source": [ + "final_df[\"current_methodology_percentile_rank\"] = final_df[\"current_methodology_percent\"].rank(\n", + " pct=True,\n", + " # Set ascending to the parameter value.\n", + " ascending=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Only include non-NA tracts for comparison purposes" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# first save NA tracts that were considered unreliable\n", + "ineligible_tracts = list(final_df[final_df[\"hbrd_rank\"].isna()][\"FIPS_tract_id\"].values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### How many tracts are ineligible according to CalEnvironScreen but are considerd in Score L?\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "final_current_methodology = final_df[final_df[\"current_methodology_percentile_rank\"] >= 0.90]" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(7323, 13)" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "final_current_methodology.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(53, 13)" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 53 tracts\n", + "final_current_methodology[final_current_methodology.FIPS_tract_id.isin(ineligible_tracts)].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "non_null_df = final_df[~final_df[\"hbrd_rank\"].isna()]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(7270, 13)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# number of tracks eligible\n", + "non_null_df[non_null_df[\"current_methodology_percentile_rank\"] >= 0.90].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "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(\"Distribution of Percentiles (Score L)\")\n", + "# Set x-axis label\n", + "plt.xlabel('Percentile (although currently not represented as a percentage)')\n", + "# Set y-axis label\n", + "plt.ylabel('Relative Frequency in Support')\n", + "\n", + "sns.histplot(non_null_df[\"current_methodology_percentile_rank\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sarahluw/.pyenv/versions/3.6.2/envs/my-virtual-env-3.6.2/lib/python3.6/site-packages/ipykernel_launcher.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", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + } + ], + "source": [ + "non_null_df[\"new_threshold_exceeded\"] = (final_df['hbrd_rank'] >= 90)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sarahluw/.pyenv/versions/3.6.2/envs/my-virtual-env-3.6.2/lib/python3.6/site-packages/ipykernel_launcher.py:2: 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", + " \n" + ] + } + ], + "source": [ + "non_null_df[\"current_threshold_exceeded\"] = (non_null_df[\n", + " 'current_methodology_percentile_rank'] >= 0.90)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False 60543\n", + "True 7270\n", + "Name: current_threshold_exceeded, dtype: int64" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "non_null_df[\"current_threshold_exceeded\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False 61012\n", + "True 6801\n", + "Name: new_threshold_exceeded, dtype: int64" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "non_null_df[\"new_threshold_exceeded\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "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", + "
FIPS_tract_idstatehbrd_rankhbrd_scoresummedcurrent_summed_methodologyT8_est1current_methodology_denominator_sans_not_computedcurrent_methodology_denominatorcurrent_methodology_percentdifferences_aggregate_denominatordifferences_aggregate_denominator_sans_not_computedcurrent_methodology_percentile_ranknew_threshold_exceededcurrent_threshold_exceeded
0010010201000146.2980770.1045758017476576576523.0000.512833FalseFalse
1010010202000183.2692310.19166713817772072072025.0000.575315FalseFalse
2010010203000163.6538460.13127417027912951295129122.0-4-40.479242FalseFalse
3010010204000134.6153850.08841514527416401635163517.0-5-50.289696FalseFalse
4010010205000168.2211540.14251559588541754175413521.0-40-400.444306FalseFalse
\n", + "
" + ], + "text/plain": [ + " FIPS_tract_id state hbrd_rank hbrd_score summed \\\n", + "0 01001020100 01 46.298077 0.104575 80 \n", + "1 01001020200 01 83.269231 0.191667 138 \n", + "2 01001020300 01 63.653846 0.131274 170 \n", + "3 01001020400 01 34.615385 0.088415 145 \n", + "4 01001020500 01 68.221154 0.142515 595 \n", + "\n", + " current_summed_methodology T8_est1 \\\n", + "0 174 765 \n", + "1 177 720 \n", + "2 279 1295 \n", + "3 274 1640 \n", + "4 885 4175 \n", + "\n", + " current_methodology_denominator_sans_not_computed \\\n", + "0 765 \n", + "1 720 \n", + "2 1295 \n", + "3 1635 \n", + "4 4175 \n", + "\n", + " current_methodology_denominator current_methodology_percent \\\n", + "0 765 23.0 \n", + "1 720 25.0 \n", + "2 1291 22.0 \n", + "3 1635 17.0 \n", + "4 4135 21.0 \n", + "\n", + " differences_aggregate_denominator \\\n", + "0 0 \n", + "1 0 \n", + "2 -4 \n", + "3 -5 \n", + "4 -40 \n", + "\n", + " differences_aggregate_denominator_sans_not_computed \\\n", + "0 0 \n", + "1 0 \n", + "2 -4 \n", + "3 -5 \n", + "4 -40 \n", + "\n", + " current_methodology_percentile_rank new_threshold_exceeded \\\n", + "0 0.512833 False \n", + "1 0.575315 False \n", + "2 0.479242 False \n", + "3 0.289696 False \n", + "4 0.444306 False \n", + "\n", + " current_threshold_exceeded \n", + "0 False \n", + "1 False \n", + "2 False \n", + "3 False \n", + "4 False " + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "non_null_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "net_difference = non_null_df[(non_null_df[\n", + " \"current_threshold_exceeded\"] != non_null_df[\"new_threshold_exceeded\"])]" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "# Inserted after the basic stats definition.\n", + "# Load demographic data\n", + "import pathlib\n", + "\n", + "DATA_DIR = pathlib.Path.cwd().parent / \"data\"\n", + "COMPARISON_OUTPUTS_DIR = DATA_DIR / \"comparison_outputs\"\n", + "\n", + "demographics_path = DATA_DIR / \"dataset\" / \"census_acs_2019\" / \"usa.csv\"\n", + "\n", + "demographics_df = pd.read_csv(\n", + " demographics_path,\n", + " dtype={\"GEOID10_TRACT\": \"string\"},\n", + ")\n", + "\n", + "# Set some field names\n", + "BLACK_FIELD_NAME = \"Black or African American alone\"\n", + "AMERICAN_INDIAN_FIELD_NAME = \"American Indian and Alaska Native alone\"\n", + "ASIAN_FIELD_NAME = \"Asian alone\"\n", + "HAWAIIAN_FIELD_NAME = \"Native Hawaiian and Other Pacific alone\"\n", + "TWO_OR_MORE_RACES_FIELD_NAME = \"Two or more races\"\n", + "NON_HISPANIC_WHITE_FIELD_NAME = \"Non-Hispanic White\"\n", + "HISPANIC_FIELD_NAME = \"Hispanic or Latino\"\n", + "PERCENT_PREFIX = \"Percent \"\n", + "\n", + "RE_OUTPUT_FIELDS = [\n", + " BLACK_FIELD_NAME,\n", + " AMERICAN_INDIAN_FIELD_NAME,\n", + " ASIAN_FIELD_NAME,\n", + " HAWAIIAN_FIELD_NAME,\n", + " TWO_OR_MORE_RACES_FIELD_NAME,\n", + " NON_HISPANIC_WHITE_FIELD_NAME,\n", + " HISPANIC_FIELD_NAME,\n", + "]\n", + "\n", + "RE_PERCENT_OUTPUT_FIELDS = [PERCENT_PREFIX + field for field in RE_OUTPUT_FIELDS]\n", + "\n", + "columns_to_keep = (\n", + " [\"GEOID10_TRACT\"]\n", + " + RE_OUTPUT_FIELDS\n", + " + RE_PERCENT_OUTPUT_FIELDS\n", + " + ['Percent of individuals < 200% Federal Poverty Line', \n", + " 'Median value ($) of owner-occupied housing units',\n", + " 'Percent individuals age 25 or over with less than high school degree',\n", + " 'Percent enrollment in college or graduate school',\n", + " 'Linguistic isolation (percent)']\n", + ")\n", + "\n", + "# Join the demographics in.\n", + "merged_df = net_difference.merge(\n", + " demographics_df[columns_to_keep],\n", + " left_on=\"FIPS_tract_id\",\n", + " right_on=\"GEOID10_TRACT\",\n", + " how=\"inner\"\n", + ")\n", + "\n", + "\n", + "# Group bys.\n", + "demographics_directory = COMPARISON_OUTPUTS_DIR / \"demographics_basic_stats\"\n", + "demographics_directory.mkdir(parents=True, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "# these are not converted into percent 0 - 100 scale\n", + "percent_cols = [x for x in merged_df.columns if \n", + " 'Percent' in x or '(percent)' in x\n", + " ]\n", + "\n", + "merged_df[\n", + " percent_cols] = merged_df[\n", + " percent_cols].apply(lambda x: x * 100)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "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", + "
FIPS_tract_idstatehbrd_rankhbrd_scoresummedcurrent_summed_methodologyT8_est1current_methodology_denominator_sans_not_computedcurrent_methodology_denominatorcurrent_methodology_percent...Percent Asian alonePercent Native Hawaiian and Other Pacific alonePercent Two or more racesPercent Non-Hispanic WhitePercent Hispanic or LatinoPercent of individuals < 200% Federal Poverty LineMedian value ($) of owner-occupied housing unitsPercent individuals age 25 or over with less than high school degreePercent enrollment in college or graduate schoolLinguistic isolation (percent)
0010059507000192.0192310.23414614421861561560736.0...0.0000000.03.28731143.1952660.00000057.11094613750031.6770191.6191210.000000
1010119521000196.1538460.26976717422264564564135.0...0.0000000.00.0000003.1032300.00000059.5946806690024.9512675.6472633.145695
2010150002000191.3461540.22983928547512401245122539.0...1.0327020.00.38726341.1790026.19621349.9139417700013.2335334.2894061.862828
3010150003000191.0576920.22950828048812201215117542.0...0.0000000.00.00000017.5010521.76693365.6289445130029.1840386.3500260.000000
4010550010000198.4615380.30804613417743544043041.0...0.0000000.01.26671426.60098515.48205568.4882906540023.3372232.4108001.489362
\n", + "

5 rows × 35 columns

\n", + "
" + ], + "text/plain": [ + " FIPS_tract_id state hbrd_rank hbrd_score summed \\\n", + "0 01005950700 01 92.019231 0.234146 144 \n", + "1 01011952100 01 96.153846 0.269767 174 \n", + "2 01015000200 01 91.346154 0.229839 285 \n", + "3 01015000300 01 91.057692 0.229508 280 \n", + "4 01055001000 01 98.461538 0.308046 134 \n", + "\n", + " current_summed_methodology T8_est1 \\\n", + "0 218 615 \n", + "1 222 645 \n", + "2 475 1240 \n", + "3 488 1220 \n", + "4 177 435 \n", + "\n", + " current_methodology_denominator_sans_not_computed \\\n", + "0 615 \n", + "1 645 \n", + "2 1245 \n", + "3 1215 \n", + "4 440 \n", + "\n", + " current_methodology_denominator current_methodology_percent ... \\\n", + "0 607 36.0 ... \n", + "1 641 35.0 ... \n", + "2 1225 39.0 ... \n", + "3 1175 42.0 ... \n", + "4 430 41.0 ... \n", + "\n", + " Percent Asian alone Percent Native Hawaiian and Other Pacific alone \\\n", + "0 0.000000 0.0 \n", + "1 0.000000 0.0 \n", + "2 1.032702 0.0 \n", + "3 0.000000 0.0 \n", + "4 0.000000 0.0 \n", + "\n", + " Percent Two or more races Percent Non-Hispanic White \\\n", + "0 3.287311 43.195266 \n", + "1 0.000000 3.103230 \n", + "2 0.387263 41.179002 \n", + "3 0.000000 17.501052 \n", + "4 1.266714 26.600985 \n", + "\n", + " Percent Hispanic or Latino \\\n", + "0 0.000000 \n", + "1 0.000000 \n", + "2 6.196213 \n", + "3 1.766933 \n", + "4 15.482055 \n", + "\n", + " Percent of individuals < 200% Federal Poverty Line \\\n", + "0 57.110946 \n", + "1 59.594680 \n", + "2 49.913941 \n", + "3 65.628944 \n", + "4 68.488290 \n", + "\n", + " Median value ($) of owner-occupied housing units \\\n", + "0 137500 \n", + "1 66900 \n", + "2 77000 \n", + "3 51300 \n", + "4 65400 \n", + "\n", + " Percent individuals age 25 or over with less than high school degree \\\n", + "0 31.677019 \n", + "1 24.951267 \n", + "2 13.233533 \n", + "3 29.184038 \n", + "4 23.337223 \n", + "\n", + " Percent enrollment in college or graduate school \\\n", + "0 1.619121 \n", + "1 5.647263 \n", + "2 4.289406 \n", + "3 6.350026 \n", + "4 2.410800 \n", + "\n", + " Linguistic isolation (percent) \n", + "0 0.000000 \n", + "1 3.145695 \n", + "2 1.862828 \n", + "3 0.000000 \n", + "4 1.489362 \n", + "\n", + "[5 rows x 35 columns]" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "merged_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "import us\n", + "\n", + "mapping = us.states.mapping('fips', 'abbr')\n", + "\n", + "for idx, row in merged_df.iterrows():\n", + " current_row = str(merged_df.loc[idx, 'state'])\n", + " state = mapping.get(current_row, None)\n", + " merged_df.loc[idx, 'state_name'] = state" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5013, 36)" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "merged_df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compute the correlation matrix\n", + "import seaborn as sns\n", + "corr = merged_df[[\"hbrd_rank\", \n", + " \"current_methodology_percentile_rank\"] + percent_cols].corr()\n", + "\n", + "# Generate a mask for the upper triangle\n", + "mask = np.triu(np.ones_like(corr, dtype=bool))\n", + "\n", + "# Set up the matplotlib figure\n", + "f, ax = plt.subplots(figsize=(15, 12))\n", + "\n", + "# Generate a custom diverging colormap\n", + "cmap = sns.diverging_palette(230, 20, as_cmap=True)\n", + "\n", + "# Draw the heatmap with the mask and correct aspect ratio\n", + "sns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,\n", + " square=True, linewidths=.5, cbar_kws={\"shrink\": .5})" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "grouped_stats = merged_df.groupby([\"state_name\"]).agg({\n", + " 'GEOID10_TRACT': 'nunique',\n", + " 'Percent of individuals < 200% Federal Poverty Line': [np.median, np.std],\n", + " 'Median value ($) of owner-occupied housing units': [np.median, np.std],\n", + " 'Percent individuals age 25 or over with less than high school degree': [np.median, np.std],\n", + " 'Percent enrollment in college or graduate school': [np.median, np.std],\n", + " 'Percent Black or African American alone': [np.median, np.std],\n", + " 'Percent American Indian and Alaska Native alone': [np.median, np.std],\n", + " 'Percent Non-Hispanic White': [np.median, np.std], \n", + " 'Linguistic isolation (percent)': [np.median, np.std],\n", + " 'Percent Hispanic or Latino': [np.median, np.std],\n", + " 'hbrd_rank': [np.median, np.std],\n", + " 'current_methodology_percent': [np.median, np.std],\n", + " 'current_summed_methodology': [np.median, np.std, np.sum]\n", + "}).reset_index()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "grouped_stats.columns = [' '.join(col).strip() for col in grouped_stats.columns.values]" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['state_name', 'GEOID10_TRACT nunique',\n", + " 'Percent of individuals < 200% Federal Poverty Line median',\n", + " 'Percent of individuals < 200% Federal Poverty Line std',\n", + " 'Median value ($) of owner-occupied housing units median',\n", + " 'Median value ($) of owner-occupied housing units std',\n", + " 'Percent individuals age 25 or over with less than high school degree median',\n", + " 'Percent individuals age 25 or over with less than high school degree std',\n", + " 'Percent enrollment in college or graduate school median',\n", + " 'Percent enrollment in college or graduate school std',\n", + " 'Percent Black or African American alone median',\n", + " 'Percent Black or African American alone std',\n", + " 'Percent American Indian and Alaska Native alone median',\n", + " 'Percent American Indian and Alaska Native alone std',\n", + " 'Percent Non-Hispanic White median', 'Percent Non-Hispanic White std',\n", + " 'Linguistic isolation (percent) median',\n", + " 'Linguistic isolation (percent) std',\n", + " 'Percent Hispanic or Latino median', 'Percent Hispanic or Latino std',\n", + " 'hbrd_rank median', 'hbrd_rank std',\n", + " 'current_methodology_percent median', 'current_methodology_percent std',\n", + " 'current_summed_methodology median', 'current_summed_methodology std',\n", + " 'current_summed_methodology sum'],\n", + " dtype='object')" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_stats.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "grouped_stats_states = grouped_stats[[x for x in grouped_stats \n", + " if \"median\" in x and \n", + " \"Percent\" in x] + [\"GEOID10_TRACT nunique\", \"state_name\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "grouped_stats_states.set_index(\"state_name\", inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "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", + " \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", + " \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", + " \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", + "
Percent of individuals < 200% Federal Poverty Line median Percent individuals age 25 or over with less than high school degree median Percent enrollment in college or graduate school median Percent Black or African American alone median Percent American Indian and Alaska Native alone median Percent Non-Hispanic White median Percent Hispanic or Latino median GEOID10_TRACT nunique
state_name
AK33.07046910.5860986.5016045.09620012.63370352.24087210.26414212
AL59.38757516.9137957.56397874.4757010.00000016.8269372.38608256
AR60.04119517.9231865.21064355.7103060.00000034.8001015.39374343
AZ57.70065126.5266437.0756255.6077602.75893326.17866056.66125899
CA51.26895231.9902329.1743124.0784490.4722289.84325065.462248897
CO46.30058814.2493257.9066043.8809621.09258646.52824034.48032772
CT50.17689818.9679858.59463123.3867030.00000027.06270836.69563058
DC50.41085415.4830456.94641390.3525770.0000003.9939143.97022317
DE42.44744711.2353687.16747548.9519210.47055836.9102358.75762914
FL51.10930217.0430947.58889422.7603000.00000022.10462426.459155234
GA58.09138817.4952208.78173866.0021550.00000016.7491174.751314121
HI34.6405239.9914248.0929962.0005260.00000011.6621984.94736817
IA45.76192710.9478677.41301111.2195120.02554969.9254357.93507755
ID52.5401366.0718259.1437310.5292651.06339583.4355838.60478525
IL55.34478318.7627467.25308638.0509940.0000009.25583112.976765203
IN58.68210818.0456815.95164435.0849010.00000039.4594119.06376482
KS56.97732518.2332798.18659411.9044760.45919356.78561816.89101050
KY56.32823418.1950865.83430618.9645030.00000063.1455404.23620071
LA61.15131620.0523317.09914376.7875130.00000017.4779322.48051059
MA47.83000120.9422967.76858611.8248780.00000034.79487327.95240884
MD39.75211215.3517317.62244149.9278960.00000022.1150727.09447088
ME42.4021237.4773148.4269661.3470680.36040490.6806281.30890127
MI60.18348616.2672816.96378869.9781660.00000017.6454671.912181145
MN42.50854112.09616810.21069716.9693820.54782058.1542808.03099791
MO55.19430615.2006196.15305936.8479800.00000035.8847104.61922152
MS58.97967617.0385406.71198072.4340180.00000025.2270430.70575543
MT45.0789855.35533213.3026610.1291611.84455488.8817273.65063820
NC56.81125419.2268577.08257542.4155180.25968433.41225210.714959109
ND43.2432436.99017916.4667397.1492562.12194877.9402937.50226713
NE55.4258249.50728713.6915898.2790700.53516864.62978310.86384829
NH39.67807813.1355246.5123402.7739100.00000086.0097285.64457124
NJ46.34573320.8433017.07307525.0784090.00000012.42603643.496410165
NM53.60195416.7253529.3477502.7661803.11614729.44009657.23481727
NV56.08303622.5641365.47547911.8682720.55708528.14339243.94739948
NY47.53685724.0067428.26279025.8594920.00000011.30094728.649040603
OH64.85730319.1609985.71620761.0523220.00000027.2796353.455150157
OK57.61886716.7902917.02701213.9696743.42083848.52185013.89988570
OR45.05710911.4072497.8693561.7578830.74264567.68737214.95778051
PA54.89406815.2657607.53012031.8856820.00000027.3596186.151832165
RI55.85143720.0353277.63214712.3701610.40053429.26877933.46851719
SC53.74211015.1065456.65387146.2740380.00000039.1304354.81528767
SD47.8048787.6506438.2104653.6046323.99484575.2877454.77278519
TN55.41666718.7124467.28065853.9672130.00000035.9933964.44444473
TX56.93950225.4102206.78726514.3435370.00000014.62720549.238149309
UT45.8097409.5987419.4932431.4449290.38485264.48710320.42816633
VA44.75079214.1815067.65054136.8306090.00000032.1986966.607595102
VT43.1128236.8371867.7231700.9235940.05055693.7005651.60550515
WA39.37531712.5430817.4483175.8803020.90327159.32113613.893070102
WI57.28758215.1812696.31025423.5638920.34694422.6303328.54177843
WV52.37579511.7412986.8748136.8052340.00000082.4479241.63657126
WY33.4140924.8757176.5539660.5780351.17455181.37824211.8082799
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def highlight_medians(s):\n", + " # highliht if the current median is greater than the median of medians for that series\n", + " \n", + " is_greater_than_median = s > s.median()\n", + " return ['color: pink; background-color:darkblue' \n", + " if cell else '' for cell in is_greater_than_median]\n", + "grouped_stats_states.style.apply(highlight_medians)" + ] + } + ], + "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.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}