Fitting a binned MLE with selection bias.

binned_mle_ex.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Review these guys first:\n",
    "\n",
    "* https://rlhick.people.wm.edu/posts/estimating-custom-mle.html\n",
    "* https://python.quantecon.org/mle.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import statsmodels.api as sm\n",
    "\n",
    "from scipy.stats import norm, poisson, pearsonr\n",
    "from scipy.optimize import minimize, Bounds\n",
    "\n",
    "import numdifftools as ndt\n",
    "\n",
    "from pprint import pprint\n",
    "\n",
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First, a simple OLS example (directly from the first link)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10000\n",
    "x = 10 * np.random.randn(N)\n",
    "y = 5 + x + np.random.randn(N)\n",
    "df = pd.DataFrame({'y':y, 'x':x})\n",
    "df['constant'] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>parameters</th>\n",
       "      <th>std err</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>constant</th>\n",
       "      <td>5.001181</td>\n",
       "      <td>0.009904</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>x</th>\n",
       "      <td>1.000765</td>\n",
       "      <td>0.000992</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          parameters   std err\n",
       "constant    5.001181  0.009904\n",
       "x           1.000765  0.000992"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "smf = sm.OLS(df.y, df[['constant','x']]).fit()\n",
    "\n",
    "pd.DataFrame({'parameters': smf.params,'std err': smf.bse})\n",
    "# smf.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 14091.071451\n",
      "         Iterations: 99\n",
      "         Function evaluations: 172\n"
     ]
    }
   ],
   "source": [
    "def neg_loglike(theta):\n",
    "    mu = theta[0] + theta[1]*x\n",
    "    return -1*norm(mu, theta[2]).logpdf(y).sum()\n",
    "\n",
    "theta_start = np.array([1,1,1])\n",
    "res = minimize(neg_loglike, theta_start, method = 'Nelder-Mead', \n",
    "               options={'disp': True})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cf here for reminder on the Hessian: http://www.sherrytowers.com/mle_introduction.pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jsaxon/.anaconda/lib/python3.8/site-packages/numdifftools/extrapolation.py:489: RuntimeWarning: invalid value encountered in less_equal\n",
      "  converged = err <= tol\n",
      "/home/jsaxon/.anaconda/lib/python3.8/site-packages/numdifftools/limits.py:173: RuntimeWarning: invalid value encountered in less\n",
      "  outliers = (((abs(der) < (a_median / trim_fact)) +\n",
      "/home/jsaxon/.anaconda/lib/python3.8/site-packages/numdifftools/limits.py:174: RuntimeWarning: invalid value encountered in greater\n",
      "  (abs(der) > (a_median * trim_fact))) * (a_median > 1e-8) +\n",
      "/home/jsaxon/.anaconda/lib/python3.8/site-packages/numdifftools/limits.py:175: RuntimeWarning: invalid value encountered in less\n",
      "  ((der < p25 - 1.5 * iqr) + (p75 + 1.5 * iqr < der)))\n"
     ]
    }
   ],
   "source": [
    "Hfun = ndt.Hessian(neg_loglike, full_output=True)\n",
    "hessian_ndt, info = Hfun(res['x'])\n",
    "se = np.sqrt(np.diag(np.linalg.inv(hessian_ndt)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assemble the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>parameters</th>\n",
       "      <th>std err</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Intercept</th>\n",
       "      <td>5.001186</td>\n",
       "      <td>0.009903</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Slope</th>\n",
       "      <td>1.000764</td>\n",
       "      <td>0.000992</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sigma</th>\n",
       "      <td>0.990177</td>\n",
       "      <td>0.007001</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           parameters   std err\n",
       "Intercept    5.001186  0.009903\n",
       "Slope        1.000764  0.000992\n",
       "Sigma        0.990177  0.007001"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = pd.DataFrame({'parameters':res['x'],'std err':se})\n",
    "results.index=['Intercept','Slope','Sigma']   \n",
    "results.head() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### And now oriented to the specific problem where we specify probabilities.\n",
    "\n",
    "The goal is to fit a probability density that simultaneously captures the likelihood of observation _and_ the outcome of the observations.  So ultimately, we'll write functions that set the probabilities of each observation by tract and speedtest outcome.\n",
    "\n",
    "For exposition, I'll just write explicit levels of each bin.  The bins would correspond to speed thresholds among tracts...\n",
    "\n",
    "I am writing these using the survival function $S$ on the _internal_ bin boundaries (i.e., not 1 and 0).  These 4 values imply 5 bins, with 4 degrees of freedom.\n",
    "\n",
    "From $S$ we get the CDF, $C = 1 - S$, and the PDF of ($dC/ds$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "smarks = np.array([0.9, 0.8, 0.5, 0.25])\n",
    "cbins  = np.concatenate([[0], 1 - smarks, [1]])\n",
    "pbins  = cbins[1:] - cbins[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate some data and bin them.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = int(1e6)\n",
    "draw_vals = np.random.uniform(size = N)\n",
    "draw_bins = (cbins < draw_vals[:,np.newaxis]).argmin(axis = 1) - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check that for large $N$, the populations should match the survival function as written above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.9 , 0.8 , 0.5 , 0.25, 0.  ])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique, counts = np.unique(draw_bins, return_counts=True)\n",
    "\n",
    "1 - (counts / counts.sum()).cumsum().round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now write the negative log-likelihood as a function of the four cut-offs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-10-44abcd0ed665>:6: RuntimeWarning: invalid value encountered in log\n",
      "  return -np.log(llh_probs[draw_bins]).sum()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 1515007.878946\n",
      "         Iterations: 122\n",
      "         Function evaluations: 215\n"
     ]
    }
   ],
   "source": [
    "def neg_loglike(prob_cuts):\n",
    "    \n",
    "    llh_cbins = np.concatenate([[0], 1 - prob_cuts, [1]])\n",
    "    llh_probs = llh_cbins[1:] - llh_cbins[:-1]\n",
    "\n",
    "    return -np.log(llh_probs[draw_bins]).sum()\n",
    "    \n",
    "fit_relprobs = np.array([0.9, 0.8, 0.7, 0.6])\n",
    "res = minimize(neg_loglike, fit_relprobs, method = 'Nelder-Mead', options={'disp': True})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the SE from the Hessian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-10-44abcd0ed665>:6: RuntimeWarning: invalid value encountered in log\n",
      "  return -np.log(llh_probs[draw_bins]).sum()\n",
      "/home/jsaxon/.anaconda/lib/python3.8/site-packages/numdifftools/extrapolation.py:489: RuntimeWarning: invalid value encountered in less_equal\n",
      "  converged = err <= tol\n",
      "/home/jsaxon/.anaconda/lib/python3.8/site-packages/numdifftools/limits.py:173: RuntimeWarning: invalid value encountered in less\n",
      "  outliers = (((abs(der) < (a_median / trim_fact)) +\n",
      "/home/jsaxon/.anaconda/lib/python3.8/site-packages/numdifftools/limits.py:174: RuntimeWarning: invalid value encountered in greater\n",
      "  (abs(der) > (a_median * trim_fact))) * (a_median > 1e-8) +\n",
      "/home/jsaxon/.anaconda/lib/python3.8/site-packages/numdifftools/limits.py:175: RuntimeWarning: invalid value encountered in less\n",
      "  ((der < p25 - 1.5 * iqr) + (p75 + 1.5 * iqr < der)))\n"
     ]
    }
   ],
   "source": [
    "H = ndt.Hessian(neg_loglike, full_output=True)\n",
    "se = np.sqrt(np.diag(np.linalg.inv(H(res['x'])[0])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pars</th>\n",
       "      <th>se</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.899848</td>\n",
       "      <td>0.000300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.799789</td>\n",
       "      <td>0.000400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.499561</td>\n",
       "      <td>0.000500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.249165</td>\n",
       "      <td>0.000433</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       pars        se\n",
       "0  0.899848  0.000300\n",
       "1  0.799789  0.000400\n",
       "2  0.499561  0.000500\n",
       "3  0.249165  0.000433"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame({'pars':res['x'], 'se' : se})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Turning to joint observations and outcomes -- Heckman\n",
    "\n",
    "Next, let's review the Heckman sample selection model.\n",
    "\n",
    "We have an an outcome $s$ that is observable if $d_i = 1$.\n",
    "\n",
    "Write the outcome (speed, in our case) as \n",
    "\n",
    "$s^* \\sim b x + \\Sigma + \\varepsilon^s $.\n",
    "\n",
    "Of course, the $x$'s could be a vector, but let's keep it this way for now.\n",
    "\n",
    "And observation / missingness / censoring determined by the latent variable\n",
    "\n",
    "$d^* \\sim \\beta \\chi + \\varepsilon^d - \\Delta$\n",
    "\n",
    "This is dichotomized via\n",
    "\n",
    "$d_i = \\mathbb{1} (\\beta \\chi_i + \\varepsilon^d_i > \\Delta) = \\mathbb{1} (\\varepsilon^d_i > \\Delta - \\beta \\chi_i )$\n",
    "\n",
    "Others write this in vector notation as $\\vec\\beta \\cdot \\vec\\chi_i > -\\varepsilon^d_i$.  That's cleaner when we have lots of variables, but I find it more-intuitive when the threshold $\\Delta$ is explicit.  If you leave the intercept in a vector with a constant term as on the right, then you're grouping deterministic utility with respect to an idiosyncratic cut-off, rather than having idiosyncratic tastes with respect to a fixed cutoff.  Rephrased, I prefer the left expressions, grouping the \"individual level\" pieces, both observed an unobserved, together.  Mathematically, it's all the same, of course.\n",
    "\n",
    "Also note that $\\varepsilon_d$ is drawn from the standard normal, $N(0, 1)$; otherwise, you wouldn't be identified.  You could scale both $b$ and $\\sigma_{\\epsilon_d}$ and get the same answer.\n",
    "\n",
    "The probability of observation is thus:\n",
    "\n",
    "$p(d_i = 1) = p(\\beta \\chi_i + \\epsilon^d_i > \\Delta) = \\Phi(\\beta \\chi_i - \\Delta)$\n",
    "\n",
    "The key point is that if $\\rho_{ds} \\equiv \\rho(\\varepsilon^d, \\varepsilon^s) \\neq 0$, then the unconditional expecation $E(s_i) = b E(x_i) + \\Sigma $ is not equal to the expectation of the speed conditional on observation $E(s_i|d_i = 1)$.  The latter is:\n",
    "\n",
    "$E(s_i| d_i = 1) \\\\ \n",
    "= E(b x_i + \\Sigma + \\varepsilon^s_i | d_i = 1) \\\\\n",
    "= b E(x_i | d_i = 1) + \\Sigma + E(\\varepsilon^s_i | d_i = 1) \\\\\n",
    "= b E(x_i | \\beta \\chi_i + \\varepsilon^d_i > \\Delta) + \\Sigma + E(\\varepsilon^s_i | \\beta \\chi_i + \\varepsilon^d_i > \\Delta)$\n",
    "\n",
    "Heckman showed that the last term can be rewritten with the [inverse Mills ratio](https://en.wikipedia.org/wiki/Mills_ratio#Inverse_Mills_ratio); we get \n",
    "\n",
    "$E(s_i| d_i = 1) = b E(x_i | \\beta \\chi_i + \\varepsilon^d_i > \\Delta) + \\Sigma + \\rho_{ds} \\sigma^{\\varepsilon^s} \\frac{\\phi(\\beta \\chi_i - \\Delta)}{\\Phi(\\beta \\chi_i - \\Delta)}$\n",
    "\n",
    "[Hick](https://rlhick.people.wm.edu/stories/econ_407_notes_heckman.html) treats the first term as equal to its unconditional expectation.  That's not immediately obvious to me.  For example, if $x$ is _wages_, the expectation of $x_i$ _increases_, if we condition on observation into the sample.  I guess it's true if the observables $\\vec x$ include (or equal) $\\vec \\chi$ (?).  Or is it just that the $x_i$ are actually _known_: conditioning doesn't change the fact of the _known values_?  Anyway, if we took his word, it would be\n",
    "\n",
    "$E(s_i| d_i = 1) = bx_i + \\Sigma + \\rho_{ds} \\sigma^{\\varepsilon^s} \\frac{\\phi(\\beta \\chi_i - \\Delta)}{\\Phi(\\beta \\chi_i - \\Delta)}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Our case, a step at a time\n",
    "\n",
    "**Goal**: we want to be able to make statements of the form, \"the Gini coefficient of Internet speeds is G,\" or \"P% of people with incomes greater than \\$I have internet bandwidth exceeding B Mbps.\"\n",
    "\n",
    "#### Dichotomizing or binning...\n",
    "\n",
    "Let's keep turning towards our situation, treating it as three possible outcomes, as a function of a single $x$: unobserved, low, and high.  For simplicity, I am dichotomizing the outcome $s_i$.\n",
    "\n",
    "We are pretending that we see \"who\" is unobserved.  That is true in unobserved wage models a la Heckman, but it won't ultimately be true in the present case (we only observe $n_t$ in a Census tract).\n",
    "\n",
    "We have \n",
    "\n",
    "$d_i \\sim \\mathbb{1} (a x_i + \\varepsilon^d_i > \\Delta)$\n",
    "\n",
    "$s_i \\sim \\mathbb{1} (b x_i + \\varepsilon^s_i > \\Sigma)$\n",
    "\n",
    "where $\\varepsilon_{i} \\sim N(0, \\sigma_{i}$).  Per above, $\\sigma_{i}^d = 1$.  Again, note that $\\rho_{ds} \\equiv \\rho(\\varepsilon_{id}, \\varepsilon_{is}) = \\textrm{cov}(\\varepsilon_{id},\\varepsilon_{id})/(\\sigma_d \\sigma_s)$ is in general nonzero.\n",
    "\n",
    "The probability of being unobserved is \n",
    "\n",
    "$p_\\textrm{unobs.} = p(d_i = 0) = p(a x_i + \\varepsilon^d_i < \\Delta)$\n",
    "\n",
    "$p_\\textrm{low}    = p(b x_i + \\varepsilon_{is} < \\Sigma | a x_i + \\varepsilon^d_i > \\Delta)$\n",
    "\n",
    "$p_\\textrm{high}   = p(b x_i + \\varepsilon_{is} > \\Sigma | a x_i + \\varepsilon^d_i > \\Delta)$\n",
    "\n",
    "Since $\\rho_{ds} \\neq 0$, the lower two are not just the products $p(w_i)p(d_i = 1)$!\n",
    "\n",
    "The challenge here is that while $a x_i \\propto x_i$ and $\\Delta = \\textrm{const.}$ do not affect the expectation, $\\rho_{ds} \\neq 0$, and the conditional expectation _will_ in general depend on $\\varepsilon^d_i$ (in some weird, dichotomized way).\n",
    "\n",
    "#### The Ookla Dataset\n",
    "\n",
    "The Ookla data are fundamentally unlike what's used for the \"classical\" Heckman selection problem.\n",
    "\n",
    "* Unlike the Heckman problem, it is not missing observables for known observations (e.g., wage is NA but the education level is observed).  Instead, if people do not \"select in\" and run the test, they do not enter the sample.  Unobserved means not at all.\n",
    "* The data consist of tests, some of which come from the same device.  The location and outcome of the test are known.  No additional covariates are.  Basically, I will select the maximum speed at home per device, and reconstruct devices' \"home\" Census tracts.  So this is an ecological regression.  What I am planning is a probability of a single device observation to land in the bin for tract $t$ and speed $s$, $p_{st}$.  What is fun about this problem, is you can write $p_{st}$ however you want.  What I was thinking of basically a proportionality between income bins (see `B19001_001E`, and following, from the [2019 ACS 5 year estimates](https://api.census.gov/data/2019/acs/acs5/variables.html)), as well as a probability following into each of the speed bins.\n",
    "* The distribution is not even plausibly gaussian, even after a log transform.\n",
    "* My biggest \"conundrum\" is how to include the correlation between selection / i.e., devices per tract and speed in this $p(s|t)$.  Where are the error terms and how are they correlated?  Is this identified?\n",
    "  * Each tract has a different composition in income or, were I to use just the median, a different value.\n",
    "  * This will lead to different numbers of devices per tract.  The selection and speed are not perfectly correlated.\n",
    "  * I can construct the bin probabilities numerically -- set the probabilities of each Internet speed (by income) and then truncate these; then I can fit back the parameters that lead to those distributions (numerically).\n",
    "\n",
    "#### Constructing Probabilites\n",
    "\n",
    "Let's start with five levels, $\\ell \\in {A, B, C, D, E}$ each with probabilities for five speed bins $s\\in {1, 2, 3, 4, 5}$.  That is, $1 = \\sum_s p_{s}^\\ell$.  \n",
    "\n",
    "The underlying level composition of tracts $t$, is known: $N_t = \\sum_\\ell N_{t\\ell}$.\n",
    "\n",
    "Imagine that selection is fixed per _level_ $d_\\ell$ is constant across tracts and speed tiers.  If we co-opt the notation of the selection $d_\\ell$ as a proportion, then it's $n_t = \\sum_\\ell d_\\ell N_{\\ell t}$.  We observe both the number $n_t$ of devices observed in tract $t$ in the sample, as well as their distribution of speeds.  That distribution represents the aggregate of selection over bins: $n_t = \\sum_\\ell n_{\\ell t} = \\sum_s n_{st}$.  (We observe $n_{st}$ but not $n_{\\ell t}$; we \"know\" $N_{\\ell t}$ from the Census, and want $N_{st}$.)\n",
    "\n",
    "**What is not credible about this stance, is that the _individuals within groups_ who run speedtests are also likely the ones with faster speeds: they may be more knowledgeable about both tests and broadly (thus higher income) or they're just \"into the Internet.\"**\n",
    "\n",
    "So, does this let us identify the bin probabilities / proportions of _testers_ (not what we want) or of _households_ (what we want)?  I'm not completely sure, but it seems not believable.\n",
    "\n",
    "Perhaps it would be more accurate to write the selection as depending on both group and underlying speed tier $d_{s\\ell}$.  That's still just 30 or so parameters, and there are 4M tests, and 800 tracts $\\times$ 5 speed bins, for 4000 total bins.  A lot.\n",
    "\n",
    "The population of a single bin will be $n_{st} = \\sum_\\ell N_{\\ell t} p_s^\\ell d_{s\\ell}$.\n",
    "\n",
    "Because the $p_s^\\ell d_{s\\ell}$ always go out together, I am not confident that this is identified.  In theory, the $p$'s determines the shape, while the $d$'s primarily affect levels.  For a tract population all of level $A$, you would observe the same bin contents from\n",
    "\n",
    "$p_{0}^A = 0.5$, $d_{0A} = 1$, $p_{1}^A = 0.5$, $d_{1A} = 0$\n",
    "\n",
    "or \n",
    "\n",
    "$p_{0}^A = 1$, $d_{0A} = 0.5$, $p_{1}^A = 0$, $d_{1A} = (\\textrm{unconstrained})$\n",
    "\n",
    "That said, I think this is somewhat contrived, and my _gut_ is that this is identified in practice.  Let's now put it to the test, with a computational example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### An Empirical Investigation..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's set up 1000 tracts with approximately 5000 people each.  They are randomly assigned to classes within tracts.\n",
    "\n",
    "In what follows, `N`, `P_t` and `P_tl` are considered known and fixed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(1)\n",
    "\n",
    "T  = 1799 # number of tracts\n",
    "\n",
    "# different, just so we get errors on mismatched indices\n",
    "L  = 6    # Income levels\n",
    "S  = 4    # Speed levels\n",
    "\n",
    "pop_mean = 2000\n",
    "pop_var  = 400\n",
    "\n",
    "# Generate the number of tracts\n",
    "P_t = np.random.normal(loc = pop_mean, scale = pop_var, size = T).astype(int)\n",
    "\n",
    "# Random numbers...\n",
    "p_tl = np.random.uniform(size = (T, L))\n",
    "\n",
    "# Normalized into shares of each row.\n",
    "p_tl = p_tl / p_tl.sum(axis = 1)[:,np.newaxis]\n",
    "\n",
    "# And then into people in each class, in each tract.\n",
    "P_tl = (p_tl * P_t[:,np.newaxis]).astype(int)\n",
    "\n",
    "# That gives us tract counts again.\n",
    "P_t = P_tl.sum(axis = 1)\n",
    "\n",
    "N = P_t.sum() # Population"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also set up the speed probabilities _by class_ as well as the propensities to run the speedtests.\n",
    "\n",
    "The propensities cannot be by speed tier.  If it were, you could just rearrange one probability to go down, balanced by an increase in its own selection effect.  The other probabilities would then increase in proportion, and this could be offset by decreases in their own selection effects.  Obviously, everything is bounded, but apparently there is still enough freedom for this to work in practice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_sl_thresh = np.array([[0.25, 0.50, 0.75],\n",
    "                        [0.25, 0.50, 0.75],\n",
    "                        [0.20, 0.30, 0.50],\n",
    "                        [0.20, 0.30, 0.50],\n",
    "                        [0.10, 0.20, 0.35],\n",
    "                        [0.10, 0.20, 0.35]])\n",
    "\n",
    "p_sl_thresh_bounded = np.concatenate([np.zeros((L, 1)), p_sl_thresh, np.ones((L, 1))], axis = 1)\n",
    "\n",
    "p_sl  = p_sl_thresh_bounded[:,1:] - p_sl_thresh_bounded[:,:-1]\n",
    "\n",
    "# d_s   = np.array([0.1, 0.2, 0.3, 0.5, 0.8])\n",
    "\n",
    "d_l = np.array([0.01, 0.02, 0.04, 0.06, 0.08, 0.10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we have a \"latent\" populations, where we're re-broadcasting from classes' propensities for speeds to tracts's distributions of speeds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "P_tl_obs = P_tl * d_l\n",
    "\n",
    "P_ts_obs = np.multiply(P_tl_obs[:,:,np.newaxis], p_sl[np.newaxis,:,:]).sum(axis = 1)\n",
    "\n",
    "p_ts_obs_row = P_ts_obs / P_ts_obs.sum(axis = 1)[:,np.newaxis]\n",
    "p_ts_obs_row_cum = p_ts_obs_row.cumsum(axis = 1)\n",
    "\n",
    "P_t_obs = P_ts_obs.sum(axis = 1)\n",
    "\n",
    "n_obs = P_ts_obs.sum().astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1799, 4)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P_ts_obs.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple version of simulation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_data = poisson.rvs(P_ts_obs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate a mixed likelihood"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(215627.09168836154, 3362851.0853303843, 0.06412032118489636)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dist_llh = -(sim_data * np.log(p_ts_obs_row)).sum()\n",
    "\n",
    "KT_obs = sim_data.sum(axis = 1)\n",
    "\n",
    "pois_llh = -np.log(poisson.pmf(KT_obs, P_t_obs)).sum() * (N / T / S)\n",
    "\n",
    "dist_llh, pois_llh, dist_llh / pois_llh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the likelihood.  \n",
    "\n",
    "First define the true variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_variables = np.concatenate([d_l, p_sl_thresh.flatten()])\n",
    "# true_variables = p_sl_thresh.flatten()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Start the minimization reaonsable but incorrect values..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "thresh = np.array([[0.2, 0.4, 0.6],\n",
    "                   [0.2, 0.4, 0.6],\n",
    "                   [0.2, 0.4, 0.6],\n",
    "                   [0.2, 0.4, 0.6],\n",
    "                   [0.2, 0.4, 0.6],\n",
    "                   [0.2, 0.4, 0.6]])\n",
    "\n",
    "## Assume that these are equal.\n",
    "equal_selection = np.ones(L) * n_obs / N\n",
    "\n",
    "init_variables = np.concatenate([equal_selection, thresh.flatten()])\n",
    "# init_variables = thresh.flatten()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mixture model\n",
    "\n",
    "First define a likelihood, with one part of the likelihood for the tract counts, and a second part for the distribution within that tract.  The full likelihood is the sum of the two parts, plus an explicit penalty to enforce bounds (probabilities 0 to 1), since scipy is beying annoying."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mixt_nll(variables = true_variables, data = sim_data, verbose = False):\n",
    "\n",
    "    # Denoting fitting variables by \"_\"\n",
    "    # Variables are a 1-D aray, so extract the parts...\n",
    "\n",
    "    _d_l = variables[:L]\n",
    "\n",
    "    _p_sl_thresh = variables[L:].reshape(L, -1)\n",
    "    _thresh_bounded = np.concatenate([np.zeros((L, 1)), \n",
    "                                      _p_sl_thresh.reshape(L, -1), \n",
    "                                      np.ones((L, 1))], axis = 1)\n",
    "\n",
    "    # These are the constructed probabilities.\n",
    "    _p_sl  = _thresh_bounded[:,1:] - _thresh_bounded[:,:-1]\n",
    "\n",
    "    _P_tl_obs = P_tl * _d_l\n",
    "    _P_ts_obs = np.multiply(_P_tl_obs[:,:,np.newaxis], _p_sl[np.newaxis,:,:]).sum(axis = 1)\n",
    "\n",
    "    # Probabilities of bins, according to these parameters\n",
    "    _p_ts_obs_row = _P_ts_obs / _P_ts_obs.sum(axis = 1)[:,np.newaxis]\n",
    "\n",
    "    # Expected tract observations, for these parameters\n",
    "    _P_t_obs = _P_ts_obs.sum(axis = 1)\n",
    "\n",
    "    # Distribution of bins within tracts.\n",
    "    dist_llh = -(data * np.log(_p_ts_obs_row)).sum()\n",
    "\n",
    "    # Poisson of # of observations in the tract.\n",
    "    pois_llh = -np.log(poisson.pmf(data.sum(axis = 1), _P_t_obs)).sum() * (N / T / S)\n",
    "    \n",
    "    # Incorporate bounds penalty: probabilities outside [0, 1]\n",
    "    max_deviation = np.zeros(variables.shape)\n",
    "    max_deviation[variables > 1] = +variables[variables > 1] - 1\n",
    "    max_deviation[variables < 0] = -variables[variables < 0]\n",
    "    bounds_penalty = 10e4 * np.power(max_deviation, 4).sum()\n",
    "\n",
    "    return dist_llh + pois_llh + bounds_penalty\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pois_nll(variables = true_variables, data = sim_data, verbose = False):\n",
    "\n",
    "    # Denoting fitting variables by \"_\"\n",
    "    # Variables are a 1-D aray, so extract the parts...\n",
    "\n",
    "    _d_l = variables[:L]\n",
    "\n",
    "    _p_sl_thresh = variables[L:].reshape(L, -1)\n",
    "    _thresh_bounded = np.concatenate([np.zeros((L, 1)), \n",
    "                                      _p_sl_thresh.reshape(L, -1), \n",
    "                                      np.ones((L, 1))], axis = 1)\n",
    "\n",
    "    # These are the constructed probabilities.\n",
    "    _p_sl  = _thresh_bounded[:,1:] - _thresh_bounded[:,:-1]\n",
    "\n",
    "    # Selection effect -- how many people will we place in distributions...\n",
    "    _P_tl_obs = P_tl * _d_l\n",
    "    \n",
    "    # Number of observations at speed tiers, by tract.\n",
    "    _P_ts_obs = np.multiply(_P_tl_obs[:,:,np.newaxis], _p_sl[np.newaxis,:,:]).sum(axis = 1)\n",
    "    \n",
    "    # print(_P_ts_obs.shape)\n",
    "    # print(_P_ts_obs)\n",
    "    # print(poisson.pmf(data, _P_ts_obs))\n",
    "\n",
    "    # Incorporate bounds penalty: probabilities outside [0, 1]\n",
    "    max_deviation = np.zeros(variables.shape)\n",
    "    max_deviation[variables > 1] = +variables[variables > 1] - 1\n",
    "    max_deviation[variables < 0] = -variables[variables < 0]\n",
    "    bounds_penalty = 10e4 * np.power(max_deviation, 4).sum()\n",
    "    \n",
    "    # Just a Poisson...\n",
    "    pmf = poisson.pmf(data, _P_ts_obs)\n",
    "    neglog = -np.log(poisson.pmf(data, _P_ts_obs))\n",
    "    nll = np.nan_to_num(neglog, posinf = 1000).sum()\n",
    "\n",
    "    return nll + bounds_penalty\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is the actual minimum of the likelihood?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the initial conditions: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_nll = pois_nll(init_variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the population distribution and true parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_nll = pois_nll(true_variables) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(35031.53672456829, 21000.90438066925, 0.5994856733173488)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "init_nll, true_nll, true_nll / init_nll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we have a good amount of room for improvement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generated sample at starting variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35031.53672456829"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pois_sim_at_true_params = pois_nll(init_variables, sim_data)\n",
    "pois_sim_at_true_params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The generated sample at the true parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21000.90438066925"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pois_sim_at_true_params = pois_nll(data = sim_data)\n",
    "\n",
    "pois_sim_at_true_params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now optimize both the straight-Poisson and the mixture models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-22-5ea0a7ed9b4c>:34: RuntimeWarning: divide by zero encountered in log\n",
      "  neglog = -np.log(poisson.pmf(data, _P_ts_obs))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pois_SLSQP\n",
      "Optimization terminated successfully    (Exit mode 0)\n",
      "            Current function value: 20981.620955900376\n",
      "            Iterations: 63\n",
      "            Function evaluations: 1705\n",
      "            Gradient evaluations: 63\n",
      "mixt_SLSQP\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-21-3b1eee6b53fd>:26: RuntimeWarning: invalid value encountered in log\n",
      "  dist_llh = -(data * np.log(_p_ts_obs_row)).sum()\n",
      "<ipython-input-21-3b1eee6b53fd>:29: RuntimeWarning: divide by zero encountered in log\n",
      "  pois_llh = -np.log(poisson.pmf(data.sum(axis = 1), _P_t_obs)).sum() * (N / T / S)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully    (Exit mode 0)\n",
      "            Current function value: 3575933.8909196784\n",
      "            Iterations: 62\n",
      "            Function evaluations: 1710\n",
      "            Gradient evaluations: 62\n"
     ]
    }
   ],
   "source": [
    "methods = ['Nelder-Mead', \"Powell\", 'L-BFGS-B', 'TNC', 'SLSQP'] #\n",
    "methods = ['SLSQP']\n",
    "\n",
    "# bad = ['COBYLA', 'CG']\n",
    "# need_jac = ['Newton-CG', 'dogleg', 'BFGS', 'trust-ncg', 'trust-exact', 'trust-krylov']\n",
    "\n",
    "llh_fns = {\"pois\" : pois_nll, \"mixt\" : mixt_nll}\n",
    "\n",
    "res = {}\n",
    "for llh_label, llh in llh_fns.items():\n",
    "    for method in methods:\n",
    "\n",
    "        label = llh_label + \"_\" + method\n",
    "\n",
    "        print(label)\n",
    "        res[label] = minimize(llh, init_variables, method = method,\n",
    "                              options = {'maxiter' : 20000, 'disp': True})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dist:\n",
      "{'input': array([[0.2, 0.4, 0.6],\n",
      "       [0.2, 0.4, 0.6],\n",
      "       [0.2, 0.4, 0.6],\n",
      "       [0.2, 0.4, 0.6],\n",
      "       [0.2, 0.4, 0.6],\n",
      "       [0.2, 0.4, 0.6]]),\n",
      " 'mixt_SLSQP': array([[0.213, 0.427, 0.657],\n",
      "       [0.242, 0.498, 0.784],\n",
      "       [0.213, 0.316, 0.525],\n",
      "       [0.191, 0.291, 0.474],\n",
      "       [0.093, 0.192, 0.342],\n",
      "       [0.11 , 0.211, 0.365]]),\n",
      " 'pois_SLSQP': array([[0.213, 0.427, 0.658],\n",
      "       [0.242, 0.499, 0.785],\n",
      "       [0.213, 0.316, 0.525],\n",
      "       [0.191, 0.291, 0.474],\n",
      "       [0.093, 0.192, 0.342],\n",
      "       [0.11 , 0.211, 0.365]]),\n",
      " 'true': array([[0.25, 0.5 , 0.75],\n",
      "       [0.25, 0.5 , 0.75],\n",
      "       [0.2 , 0.3 , 0.5 ],\n",
      "       [0.2 , 0.3 , 0.5 ],\n",
      "       [0.1 , 0.2 , 0.35],\n",
      "       [0.1 , 0.2 , 0.35]])}\n",
      "\n",
      "sel:\n",
      "{'input': array([0.05155124, 0.05155124, 0.05155124, 0.05155124, 0.05155124,\n",
      "       0.05155124]),\n",
      " 'mixt_SLSQP': array([0.012, 0.018, 0.041, 0.059, 0.079, 0.1  ]),\n",
      " 'pois_SLSQP': array([0.012, 0.018, 0.041, 0.059, 0.079, 0.1  ]),\n",
      " 'true': array([0.01, 0.02, 0.04, 0.06, 0.08, 0.1 ])}\n"
     ]
    }
   ],
   "source": [
    "p_sl_comp = {\"input\" : thresh, \"true\" : p_sl_thresh}\n",
    "d_s_comp  = {\"input\" : equal_selection, \"true\" : d_l}\n",
    "\n",
    "for l in llh_fns:\n",
    "    for m in methods:\n",
    "        \n",
    "        l = l + \"_\" + m\n",
    "\n",
    "        params = res[l][\"x\"]\n",
    "\n",
    "        d_s_comp[l]  = params[:L].round(3)\n",
    "        p_sl_comp[l] = params[L:].reshape(L, -1).round(3)\n",
    "\n",
    "        \n",
    "print(\"dist:\")\n",
    "pprint(p_sl_comp)\n",
    "print(\"\\nsel:\")\n",
    "pprint(d_s_comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This looks great!\n",
    "\n",
    "Check for outliers; see that we're not crazy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.971814682423873, 0.0)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 243,
       "width": 371
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get_expected(variables = true_variables):\n",
    "\n",
    "    _d_l = variables[:L]\n",
    "    _p_sl_thresh = variables[L:].reshape(L, -1)\n",
    "    _thresh_bounded = np.concatenate([np.zeros((L, 1)), \n",
    "                                      _p_sl_thresh.reshape(L, -1), \n",
    "                                      np.ones((L, 1))], axis = 1)\n",
    "\n",
    "    # These are the constructed probabilities.\n",
    "    _p_sl  = _thresh_bounded[:,1:] - _thresh_bounded[:,:-1]\n",
    "\n",
    "    _P_tl_obs = P_tl * _d_l\n",
    "    _P_ts_obs = np.multiply(_P_tl_obs[:,:,np.newaxis], _p_sl[np.newaxis,:,:]).sum(axis = 1)\n",
    "\n",
    "    return _P_ts_obs\n",
    "\n",
    "\n",
    "pred_ts_obs = get_expected(res[\"pois_SLSQP\"][\"x\"])\n",
    "\n",
    "plt.scatter(pred_ts_obs.flatten(), sim_data.flatten(), alpha = 0.10, s = 100, lw = 0)\n",
    "pearsonr(pred_ts_obs.flatten(), sim_data.flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now with real data..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "counties = [17031, 17043, 17197, 18089]\n",
    "counties = [(g // 1000, g % 1000) for g in counties]\n",
    "\n",
    "income_levels = {\"B28004_001E\" : \"N\", \n",
    "                 \"B28004_002E\" : \"N_10k\",\n",
    "                 \"B28004_004E\" : \"br_10k\",\n",
    "                 \"B28004_006E\" : \"N_20k\",\n",
    "                 \"B28004_008E\" : \"br_20k\",\n",
    "                 \"B28004_010E\" : \"N_35k\",\n",
    "                 \"B28004_012E\" : \"br_35k\",\n",
    "                 \"B28004_014E\" : \"N_50k\",\n",
    "                 \"B28004_016E\" : \"br_50k\",\n",
    "                 \"B28004_018E\" : \"N_75k\",\n",
    "                 \"B28004_020E\" : \"br_75k\",\n",
    "                 \"B28004_022E\" : \"N_top\",\n",
    "                 \"B28004_024E\" : \"br_top\",\n",
    "                 }\n",
    "\n",
    "all_vars = \",\".join(income_levels)\n",
    "\n",
    "all_hh = [x for x in income_levels.values() if x.startswith(\"N_\")]\n",
    "br_hh = [x for x in income_levels.values() if x.startswith(\"br_\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "api_call = \"https://api.census.gov/data/2019/acs/acs5?get={}&for=tract:*&in=state:{:d}+county:{:03}\"\n",
    "\n",
    "income_data = []\n",
    "for st, co in counties:\n",
    "    \n",
    "    j = requests.get(api_call.format(all_vars, st, co)).json()\n",
    "    df = pd.DataFrame(columns = j[0], data = j[1:])\n",
    "    \n",
    "    df.rename(columns = income_levels, inplace = True)\n",
    "    df[\"geoid\"] = df.state + df.county + df.tract\n",
    "    \n",
    "    # df.drop([\"state\", \"county\", \"tract\"], axis = 1, inplace = True)\n",
    "    \n",
    "    df = df.astype(int)\n",
    "    \n",
    "    income_data.append(df)\n",
    "    \n",
    "income_data = pd.concat(income_data)\n",
    "income_data.sort_values(\"geoid\", inplace = True)\n",
    "income_data.set_index(\"geoid\", inplace = True)\n",
    "income_data.query(\"N > 0\", inplace = True)\n",
    "\n",
    "populated_tracts = set(income_data.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9866786940580806 339082 343660\n"
     ]
    }
   ],
   "source": [
    "speeds = pd.read_csv(\"speedtests_at_home.csv.gz\")\n",
    "\n",
    "Npop = speeds.query(\"geoid in @populated_tracts\").shape[0]\n",
    "Ntot = speeds.shape[0]\n",
    "\n",
    "print(Npop / Ntot, Npop, Ntot)\n",
    "\n",
    "speeds.query(\"geoid in @populated_tracts\", inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABtAAAAF6CAYAAACA4RwLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdf7Cld30f9vdHln8IdBEYbLB2Eq5NHQMWnrGITdu0kzXUTtrFQM24U1shkdPWnmTc4nbVdK2UKMSdsgneEDd4Wstp7EljJq5TQ5DX1NRGO9OZgF1kShBEcgezuL3CgCFeXRnJAfTtH+ec5eHqnHvPOfee85xzn9dr5plznt+fc3b1aPe+9/P9VmstAAAAAAAAwMgNfRcAAAAAAAAAm0SABgAAAAAAAB0CNAAAAAAAAOgQoAEAAAAAAECHAA0AAAAAAAA6BGgAAAAAAADQcWPfBfStqlprre8ytsKVK1eSJGfPnu21DoBFeX4B28wzDNhmnmHAtvL8AraZZ9jCatrGwQVoVbWTZKfvOgAAAAAAANhMQxzC8XySvc4CAAAAAAAA1w0xQLuU5ExnAQAAAAAAgOsGN4Rja20/yf5kvWrq0JYAAAAAAAAM1OACNHOgAQAAAAAAcJghDuFoDjQAAAAAAABmGmKAZg40AAAAAAAAZhrcEI7mQAMAAAAAAOAwQ+xAAwAAAAAAgJkG14FWVTtJdvquAwAAAAAAgM00xA6080n2OgsAAAAAAABcN8QA7VKSM50FAAAAAAAArhvcEI6ttf0k+5P1quqxGgAAAAAAADbNEDvQGJDdC5f7LgEAAAAAANgyg+tAq6qdJDt91wEAAAAAAMBmGmIH2vkke50FAAAAAAAArhtigHYpyZnOAgAAAAAAANcNbgjH1tp+kv3JelX1WA0AAAAAAACbZogdaAAAAAAAADCTAA0AAAAAAAA6BjeEY1XtJNnpuw4AAAAAAAA20xA70M4n2essAAAAAAAAcN0QA7RLSc50FgAAAAAAALhucEM4ttb2k+xP1quqx2oAAAAAAADYNIML0BiG3QuX+y4BAAAAAADYUkMcwhEAAAAAAABmEqABAAAAAABAhwANAAAAAAAAOgY3B1pV7STZ6bsOAAAAAAAANtMQO9DOJ9nrLAAAAAAAAHDdEAO0S0nOdBYAODV2L1zO7oXLfZcBAAAAAFttcEM4ttb2k+xP1quqx2oAAAAAAADYNEPsQAMAAAAAAICZBGgAAAAAAADQIUADAAAAAACADgEaAAAAAAAAdAjQOHV2L1zuuwQAAAAAAGCL3dh3AetWVTtJdvquAwAAAAAAgM00xA6080n2OgsAAAAAAABcN7gOtCSXktzbWReinRKGbgQAAAAAAE7C4AK01tp+kv3JelX1WA3L6AZlVy+ee8o2AAAAAACA4xjiEI4AAAAAAAAwkwCNjTRvR9nuhcu6zzgWv4cAAAAAADhIgMbG64Ybgg4AAAAAAGDVBjcHGptn2pxmhx2z7PVnXRsAAAAAAKBLgMZG0W0GAAAAAAD0TYBGr4Rk9MXvPQAAAAAAZjEHGr3YvXB57QGGwAQAAAAAAJiHDjRW7jQFV7sXLptLDQAAAAAATjkBGscyCce6oVI3MNu0sKlb77TaAQAAAAAABGicmG3qNJtW68Hgb9bnmRUQCuQAAAAAAOB0GFyAVlU7SXb6rmNbPbh3LWenbN+m8Oygo8K0Rc8F6ItnEgAAAACcjMEFaEnOJ7mn7yK2mR/QHm2Th7EEAAAAAAAOd0PfBfTgUpIznYUVGmLYNsTPDAAAAAAAp8ngArTW2n5r7ZHJ0nc9DJOQDQAAAAAANtcQh3CEtTKc4+YRYAIAAAAAcBgBGqxRN7iZvBeqAQAAAADAZhncEI4wJDqtAAAAAABgcTrQoGfdTjTDPQIAAAAAQP90oMGG2r1wWQcZAAAAAAD0QIAGG0JYBgAAAAAAm8EQjrAFDO0IAAAAAADrI0CDDTdPZ9rBgG2Tutm6c7wBq7FJ/80DAAAAwGmw8QFaVd2e5K8nuT3J85I8luRfJrnUWvtnfdYGfZr1A3M/SJ/NdwMAAAAAwDw2PkBL8k1JvibJzyV5JMnTk7w2yTuq6kdbaz/dZ3GwbouGQDrA4HQTDAMAAADAydv4AK219k+T/NPutqp6a5IHkvyXSQRoAAAAAAAAnJiND9Cmaa19sar+vyQv67sW2BYHu1ROuiNNpxuH2b1w2e8NAAAAAGBr3NB3AfOqqpur6jlV9c1V9deS/PtJ3t13XbCtdi9cfkqoNm3bvNcCgFXx/xkAAABg3RYK0Kpqp6peVVU/UVXvqqo/qKo2Xl445zWeV1U/VVUfraonquqTVXVfVb3iiFPfmuTTSX4nyX+f5JeS/NVF6geeatnQbJn79Knv+wMAAAAAsD0WHcLxFUnevuzNqurbkrwnybPHmx5N8pwkr0xyrqrubq1dnHH630nyj5PcmuQvJHn6eLm2bD3AdLPCpqsXzy00VKPQCgAAAACAbbTMEI6fSvKrSd6Y5IfnPamqbkryzozCsw8kua21dkuSZyW5lKSSvKmqvmfa+a21j7TWfr219o+S/LkkNyd5Z1XVEp8BOGCesEsgBgAAAADAECzagXZfa+0dk5Wq2l3g3B9J8vwkjyX53tbaXpK01h5NcldVvSDJa5K8KUfMbdZaa1X1S0l+OsmfSvLwAnUAJ0CYBv3y3yAAAAAArM5CAVpr7YvHuNcd49e3TcKzA96cUYB2e1W9sLX20BHXu2n8essxagJO2Kb9UH/T6gEAAAAAYPMtM4TjwqpqJ8lLx6u/NuOw9+VL85m9vHPu10253lcleV2Sx5N85OQqBfq0e+GywAsAAAAAgN4tOoTjsl6U0RxnSfLhaQe01p6sqoeTfGeSF3d2/WJVfS7Je5P8fpJbMwrPvjnJ+dbaYyurGjhRk3Ds6sVzp+I+AAAAAACcTtVaW/7k0RxoHxuvvmjWsItV9eokk7nTntFa259x3NszGsbxl1trrx1v+6EkfzGjUO1rkzya5IEkb22tvXPOOh84ZPft999//zyXGbz9/f088fkn88nH+66EbXfbmekjrz64d+0p22YdO8u0axynJk7Gg3vXev2O9/dH/9vZ2dnprYaTdtTvdb+nOU36fob07TQ+w4Dh8AwDtpXnF7DNPMMWc/bs2Zq2fV0daE/vvD8sfvnc+PXmyYbW2s8l+blVFAX0Z/LD/035gejQfzjLdlk2KAYAAAAA5rOuAG1qercurbWXztpXVe3s2bNrrGZ7XblyJR/fu5af/NC6fttwWl2942zunAyzeMfZJJNhF6f83vrQH801FOOX5k47xu/PD/3RqKaL5wwDecLuvHD5+q91H65cuZIkOS3P+zvnmCuwz+8bTlrfz5C+nbZnGDAsnmHAtvL8AraZZ9jJWFcS0p2n7KYkU4dwTPK0KcefqKraSaJvEXq0O8cP/6cdL8wCAAAAAGAd1hWgPdJ5f2uSh2ccd+v49RMrrOV8kntWeH1gAcuGaau0jnsAAAAAALC5bljTfR5K0sbvv3XaAVV1Q5JvGa9+ZIW1XEpyprMAW6KPYEuYBgAAAAAwPGsJ0Fpr+0neP1797hmHvSzJLeP3v7HKWlprj0yWVd0HAAAAAACA7bSuDrQkedv49Y6q+oYp++8avz7QWps1xOOxVdVOVd06WVZ1HwAAAAAAALbTwnOgVdVzOqvP6rx/5oF9n22tPdlZ/5kkP5bk+Ul+pape11r7SFXtJHlDku8bH3f3ojUtyBxowEImwzhevXiu50oYMsOJAgAAAMD6LBygJfn0jO3vPbD+jUmuTlZaa49X1aszGp7x9iQfrqpHk9ycUSdcS3J3a+3dS9S0iEtJ7u2s7634fgAAAAAAAGyRZQK0pbXWPlhVtyX58SSvTHImyWeS/FaSt7TWVjb3WaeG/ST7k/WqWvUtAQAAAAAA2CILB2ittWMlTq2130/y+vECAAAAAAAAG2WtHWibYDzn2k7fdQAMgXm7js93CAAAAADrd0PfBfTgfEbznk0WAFZA8HN8vkMAAAAA6MfgOtCSXEpyb2ddiAacmG7gcfXiuS/b3l0H4GhCZAAAAKAvgwvQWmv7SfYn61XHmtINGLDJD3YFY/PxfQEAAAAA22JwARrAsrpdZN2uiFkdErrOWJauGwAAAADo1+ACtKraSbLTdx3Adlo02DgsXEt0Y/HlvxcEZwAAAACwGW7ou4AenM9o3rPJArBWR3WvbWOIsnvh8vUFAAAAAGDbDTFAu5TkTGcB2DjbHEZtc+3rsK7vxq8BAAAAACxvcEM4ttb2k+xP1quqx2qAIVk20Jh23qyhH827BgAAAABwfIML0AA2zSo7hcy1djwCSeiHDkoAAACgb0McwhFg6x02j9q0IRRX8cNo854dn+8OAAAAADbT4DrQqmonyU7fdQCcpGlBzGHhTLcz7WCXWve8bveVbqzFzeoAXPTXCwAAAABYr8EFaEnOJ7mn7yIA5jFPCHYS11rnNdblOIHfcearmxZECh8BAAAAYLsMMUC7lOTezvpeX4UA9O2woSAn21YR/EzrgJuYdb9ZtRx2/mTfz//5px+r3qNqOep7PGw7AAAAALB5Bhegtdb2k+xP1quqx2oANl/fwc9JBXsP7l3LnePzpg1TedTnPCw0A45HlyYAAACwaQYXoAHQr0W63g7un6fTa5oH964tdd4yxwMAAAAA20+ABsCgLRKQCdNgdbpDuwIAAAD0TYAGwMY5TlAl5ILt5r9hAAAAYBPc0HcBAAAAAAAAsEkG14FWVTtJdvquAwBWzZB4AAAAALCcIXagnU+y11kAAJZiuEEAAACA02mIAdqlJGc6CwAAAAAAAFw3uCEcW2v7SfYn61XVYzUAAAAAAABsmiF2oAEAAAAAAMBMg+tAAwA4LnOfnYxFvsfJsVcvnltVOQAAAADXCdAAAFgb4SMAAACwDQzhCAAAAAAAAB0CNAAAAAAAAOgY3BCOVbWTZKfvOgAAAAAAANhMQ+xAO59kr7MAAAAAAADAdUMM0C4lOdNZAOBU271weep7WJfdC5f93gMAAAC2yuACtNbafmvtkcnSdz0AsG6TMGPZQGOIQYgQcnm+LwAAAGAbDS5AA4AhWiYwW1Xw0a1FZxIAAAAAm+jGvgsAADbDJMi6evHc0ucve+6m0nkGAAAAMEwCNAAYsGmh0KZ0qrG5jhu2AgAAAGw6ARoAMFM3HOuGJfMEKNOCtVnHn0T32rzXWHf4M+s7PO0EqwAAAMA2MwcaALC0WSHJccKTaXOkrTqMOThUo/BnPosOcel7BQAAALaFAA0AODFHhU99zCl2GkMbIR8AAADAagnQAICtdTBE2pRgaZkaNqV2AAAAAMyBBgBsiXUO47iq+y0719tJzBF3HIveXxAIAAAAbDsBGgAwl00NsOaZh20TA515Qqlpn+G4QdpJXefg9Q6+BwAAANhmhnAEAAbppMKeydCLmzCc5CL3nBV8HXy/js48AAAAgE0zuA60qtpJstN3HQDAMB0VQC27/7jBlmAMAAAA4EuG2IF2PsleZwEATpltC4NWNd/a5Lon0Q3XR0fdrDoAAAAAVm1wHWhJLiW5t7MuRAOAgdr2MGbWPGrHnZds278XAAAAgOMaXIDWWttPsj9Zr6oeqwEAhqyPOdIAAAAAONrgAjQAAEYEagAAAADTCdAAALaYEAwAAADg5AnQAABOiDALAAAA4HS4oe8CAAAAAAAAYJMI0AAAAAAAAKBDgAYAAAAAAAAdAjQAAE6t7rx0uxcuX18AAAAADiNAAwBgKwnCAAAAgFW5se8CjlJV35HkLyX5riS7ST6T5H1J/tvW2u/0WBoAAD042FWWJFcvnuurHAAAAOAU2vgALcl/k+TPJPmlJP8iyfOS/GiS366qf6u19qE+iwMAYDMI0wAAAICTsg0B2t9N8oOttX892VBVv5jkwSR3J/mBvgoDAGAzHBzOcVqXGgAAAMC8Nj5Aa6398ynb/p+qejDJi3soCQAAAAAAgFPshr4LWEZVVZLnJvl037UAALB9dKUBAAAAh1koQKuqnap6VVX9RFW9q6r+oKraeHnhnNd4XlX9VFV9tKqeqKpPVtV9VfWKBUp5XZIzSf7JIvUDAHD6HSccE6wBAAAAyeJDOL4iyduXvVlVfVuS9yR59njTo0mek+SVSc5V1d2ttYtHXONPJfn7Sd6b5OeWrQUAAAAAAACmWWYIx08l+dUkb0zyw/OeVFU3JXlnRuHZB5Lc1lq7JcmzklxKUkneVFXfc8g1npvkXUn+MMn3t9a+uET9AACQ3QuXD+04O2o/AAAAcHot2oF2X2vtHZOVqtpd4NwfSfL8JI8l+d7W2l6StNYeTXJXVb0gyWuSvCnJuw+eXFW3JPnfk9yS5N+ZnA8AAKfRJLz7+T//9J4rAQAAgOFZqAPtmB1fd4xf3zYj/Hrz+PX2g/OpVdXXZNS99s1JzrXWHjpGHQAAAAAAADDTMkM4LqyqdpK8dLz6azMOe1+Sa+P3L++c+xVJfjHJv53RsI2/uao6AQAYnlUM0zjP8I+GiAQAAIDNtZYALcmLMprjLEk+PO2A1tqTSR4er764s+tSkldlNO/as6vqL3SXVRUMAADr0A3RFg3U5pnH7SQI+wAAABiaaq0tf/JoDrSPjVdfNGtoxap6dZLJ3GnPaK3tzzju7RnNg/bLrbXXjrddSfJnZ9XQWqtZ+zrXfeCQ3bfff//9R12CJPv7+3ni80/mk4/3XQnAYp570+jV8wuYx21nbkmSPLh37Snb5jU597Dzpl3/wb1rT7n/858x+jdvOzs7M8+fda/u9Y7jON8FMGz7+6O//h98hgFsOs8vYJt5hi3m7NmzU3OmdXWgdWc+P+zHl58bv9482dBaO9taq1nLSqoFAIAZHty79pTw6uD6SXri808eef+h830AAABw0m5c0316Dbpaay+dta+q2tmzZ9dYzfa6cuVKPr53LT/5oXX9tgE4GXe95AtJ4vkFzOXqHWeTJHd2hiycbPuy7R/6o1y9eO76tskxo6EOb3zKeQdNu373OpP9d73kC7nta3cy+TPrnTOGUpx2r+71unYvXL5e+5dqzpdtO6rWTTLrcwL9u3LlSpLE37uBbeP5BWwzz7CTsa6fJD7WeX9TkqlDOCZ52pTjT1RV7STRtwgAwLEdZ/6yRTy4d21mcDbNtLpmhWNH1W3us6O/w1nHd8/phpYHA0wAAAA2z7qGcHyk8/7WQ46b7PvECms5n2SvswAAwEqc5vBp1mfbvXD5+rLJ1lXjNnwXAAAAPNW6ArSHkrTx+2+ddkBV3ZDkW8arH1lhLZeSnOksAAAwl20OXA5e8yTvs0kBUV+faZ7vU5gGAACwPdYyhGNrbb+q3p/kO5J8d5JfnnLYy5LcMn7/G6usJZ0hJKt6nZ4NAIBTbtpwfvRLiAUAAMBR1jUHWpK8LaMA7Y6q+luttYPDNN41fn2gtfbwqoowBxoAAH1ZZXDTRyg0T8dVNzScNZfYvHOMzbrePMcLzQAAAFjEwgFaVT2ns/qszvtnHtj32dbak531n0nyY0men+RXqup1rbWPjAOtNyT5vvFxdy9a04LOJ7lnxfcAAOAUEb4s76hw7LDvdtq584Zt81x/mWsuev9VXwcAAIDVWKYD7dMztr/3wPo3Jrk6WWmtPV5Vr85oeMbbk3y4qh5NcnNGc7G1JHe31t69RE2LuJTk3s763orvBwDAFjnNYdkin+00fw8n5bCADwAAgO22ziEc01r7YFXdluTHk7wyyZkkn0nyW0ne0lpb2dxnnRrMgQYAAFNs0xCTpyWoOjgsJQAAAJth4QCttXasxKm19vtJXj9eAACALbKu4GrR+6w7UOve77j3NpwjAADA5llrB9omGM+5ttN3HQAAMHFauqkWsQ2feRtqBAAAYDUGF6AlOZ/knr6LAAAA5iPIAgAAYN2GGKBdSnJvZ32vr0IAAIAv1+dQjJvAcI4AAACbYXABWmttP8n+ZL3qWFO6AQAA2bwgahXW+Rl3L1wWogEAAPTohr4LAAAAAAAAgE0yuA60qtpJstN3HQAAAAAAAGymIXagnc9o3rPJAgAArNGqh0LcvXB5EENKLst3AwAAcLQhBmiXkpzpLAAAwAboO9jp+/6zCAQBAADWb3BDOLbW9pPsT9arqsdqAACATbJJQdUm1QIAADA0Q+xAAwAA2DgCMwAAgM0hQAMAADilDP8IAACwnMEN4VhVO0l2+q4DAAAAAACAzTTEDrTzSfY6CwAAwMY72Ek26S6b1WGm8wwAAGB5QwzQLiU501kAAAC2yjaGY4aTBAAAtsngArTW2n5r7ZHJ0nc9AAAA22yZUGxWmCZkAwAANsXgAjQAAIDT6iTDLAAAgCEToAEAADDTtIBN4AYAAJx2AjQAAIBTZJ6OsmW6zg47/qjrrSJw0zkHAACs0o19FwAAAMDxzBOYreM+q7ovAADAug0uQKuqnSQ7fdcBAAAAfZuEnFcvnuu5EgAA2CyDC9CSnE9yT99FAAAALEpHVz+ETAAAMDxDnAPtUpIznQUAAIB8+bxiq5pj7DjXPOmaBJIAAMAsg+tAa63tJ9mfrFdVj9UAAACcHt1A6jjdWrsXLl8//7iB23FrAQAAhmlwARoAAACbb12dZkeFbLrUAABgmIY4hCMAAACHWFdotKohIoVeAADAcelAAwAA4MStMsTahIDsqOEqD9tvaEkAANh8OtAAAADYiFBq2x01VOQmfMebUAMAAGwDARoAAAD0ZFqw1l3vI/Ba9p7COQAAThMBGgAAAFvtqBCqb6d9OEsAADiNBjcHWlXtJNnpuw4AAAAAAAA20+ACtCTnk9zTdxEAAAB924TupUkNVy+eO7FrnUQtR81nNiTL/hrtXricu17yhdx25pZVlAUAACs1xADtUpJ7O+t7fRUCAACwrU5biLSuecf6nt8MAACYz+ACtNbafpL9yXpV9VgNAAAAxzGkEGpWJ1j3OziJTr7jWKRbbffC5d7rBQCAWW7ouwAAAABgMbsXLm9EeLgJNQAAwCoMrgMNAACAzSOI+XLrHupxE7rBTnI+PAAAOC4daAAAAAAAANChAw0AAACOYRu655atcdZ5J/2ZD3bc6UIDAKBvAjQAAACYwzyh0XGCqpMOjY4aEvFgrfMOG7kNgSEAAByXIRwBAAAAAACgQwcaAAAA0AvdbAAAbCodaAAAALBFhho67V64PNjPDgDA+gnQAAAAAAAAoGNwQzhW1U6Snb7rAAAAgD6su4vrwb1rObvC608+z9WL52bun7UPAABmGVyAluR8knv6LgIAAAC2yXGCt+65QwizhHYAANtviEM4XkpyprMAAAAAAADAdYPrQGut7SfZn6xXVY/VAAAAwGqte8jGk3DcjjUdYAAAHNcQO9AAAAAAAABgpsF1oAEAAMAmOslOsXV2nW1Kh9syXWeT2nWrAQBwkA40AAAAAAAA6BCgAQAAAHTsXri8MZ11AAD0Q4AGAAAAAAAAHQI0AAAAgCUc7FLTuQYAcHoI0AAAAAAAAKDjxr4LAAAAAE7GULqfJp/z6sVzC58365yjvruhfLcAAIxsfAdaVd1cVW+sql+tqk9XVauqC33XBQAAAAAAwOm08QFakuck+RtJXpLkAz3XAgAAAGyoeeYgW3SesqOOP4l5z2adr+sNAKA/2zCE4yeSnGmtPVJVu0k+1m85AAAAAAAAnGYbH6C11v44ySN91wEAAAAAAMAwbHyABgAAAGyXo4Y83BaLDvV41ParF89dX+++BwBg8yw0B1pV7VTVq6rqJ6rqXVX1B1XVxssL57zG86rqp6rqo1X1RFV9sqruq6pXLPcRAAAAAAAA4OQs2oH2iiRvX/ZmVfVtSd6T5NnjTY8meU6SVyY5V1V3t9YuLnt9AAAAAAAAOK5lhnD8VJL3J/m/kuwluXeek6rqpiTvzCg8+0CS17XWPlxVz0jyN5KcT/Kmqvrt1tq7l6gLAAAAOGWWHQ7yJIZfXKfu0I4AAPRv0QDtvtbaOyYrVbW7wLk/kuT5SR5L8r2ttb0kaa09muSuqnpBktckeVMSARoAAAAAAAC9WGgOtNbaF49xrzvGr2+bhGcHvHn8evu886kBAAAAAADASVtmCMeFVdVOkpeOV39txmHvS3ItyS1JXp7koTWUBgAAAAxQH8M2du95UsNPAgCwGmsJ0JK8KEmN33942gGttSer6uEk35nkxd19VfWjSZ45XpLku6pqUvvfb61dO/mSAQAAAAAAGKJqrS1/8mgOtI+NV1/UWpvaNVZVr04ymTvtGa21/RnHvT2jedB+ubX22s72qxnNnzbNN7bWrh5R5wOH7L79/vvvP+x0xvb39/PE55/MJx/vuxKAxTz3ptGr5xewjTzDgG22imfYbWduyYN7i/072tvO3JIkC593HMve8+Dnm1wHWK/9/dGPL3d2dnquBGBxnmGLOXv2bE3bvq4OtKd33h/2x+bPjV9v7m5sre2edEEAAADA9lkmBFtncNbnPad5cO+aEA4AYAnrCtCmpnfr0lp76ax9VdXOnj27xmq215UrV/LxvWv5yQ+t67cNwMm46yVfSBLPL2AreYYB28wzbHFX7zibOztzoF294+yxrnfnhcvHvgYM0ZUrV5Ikfm4IbCPPsJOxrj/BPtZ5f1OSqUM4JnnalONPVFXtJNG3CAAAAAAAwFQ3rOk+j3Te33rIcZN9n1hhLeeT7HUWAAAAgI2w2+k+W+bcRc4/6vijrnVw/6L3X9a67gMADNu6ArSHkrTx+2+ddkBV3ZDkW8arH1lhLZeSnOksAAAAAAAAcN1aArTW2n6S949Xv3vGYS9LMpnV9jdWWUtr7ZHJsqr7AAAAAAAAsJ3W1YGWJG8bv95RVd8wZf9d49cHWmsPr6qIqtqpqlsny6ruAwAAAAAAwHa6cdETquo5ndVndd4/88C+z7bWnuys/0ySH0vy/CS/UlWva619pKp2krwhyfeNj7t70ZoWdD7JPSu+BwAAAMCJ2b1wOVcvnrv+fmLatuPeZ5njJ3UAAJwWCwdoST49Y/t7D6x/Y5Krk5XW2uNV9eqMhme8PcmHq+rRJDdn1AnXkoUwaVUAABgoSURBVNzdWnv3EjUt4lKSezvreyu+HwAAAAAAAFtkmQBtaa21D1bVbUl+PMkrk5xJ8pkkv5XkLa21lc191qlhP8n+ZL2qVn1LAAAAAAAAtsjCAVpr7ViJU2vt95O8frwAAAAAAADARllrB9omGM+5ttN3HQAAAAAAAGymwQVoSc4nuafvIgAAAAAWsXvh8okdd/CYWed0t1+9eG7u+3ePnXaNg8esQx/3BAC21w19F9CDSxnNvTZZAAAAAAAA4LrBdaC11vaT7E/Wq441pRsAAAAAAACnzBA70AAAAAAAAGCmwXWgVdVOkp2+6wAAAAAAAGAzDS5AS3I+yT19FwEAAABwlN0Ll/suYSmTuq9ePNdzJbNtQ40AQH+GOITjpSRnOgsAAAAAAABcN7gOtNbafpL9yXpV9VgNAAAAAAAAm2aIHWgAAAAAAAAwkwANAAAAAAAAOgY3hGNV7STZ6bsOAAAAAAAANtPgArQk55Pc03cRAAAAAOu0e+Fyrl48N3X7SVx7U3RrmfZ5Dx5z2PZZ5x927iLnAACba4hDOF5KcqazAAAAAAAAwHWD60Brre0n2Z+sV1WP1QAAAAAAALBphtiBBgAAAAAAADMJ0AAAAAAAAKBDgAYAAAAAAAAdAjQAAAAAAADouLHvAtatqnaS7PRdBwAAAAAAAJtpiB1o55PsdRYAAACArbR74XJ2L1xe2fHTzj3ONea5x1HvZ22bp66T/L5O6js46nOu2yp/fQFgmwwxQLuU5ExnAQAAAAAAgOsGN4Rja20/yf5kvap6rAYAAAAAAIBNM8QONAAAAAAAAJhJgAYAAAAAAAAdAjQAAAAAAADoEKABAAAAAABAhwANAAAAAAAAOgRoAAAAAAAA0HFj3wWsW1XtJNnpuw4AAAAAAAA20+ACtCTnk9zTdxEAAAAA67B74XLfJSytW/uqPsei1132+KsXzy103qK6dS1yr90Ll1d6/Gkz9M8PMCRDHMLxUpIznQUAAAAAAACuG1wHWmttP8n+ZL2qeqwGAAAAAACATTPEDjQAAAAAAACYSYAGAAAAAAAAHQI0AAAAAAAA6BCgAQAAAAAAQIcADQAAAAAAADoEaAAAAAAAANAhQAMAAAAAAIAOARoAAAAAAAB0CNAAAAAAAACg48a+C1i3qtpJstN3HQAAAAAAAGymwQVoSc4nuafvIgAAAABOu90Ll2eud99fvXhu5jmLXH/R/Yvcp1vjvPc8eM5k36zts6518Ps56vzueYfVs6xZn2PeYw/7Puf5jqadO+0zH3aPab/nutse3LuW287cMuNTHc8iv58A6M8Qh3C8lORMZwEAAAAAAIDrBteB1lrbT7I/Wa+qHqsBAAAAAABg0wyxAw0AAAAAAABmEqABAAAAAABAhwANAAAAAAAAOgRoAAAAAAAA0CFAAwAAAAAAgA4BGgAAAAAAAHQI0AAAAAAAAKBDgAYAAAAAAAAdGx+gVdVXVtXfqqrfq6onqupfVNUP9l0XAAAAAAAAp9ONfRcwh3uT/MUkP53kQ0lek+QXqurG1to/6rUyAAAAAAAATp2N7kCrqtuT3Jnkb7bW/ovW2s8meWWSK0neXFVf3WN5AAAAAAAAnEIbHaAl+Y+SPJlR91mSpLXWkrw1ydcnOdtPWQAAAAAAAJxWmx6g3Z7ko621zx7Y/pud/QAAAAAAAHBi5g7Qqmqnql5VVT9RVe+qqj+oqjZeXjjnNZ5XVT9VVR+tqieq6pNVdV9VvWLGKbcm+cSU7Y909gMAAAAAAMCJuXGBY1+R5O3L3qiqvi3Je5I8e7zp0STPyWhOs3NVdXdr7eKB025K8scHr9Vae7KqPj/eDwAAAAAAACdm0SEcP5XkV5O8MckPz3tSVd2U5J0ZhWcfSHJba+2WJM9KcilJJXlTVX3PgVMfT/LVU653Q5KvHO8HAAAAAACAE7NIB9p9rbV3TFaqaneBc38kyfOTPJbke1tre0nSWns0yV1V9YIkr0nypiTv7pz3ifF5B02Gbnxkyj4AAAAAAABY2twdaK21Lx7jPneMX982Cc8OePP49fYD86k9kOQFVfW1B45/2fj1t49REwAAAAAAADzFokM4LqyqdpK8dLz6azMOe1+Sa+P3L+9s/6WMavyrnetVkh9N8ukkV06yVgAAAAAAAFhkCMdlvSijOc6S5MPTDmitPVlVDyf5ziQv7mx/oKr+lyRvrKqvS/KhjIZ6PJvkL7fW/niVhQMAAAAAADA81Vpb7sTRHGgfG6++qLX20IzjXp1kMnfaM1pr+zOOe3tG4dgvt9Ze29n+VUnekOTOJF+f5HeS/O3W2j9eoNYHDtl9+/333z/vpQZtf38/T3z+yXzy8b4rAVjMc28avXp+AdvIMwzYZp5hzOu2M7ckSR7cu3bEkf2ZVuNk28Ht3f2T7Qffzzpv2r6D27rrs+598J4HrzPretPuOetes46ZdvxRn+Go+8/zOSb75vkMR33mT3/2Wr7mK2/Izs7Ooecu4ySuAXCY/f1RDHPwGcZ0Z8+erWnb19GB9vTO+8P+yPy58evN3Y2ttX+dUYD2hhOuCwAAAIANsMnB2cS0Go+qu7t/1vt5rznv+fPUMyucmhVyzVPTvPc+bPuyodIy382itS8SMi56v6NC2aMC01mB7GG/zrMC31nHL1L3Udc4ie9zHofdZ1X3PK5FA+eTvuc6vpfjfp5N/bWblwB9u6yjA+2OJJNusa9srX1hxnG/kOQHk7y7tfbnlipqCVXVlv0OhubKlSt5cO9afvJD68hdAU7OXS8Z/a/H8wvYRp5hwDbzDIOTcfXiuexeuHxi5129eO76++7+g8dPjlvm3vPUdtj9uzVOO27Wvmn3OGie49/6C/8st525JWfPns3uhcsz653XwXse9mtwcPtRn3eeax283lG/Lw67/zz3Ouwa3e9znvss67D7rOqexzXP97XKe67jeznu59nUX7t5rfrXc+LKlStJkrNnz678XqfE1A60G9Zw48c672865LinTTkeAAAAAAAA1mod/wTskc77W5M8POO4W8evn1hlMVW1k8TAnwAAAAAAAEy1jg60h5JMxkj81mkHVNUNSb5lvPqRFddzPsleZwEAAAAAAIDrVh6gtdb2k7x/vPrdMw57WZLJzHm/seKSLiU501kAAAAAAADgunV0oCXJ28avd1TVN0zZf9f49YHW2qwhHk9Ea22/tfbIZFnlvQAAAAAAANg+CwVoVfWcyZLkWZ1dz+zuGw/J2PUzST6e0dxjv1JVLx5fb6eq/k6S7xsfd/dyH2Ohz7BTVbdOllXfDwAAAAAAgO1y44LHf3rG9vceWP/GJFcnK621x6vq1RkNz3h7kg9X1aNJbs4oxGtJ7m6tvXvBepZxPsk9a7gPAAAAAAAAW2hdQzimtfbBJLcl+R+S/G6Sr07ymSSXk3x3a+3imkoxBxoAAAAAAAAzLdSB1lqr49ystfb7SV4/XnrRWttPsj9ZrzrWRwIAAAAAAOCUWXQIx61XVTsZzcUGAAAAAAAAT7G2IRw3yPkke50FAAAAAAAArhtigGYONAAAAAAAAGYa3BCO5kADAAAAAADgMNVa67uGXlXVsL8AAAAAAACAAWutPaXbavABGvOrqgeSpLX20r5rAViE5xewzTzDgG3mGQZsK88vYJt5hp2MIc6BBgAAAAAAADMJ0AAAAAAAAKBDgAYAAAAAAAAdAjQAAAAAAADoEKABAAAAAABAR7XW+q4BAAAAAAAANoYONAAAAAAAAOgQoAEAAAAAAECHAA0AAAAAAAA6BGgAAAAAAADQIUADAAAAAACADgEaAAAAAAAAdAjQAAAAAAAAoEOAxpGq6nlV9VNV9dGqeqKqPllV91XVK/quDTi9qupPVtWPjZ83v1dVf1xV+1X1waq6WFXfcMT5X1VVf62q/u+qeqyq/rCq3ltVP1xVNcf9v7+q3lNVn6mqz1XVv6yq/66qdk7uUwJDUVU3V9X/W1VtvNx5yLGeX8DGqKpvqqq3jJ8lj1XVtfH7f1hVf3bGOZ5jQG+q6oaq+qGq+vWq+nRVfX78HPrNqvrrhz1LPL+AVaqqnap6VVX9RFW9q6r+oPN3xBfOcX5vz6iq+tNV9U+q6pFxRvB7VfUPqurfmPfzb6NqrfVdAxusqr4tyXuSPHu86dEkN2cUvrYkd7fWLvZUHnBKVdWfSPLxJN3/+T+a5OlJvmK8/q+SvLa1dv+U85+R0bPrpeNNn0tyY5KvGq//SpL/sLX2hRn3vzfJfzZe/UKSJzJ69iXJ7yb5d1trjyz+yYChqqq/l+T1nU0/1Fr7+SnHeX4BG6Oq/nKStya5abzpjzL6u+Bk/X9urf2nB87xHAN6U1VPS3Jfkpd3Nj+aZCdf+vvlx5O8vLX2uwfO9fwCVqqqXpPk7TN2v6i19tAh5/b2jKqqv5TkH4zv1zJ6rt4y3v1HSV7VWnvPrNq3mQ40Zqqqm5K8M6Pw7ANJbmut3ZLkWUkuZfQHjzdV1ff0VyVwSk1CsstJvj/J146fP09L8h8k+VhGz6J3VNXzppz/sxn9geKzSb43oz8QPC3JnRn9AeGVSd447cZV9Vcy+gPFk0n+6yQ3t9Z2kvyZjP6i9U1J/tdjf0JgMKrq9iQ/muQ35zjc8wvYCFX1H2f0g5KbMgrRXtBau7m19rQkz0vyuiT/fMqpnmNAn96QUXjWktyd5Jnjv0t+TZIfSPKHSZ6f0fPtIM8vYB0+leRXM3qe/PAC5/XyjBo32PxsRuHZLyR5bmvtmUl2k/wfGf1j9/+tqr5ugc+yNXSgMVNV/ViStyR5LMkLW2t7B/a/Pclrkvx2a+2lUy4BsJSquiXJbmvtgzP2vzCjYP9rkvzN1tobO/u+Pclvj1df3Vp754FzX5/k7yV5fHyPT3X2fXWS30vy9Une0lr7rw6c++1JHsjoHxC8qrV237E+KHDqVdUNGQVn357kO/Kl59NTOtA8v4BNUVVfn+ShjP7B0t2ttTfNeZ7nGNCrqvp4kj+Z5B+21v6TKfvvTPJz49Wvba39q/F2zy9g5arqK1prX+ys72b0j8STQzrQ+nxGVdU7krw6yfuT/JsH6r85yUeS/Ikkf7e1dn6Or2Gr6EDjMHeMX992MDwbe/P49fZ5xmgFmFdr7dqs8Gy8/6Ek7xuvHgzwf3D8+vDBP1CM3ZvkWkb/mvr7Duz79zL6A0XLqNP24H0/kOTXx6t3HNwPMMV/nuRPJ/kfx8+Qw3h+AZvir2QUnj2c5G8vcJ7nGNC3545fZ/2564HO+6d13nt+ASvXDZ8W1MszqqqemdFIUMkoIPvigXMfS/I/jVd/YJ552LaNAI2pxhMHTn4o/WszDntfRv9hJl8+tjTAOnxm/PoVB7Z/1/j13dNOaq09nuT/HK8efHZNzn1wxj8cSL70TPTcAw71/7d3ryGXVWUAx/+PmuM9y0tO1qSS5ailkReMDIpxMG9gX/wQlAZm0IdMpUyDLlJqEHYx6KbYeOkCZZRjGIxZKJTkLXTSFDUn1LGsccYr2jx9WOv0Lg/7nPc4Op79vu//B4e9117rmbPfD/Ocfc6z9l4RsSdwHrAW+PwEIeYvSX0x+PFkRWZufAlx5jFJ0/Zg3b5rRP/gt661QLvWj/lLUp9NK0e9F3jNuPduYhcDS0eMmbMsoGmUpcwsrnpX14D6Reqe2tz/1TgpSQKIiK0oz2kGuLM5HsDgjtjO3FWtrtvh3DVoTxK7W0TsOvvZSlrAvk1ZsP6szHxi3EDzl6S+iIhdgH1r88aI+EBEXBcR/4mIpyNidURcMJxHzGOSeuIHdXtKRJxdlwcgIraOiJMoS5Uk5fosa5/5S1JvTTlHDWIfzczH6ba62Z93NQILaBplcbP/8MhRM32Lx4yRpFfaJymL128EVjTHd6IsXgqblrsWD/WPi+2KlyQAIuJ44ETghsy8YoIQ85ekvti32V9OeaTPcmbu+l8KfBa4PSLaWcbmMUl98A3gO5RJ4ecD6yJiHWVdoJ9Q1nc8Yej6zPwlqc+mmaNmja13v60b8d5zngU0jbJ9s//MmHFP1+0Om/FcJOn/IuKdwFdr8+LMbGfQvNzcNYifJLYrXpKIiO2Bi4HnKQX/SZi/JPXFzs3+OZTZyodn5k6U3HEM8BiwJ/Dz+mQAMI9J6oG6Ps/pwJnAC/Xwa5n5DXRHYLehMPOXpD6bZo6aJHbce895FtA0yrxb8E/S3BcRi4FfUhZ7voUy+/lFQ5r93JS3eBmxkjTwZWAJcFFmrp5tcGX+ktQX7e8E/wVOzMyboTzGPzN/A3ys9i+l3G0L5jFJPRARewA3AV8HrgQOovyguy/wOWAf4NKIOL8Na/bNX5L6Zpo5asHnNwtoGuXJZn/bMeO26xgvSa+4iHg9ZcHSvYF7gWMz89mhYW0u2o7RRuWuJ4f6x8V2xUta4CLiYOBTwBpKIW1S5i9JfdHmh5WZed/wgMxcCfytNpd1xJnHJE3LCuAw4JLMPDkz/5KZT2XmfZl5AXBaHfeZiDiw7pu/JPXZNHPUJLHj3nvOs4CmUdrnmr5xzLhB3yOb8VwkLXB14efrgAOBh4Blmbm2Y+h64Km6vym56+Gh/nGxXfGS9E3KOkHnUtZ73qF9NeMW1WODLxrmL0l90X4XvGfMuEHfm+vWPCZpqiJif+Co2ryoa0xmXg48TvlN9Lh62Pwlqc+mmaNmjY2IbZl5BPi8y28W0DTK3czcmnlA14CI2AJ4e21O+ngiSXpJ6lpC1wKHAI9SimcPdY3NzAT+Wpuduavav26Hc9egPUnsPzPzX2PGSVqY3lK3K4ANHa+B79b2ajB/SeqV+5lZ52KSx/UkmMck9cLSZv+BMePur9u9wPwlqd+mnKMGsXtExC6zxHa995xnAU2dMnMD8OfaPGrEsMMpC7ECrNrsJyVpwamzWH4NvIcyS3BZZt47S9jv6rYzd0XENsCRtTmcuwaxB0TEqNk1y0fEStLLZf6SNHWZuRG4oTb3GzN0MJny780x85ikadrY7C8ZM24w4amd3GT+ktRn08pRNwLP1/1ldBvEPsJMoW/esICmca6q2w9HxOKO/rPq9pbMHPdoD0l6ySJia+AXwPuBdcDyzLxrgtAf1+1+EXFcR/+plOL/M8DVQ32rgMcon49ndJzTQcxcMFw5wblIWmAyc6/MjFGvZugp9dhezTHzl6S+uLxuj42Itw53RsSxwNtq89qmyzwmaZpub/ZP7RoQEccDu9fmn5ou85ekPptKjsrMJ5i51jujPpGujd0e+ERtXlXvlptXLKBpnO9RZhPuCFxTnyVNROwYEV8DPlTHnTOl85M0T0XElpQi/tGUWYEfzMxbJ4nNzNuAn9XmZRFxzODfjIiPABfWvosy87Gh2OeAL9bmpyPizIhYVOOPoFyEbAHclJnXbOrfJ0ldzF+SeuSnwC3AVsDVEXEolMf4R8TRwCV13M3AykGQeUzSNGXmA8Bva/P0iDg/InYHqGvPngxcVvsfBH7VxJq/JL0qImLXwQt4XdO1c9vXFqumnKO+QLkL7bD63rvW2CWUie9LKBPfL+yInfNiHhYF9QqqFehVwOAZp+uBHSj/qRI4JzMvmNLpSZqnIuJ9wO9r81ngiTHD12TmoUPxOwHXA++uh54GtgQW1fY1wImZ+cKI9/8+MzMWnweeo+Q+KM/LPzIzH+6KlaRxImJw8X1KZl7W0W/+ktQLEfEmyvXYPvXQBko+2q627wGOysw1Q3HmMUlTU5+gtIoXr4e2gTI5fGAtZZLmbUOx5i9Jm13znXA2e2fmg03c1HJURHwU+CFlclVSagSDpZ2eAk7IzOsn/LvmFO9A01iZeQdwIPAtyn+kRZR1iFZSvixZPJO0ObSfT9sAbxjz2m04ODPXU9ZNOxu4g/Lh/hzwR+A0ygd75wVFjf84cBLlOdFPUi4Q7ga+Ahzslx5Jm4v5S1JfZOY/gIOALwF3Un6gSeA24FzgkOHiWY0zj0mamsx8hPLj8unAH4B/Uwr/64FbgfOAdwwXz2qs+UtSb00zR2Xmj4AjKHfBrQW2BdYAl9bYeVk8A+9AkyRJkiRJkiRJkl7EO9AkSZIkSZIkSZKkhgU0SZIkSZIkSZIkqWEBTZIkSZIkSZIkSWpYQJMkSZIkSZIkSZIaFtAkSZIkSZIkSZKkhgU0SZIkSZIkSZIkqWEBTZIkSZIkSZIkSWpYQJMkSZIkSZIkSZIaFtAkSZIkSZIkSZKkhgU0SZIkSZIkSZIkqWEBTZIkSZIkSZIkSWr8Dz8MwCIP71cIAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 189,
       "width": 872
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = speeds.download_mbps.hist(bins = np.arange(0, 1000, 1), figsize = (15, 3))\n",
    "ax.set_yscale(\"log\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25     32.5100\n",
       "0.50     81.2010\n",
       "0.75    184.1435\n",
       "Name: download_mbps, dtype: float64"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speeds.download_mbps.quantile([0.25, 0.5, 0.75])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 32]        83683\n",
       "(32, 82]       86822\n",
       "(82, 182]      82808\n",
       "(182, 2000]    85768\n",
       "Name: download_mbps, dtype: int64"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speed_thresh = [0, 32, 82, 182, 2000]\n",
    "pd.cut(speeds.download_mbps, speed_thresh).value_counts().sort_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[522, 304, 224, 414, 721, 460],\n",
       "       [304, 202, 445, 340, 162, 299],\n",
       "       [406, 661, 205,  80, 143, 289],\n",
       "       ...,\n",
       "       [110, 116, 727, 693, 745, 470],\n",
       "       [ 66, 840, 339, 411, 680, 459],\n",
       "       [163, 433, 238, 321, 875, 273]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P_tl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = income_data.shape[0]\n",
    "\n",
    "L = len(br_hh)\n",
    "\n",
    "speed_thresh = [0, 32, 82, 182, 2e3]\n",
    "S = len(speed_thresh) - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speeds.geoid.isin(income_data.index).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate the households per tracts\n",
    "P_t = income_data[br_hh].sum(axis = 1).values\n",
    "\n",
    "# Random numbers...\n",
    "P_tl = income_data[br_hh].values\n",
    "\n",
    "# And the total number of households\n",
    "N = P_t.sum() \n",
    "\n",
    "# And the number of actual devices\n",
    "n_obs = speeds.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "speeds[\"dl_tier\"] = pd.cut(speeds.download_mbps, bins = speed_thresh, labels = [\"Q1\", \"Q2\", \"Q3\", \"Q4\"])\n",
    "\n",
    "speed_tiers_n = speeds.groupby([\"geoid\", \"dl_tier\"]).download_mbps.count().unstack()\n",
    "speed_tiers_n = speed_tiers_n.join(income_data[[]], how = \"outer\").fillna(0).astype(int)\n",
    "real_data = speed_tiers_n.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "thresh = np.array([[0.3, 0.6, 0.9],\n",
    "                   [0.3, 0.6, 0.9],\n",
    "                   [0.3, 0.6, 0.9],\n",
    "                   [0.3, 0.6, 0.9],\n",
    "                   [0.3, 0.6, 0.9],\n",
    "                   [0.3, 0.6, 0.9]\n",
    "                   ])\n",
    "\n",
    "## Assume that these are equal.\n",
    "equal_selection = np.ones(L) * n_obs / N\n",
    "\n",
    "init_variables = np.concatenate([equal_selection, thresh.flatten()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1493613154360406"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_obs / N "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pois_nll(variables = true_variables, data = speed_tiers_n, verbose = False):\n",
    "\n",
    "    # Denoting fitting variables by \"_\"\n",
    "    # Variables are a 1-D aray, so extract the parts...\n",
    "\n",
    "    _d_l = variables[:L]\n",
    "\n",
    "    _p_sl_thresh = variables[L:].reshape(L, -1)\n",
    "    _thresh_bounded = np.concatenate([np.zeros((L, 1)), \n",
    "                                      _p_sl_thresh.reshape(L, -1), \n",
    "                                      np.ones((L, 1))], axis = 1)\n",
    "\n",
    "    # These are the constructed probabilities.\n",
    "    _p_sl  = _thresh_bounded[:,1:] - _thresh_bounded[:,:-1]\n",
    "    \n",
    "\n",
    "    # Selection effect -- how many people will we place in distributions...\n",
    "    _P_tl_obs = P_tl * _d_l\n",
    "    \n",
    "    # Number of observations at speed tiers, by tract.\n",
    "    _P_ts_obs = np.multiply(_P_tl_obs[:,:,np.newaxis], _p_sl[np.newaxis,:,:]).sum(axis = 1)\n",
    "    \n",
    "    # Incorporate bounds penalty: probabilities outside [0, 1]\n",
    "    unitary = np.zeros(variables.shape)\n",
    "    unitary[variables > 1] = +variables[variables > 1] - 1\n",
    "    unitary[variables < 0] = -variables[variables < 0]\n",
    "    \n",
    "    increasing_0 = np.maximum(np.zeros(L), _p_sl_thresh[:,0] - _p_sl_thresh[:,1])\n",
    "    increasing_1 = np.maximum(np.zeros(L), _p_sl_thresh[:,1] - _p_sl_thresh[:,2])\n",
    "    \n",
    "    deviations = np.concatenate([unitary, increasing_0, increasing_1])\n",
    "    \n",
    "    bounds_penalty = 10e8 * np.power(deviations, 2).sum()\n",
    "    \n",
    "    # Just a Poisson...\n",
    "    pmf = poisson.pmf(data, _P_ts_obs)\n",
    "    neglog = -np.log(poisson.pmf(data, _P_ts_obs))\n",
    "    nll = np.nan_to_num(neglog, posinf = 1000).sum()\n",
    "    nll = nll.sum()\n",
    "\n",
    "    if verbose: print(nll, bounds_penalty)\n",
    "        \n",
    "    return nll + bounds_penalty\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98098.06122488333"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pois_nll(init_variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-44-6851dd463cd7>:37: RuntimeWarning: divide by zero encountered in log\n",
      "  neglog = -np.log(poisson.pmf(data, _P_ts_obs))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully    (Exit mode 0)\n",
      "            Current function value: 50745.75751084852\n",
      "            Iterations: 230\n",
      "            Function evaluations: 6524\n",
      "            Gradient evaluations: 230\n",
      "50745.75402703931 0.0034838092098859823\n",
      "50745.75751084852\n",
      "[0.001 0.    0.088 0.002 0.005 0.262]\n",
      "[[0.998 0.999 0.999]\n",
      " [0.    0.168 0.999]\n",
      " [0.656 0.857 0.857]\n",
      " [0.34  0.34  1.   ]\n",
      " [0.    0.001 1.   ]\n",
      " [0.222 0.483 0.738]]\n"
     ]
    }
   ],
   "source": [
    "res = minimize(pois_nll, init_variables, method = \"SLSQP\",\n",
    "               options = {'maxiter' : 20000, 'disp': True})\n",
    "\n",
    "params = res[\"x\"]\n",
    "\n",
    "d_l  = params[:L].round(3)\n",
    "p_sl = params[L:].reshape(L, -1).round(3)\n",
    "\n",
    "print(pois_nll(res[\"x\"], speed_tiers_n, verbose = True))\n",
    "print(d_l)\n",
    "print(p_sl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pois_SLSQP\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-44-6851dd463cd7>:37: RuntimeWarning: divide by zero encountered in log\n",
      "  neglog = -np.log(poisson.pmf(data, _P_ts_obs))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully    (Exit mode 0)\n",
      "            Current function value: 50745.75751084852\n",
      "            Iterations: 230\n",
      "            Function evaluations: 6524\n",
      "            Gradient evaluations: 230\n",
      "pois_Nelder-Mead\n",
      "Optimization terminated successfully.\n",
      "         Current function value: 51653.443805\n",
      "         Iterations: 8176\n",
      "         Function evaluations: 10364\n"
     ]
    }
   ],
   "source": [
    "methods = ['Nelder-Mead', \"Powell\", 'L-BFGS-B', 'TNC', 'SLSQP'] #\n",
    "methods = ['SLSQP', 'Nelder-Mead']\n",
    "\n",
    "# bad = ['COBYLA', 'CG']\n",
    "# need_jac = ['Newton-CG', 'dogleg', 'BFGS', 'trust-ncg', 'trust-exact', 'trust-krylov']\n",
    "\n",
    "llh_fns = {\"pois\" : pois_nll} # , \"mixt\" : mixt_nll}\n",
    "\n",
    "res = {}\n",
    "for llh_label, llh in llh_fns.items():\n",
    "    for method in methods:\n",
    "\n",
    "        label = llh_label + \"_\" + method\n",
    "\n",
    "        print(label)\n",
    "        res[label] = minimize(llh, init_variables, method = method,\n",
    "                              options = {'maxiter' : 20000, 'disp': True})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pois_SLSQP\n",
      "sel: [0.001 0.    0.088 0.002 0.005 0.262]\n",
      "dist:\n",
      "array([[0.998, 0.999, 0.999],\n",
      "       [0.   , 0.168, 0.999],\n",
      "       [0.656, 0.857, 0.857],\n",
      "       [0.34 , 0.34 , 1.   ],\n",
      "       [0.   , 0.001, 1.   ],\n",
      "       [0.222, 0.483, 0.738]])\n",
      "\n",
      "pois_Nelder-Mead\n",
      "sel: [ 0.09   0.097 -0.     0.05   0.032  0.245]\n",
      "dist:\n",
      "array([[0.285, 0.644, 0.729],\n",
      "       [0.753, 0.794, 0.797],\n",
      "       [0.131, 0.522, 0.522],\n",
      "       [0.719, 0.719, 0.747],\n",
      "       [0.74 , 0.911, 0.911],\n",
      "       [0.186, 0.46 , 0.736]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "p_sl_comp = {\"input\" : thresh}\n",
    "d_s_comp  = {\"input\" : equal_selection}\n",
    "\n",
    "for l in llh_fns:\n",
    "    for m in methods:\n",
    "        \n",
    "        lm = l + \"_\" + m\n",
    "\n",
    "        params = res[lm][\"x\"]\n",
    "\n",
    "        d_s_comp[lm]  = params[:L].round(3)\n",
    "        p_sl_comp[lm] = params[L:].reshape(L, -1).round(3)\n",
    "        \n",
    "        print(lm)\n",
    "        print(\"sel:\", d_s_comp[lm])\n",
    "        print(\"dist:\")\n",
    "        pprint(p_sl_comp[lm])\n",
    "        print()\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions / thoughts about selection:\n",
    "\n",
    "* I _think_ that one cannot even identify the fraction _without_ internet (and for whom selection is \"0\").  You could increase or decrease the share of households no-internet, proporitional shrinking or expanding (respectively the share for other bins.  This could be compensated by an \"inverse\" scaling of the selection factors for the yes-internet bins.  That stinks!\n",
    "* However, we can just put in the Census-produced measures of boolean presence of Internet, using B28004_001E and following from [the ACS](https://api.census.gov/data/2019/acs/acs5/variables.html).\n",
    "* Still, the arguments above may not apply if the idiosyncratic errors are correlated for speed and selection.  The reason that the argument is trivially true above, is that you can scale speed bins and *exactly* compensate back with the selection effect.  If the selection probability goes up by (1 + d), and the distribution bin with goes down by 1 / (1 + d), then the product is 1: no effect.  But does that argument hold, if the speed and selection are correlated?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}