item-nonresponse-demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Item Nonresponse Demo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To generate and store data.\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy.stats as stats\n",
    "\n",
    "# To visualize data.\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# To fit linear regression model.\n",
    "from sklearn.linear_model import LinearRegression, LogisticRegression\n",
    "\n",
    "# Install and import missingno to visualize missingness patterns. (Uncomment first line to install missingno.)\n",
    "!pip install missingno\n",
    "import missingno as msno\n",
    "\n",
    "# # There is a SciPy issue that won't affect our work, but a warning exists\n",
    "# # and an update is not imminent.\n",
    "import warnings\n",
    "warnings.filterwarnings(action=\"ignore\")\n",
    "\n",
    "# To render plots in the notebook.\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's generate some data. Specifically, we'll generate age, partnered, children, and income data, where income is linearly related to age, partnered, and children."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To ensure we get the same results.\n",
    "np.random.seed(42)\n",
    "\n",
    "# Generate data.\n",
    "age = np.round(np.random.uniform(20, 60, size = 100))\n",
    "partnered = np.random.binomial(1, 0.8, size = 100)\n",
    "children = np.random.poisson(2, size = 100)\n",
    "income = 15000 + 750 * age + 20000 * partnered - 2500 * children + np.random.normal(0, 20000, size = 100)\n",
    "\n",
    "# Ensure income is not negative!\n",
    "income = [i if i >= 0 else 0 for i in income]\n",
    "\n",
    "# Combine our results into one dataframe.\n",
    "df = pd.DataFrame({'age': age,\n",
    "                   'partnered': partnered,\n",
    "                   'children': children,\n",
    "                   'income': income})\n",
    "\n",
    "# Check the first five rows of df to make sure we did this properly.\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run this cell. These are functions that will generate missing values according to MCAR, MAR, or NMAR."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_mcar_column(df, missing_column = 'income', p_missing = 0.01, random_state = 42):\n",
    "    \"\"\"\n",
    "    Creates missingness indicator column, where data are MCAR (missing completely at random).\n",
    "    \n",
    "    User must specify:\n",
    "        df = the pandas DataFrame the user wants to read in for analysis\n",
    "        column = the name of the column in df that is missing\n",
    "        p_missing = the proportion of observations that are missing\n",
    "        \n",
    "    Function returns:\n",
    "        mcar_column = a column that indicates whether data are missing, assuming MCAR\n",
    "    \"\"\"\n",
    "    np.random.seed(random_state)\n",
    "    \n",
    "    mcar_indices = [df.sample(n = 1).index[0] for i in range(round(p_missing * df.shape[0]))]\n",
    "    \n",
    "    while len(set(mcar_indices)) < round(p_missing * df.shape[0]):\n",
    "        mcar_indices.append(df.sample(n = 1).index[0])\n",
    "    \n",
    "    mcar_column = [1 if i in mcar_indices else 0 for i in range(df.shape[0])]\n",
    "    \n",
    "    return mcar_column\n",
    "\n",
    "def create_mar_column(df, missing_column = 'income', depends_on = 'age', method = 'linear', p_missing = 0.01, random_state = 42):\n",
    "    \"\"\"\n",
    "    Creates missingness indicator column, where data are MAR (missing at random).\n",
    "    \n",
    "    User must specify:\n",
    "        df = the pandas DataFrame the user wants to read in for analysis\n",
    "        missing_column = the name of the column in df that is missing\n",
    "        depends_on = the name of the column in df which affects the missingness\n",
    "        method = 'linear' or 'quadratic'\n",
    "            - 'linear' means the probability of missingness is linearly related to the depends_on variable\n",
    "            - 'quadratic' means the probability of missingness is quadratically related to the depends_on variable\n",
    "        p_missing = the proportion of observations that are missing\n",
    "        \n",
    "    Function returns:\n",
    "        mar_column = a column that indicates whether data are missing, assuming MAR\n",
    "    \"\"\"\n",
    "    np.random.seed(random_state)\n",
    "    \n",
    "    if method == 'linear':\n",
    "        mar_indices = [df.sample(n = 1, weights = depends_on).index[0] for i in range(round(p_missing * df.shape[0]))]\n",
    "\n",
    "        while len(set(mar_indices)) < round(p_missing * df.shape[0]):\n",
    "            mar_indices.append(df.sample(n = 1, weights = depends_on).index[0])\n",
    "    \n",
    "    elif method == 'quadratic':\n",
    "        mar_indices = [df.sample(n = 1, weights = df[depends_on] ** 2).index[0] for i in range(round(p_missing * df.shape[0]))]\n",
    "\n",
    "        while len(set(mar_indices)) < round(p_missing * df.shape[0]):\n",
    "            mar_indices.append(df.sample(n = 1, weights = df[depends_on] ** 2).index[0])\n",
    "\n",
    "    mar_column = [1 if i in mar_indices else 0 for i in range(df.shape[0])]\n",
    "        \n",
    "    return mar_column\n",
    "\n",
    "def create_nmar_column(df, missing_column = 'income', method = 'linear', p_missing = 0.01, random_state = 42):\n",
    "    \"\"\"\n",
    "    Creates missingness indicator column, where data are NMAR (not missing at random).\n",
    "    \n",
    "    User must specify:\n",
    "        df = the pandas DataFrame the user wants to read in for analysis\n",
    "        missing_column = the name of the column in df that is missing\n",
    "        method = 'linear' or 'quadratic'\n",
    "            - 'linear' means the probability of missingness is linearly related to the depends_on variable\n",
    "            - 'quadratic' means the probability of missingness is quadratically related to the depends_on variable\n",
    "        p_missing = the proportion of observations that are missing\n",
    "        \n",
    "    Function returns:\n",
    "        nmar_column = a column that indicates whether data are missing, assuming NMAR\n",
    "    \"\"\"\n",
    "    np.random.seed(random_state)\n",
    "    \n",
    "    if method == 'linear':\n",
    "        nmar_indices = [df.sample(n = 1, weights = missing_column).index[0] for i in range(round(p_missing * df.shape[0]))]\n",
    "\n",
    "        while len(set(nmar_indices)) < round(p_missing * df.shape[0]):\n",
    "            nmar_indices.append(df.sample(n = 1, weights = missing_column).index[0])\n",
    "    \n",
    "    elif method == 'quadratic':\n",
    "        nmar_indices = [df.sample(n = 1, weights = df[missing_column] ** 2).index[0] for i in range(round(p_missing * df.shape[0]))]\n",
    "\n",
    "        while len(set(nmar_indices)) < round(p_missing * df.shape[0]):\n",
    "            nmar_indices.append(df.sample(n = 1, weights = df[missing_column] ** 2).index[0])\n",
    "            \n",
    "    nmar_column = [1 if i in nmar_indices else 0 for i in range(df.shape[0])]\n",
    "    \n",
    "    return nmar_column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's generate some missing data!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['age_missingness'] = create_mcar_column(df,\n",
    "                                           missing_column = 'age',                                           \n",
    "                                           p_missing = 0.3,\n",
    "                                           random_state = 42)\n",
    "\n",
    "df['partnered_missingness'] = create_mar_column(df,\n",
    "                                                missing_column = 'partnered',\n",
    "                                                method = 'linear',\n",
    "                                                p_missing = 0.2,\n",
    "                                                random_state = 42)\n",
    "\n",
    "df['income_missingness'] = create_nmar_column(df,\n",
    "                                              missing_column = 'income',\n",
    "                                              method = 'quadratic',\n",
    "                                              p_missing = 0.2,\n",
    "                                              random_state = 42)\n",
    "\n",
    "print(df['age_missingness'].value_counts())\n",
    "print(df['partnered_missingness'].value_counts())\n",
    "print(df['income_missingness'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's create a new dataframe with the values actually missing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_missing = pd.DataFrame(df['children'])\n",
    "\n",
    "df_missing['age'] = [df.loc[i,'age'] if df.loc[i,'age_missingness'] == 0 else np.nan for i in range(100)]\n",
    "df_missing['partnered'] = [df.loc[i,'partnered'] if df.loc[i,'partnered_missingness'] == 0 else np.nan for i in range(100)]\n",
    "df_missing['income'] = [df.loc[i,'income'] if df.loc[i,'income_missingness'] == 0 else np.nan for i in range(100)]\n",
    "\n",
    "df_missing.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's visualize our missing data.\n",
    "- Children is 100% observed.\n",
    "- Age is missing completely at random and is missing 30% of its observations.\n",
    "- Partnered is missing at random and is missing 20% of its observations.\n",
    "- Income is missing at random and is missing 20% of its observations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "msno.matrix(df_missing);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "msno.heatmap(df_missing);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "msno.dendrogram(df_missing);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate histograms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare_histograms(df, imputed_column, original_column, missingness_column, x_label, y_label = 'Frequency'):\n",
    "    fig, (ax0, ax1) = plt.subplots(nrows = 2, ncols = 1, figsize = (16,9))\n",
    "\n",
    "    # Set axes of histograms.\n",
    "    mode = stats.mode(df[imputed_column])\n",
    "    rnge = max(df[original_column]) - min(df[original_column])\n",
    "    xmin = min(df[original_column]) - 0.02 * rnge\n",
    "    xmax = max(df[original_column]) + 0.02 * rnge\n",
    "    ymax = 1.3 * (mode[1][0] + df[df[original_column] == mode[0][0]].shape[0])\n",
    "\n",
    "    ax0.set_xlim(xmin, xmax)\n",
    "    ax0.set_ylim(0, ymax)\n",
    "    ax1.set_xlim(xmin, xmax)\n",
    "    ax1.set_ylim(0, ymax)\n",
    "\n",
    "    # Set top labels.\n",
    "    ax0.set_title('Real Histogram', position = (0,1), ha = 'left', fontsize = 25)\n",
    "    ax0.set_xlabel(x_label, position = (0,0), ha = 'left', fontsize = 25, color = 'grey', alpha = 0.85)\n",
    "    ax0.set_ylabel(y_label, position = (0,1), ha = 'right', va = 'top', fontsize = 25, rotation = 0, color = 'grey', alpha = 0.85)\n",
    "    ax0.set_xticks([])\n",
    "    ax0.set_yticks([])\n",
    "\n",
    "    # Generate top histogram.\n",
    "    ax0.hist(df[original_column], bins = 15, color = '#185fad', alpha = 0.75, label = '')\n",
    "    ax0.axvline(np.mean(df[original_column]), color = '#185fad', lw = 5, label = 'True Mean')\n",
    "    ax0.legend(prop={'size': 15}, loc = 1)\n",
    "\n",
    "    # Set bottom labels.\n",
    "    ax1.set_title('Observed + Imputed Histogram', position = (0,1), ha = 'left', fontsize = 25)\n",
    "    ax1.set_xlabel(x_label, position = (0,0), ha = 'left', fontsize = 25, color = 'grey', alpha = 0.85)\n",
    "    ax1.set_ylabel(y_label, position = (0,1), ha = 'right', va = 'top', fontsize = 25, rotation = 0, color = 'grey', alpha = 0.85)\n",
    "\n",
    "    # Generate bottom histogram.\n",
    "    ax1.hist([df[imputed_column][df[missingness_column] == 0], df[imputed_column][df[missingness_column] == 1]], bins = 15, color = ['#185fad','orange'], alpha = 0.75, label = '', stacked = True)\n",
    "    ax1.axvline(np.mean(df[original_column]), color = '#185fad', lw = 5, label = 'True Mean')\n",
    "    ax1.axvline(np.mean(df[original_column][df[missingness_column] == 0]), color = 'grey', alpha = 0.5, lw = 5, label = 'Observed Mean')\n",
    "    ax1.axvline(np.mean(df[imputed_column]), color = 'orange', lw = 5, label = 'Observed and Imputed Mean')\n",
    "    ax1.legend(prop={'size': 15}, loc = 1)\n",
    "\n",
    "    plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examine various imputation methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Mean Imputation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def impute_mean(df, impute_column, missingness_column):\n",
    "    \"\"\"\n",
    "    Imputes mean for any value where data is marked missing.\n",
    "    \n",
    "    User must specify:\n",
    "        df = the pandas DataFrame the user wants to read in for analysis\n",
    "        impute_column = the name of the column in df that is missing\n",
    "        missingness_column = the name of the missingness indicator column\n",
    "        \n",
    "    Function returns:\n",
    "        mean_impute = a column with the mean imputed for any missing value.\n",
    "    \"\"\"\n",
    "    mean_impute = [df.loc[i,impute_column] if df.loc[i,missingness_column] == 0 else np.mean(df[impute_column]) for i in range(df.shape[0])]\n",
    "    \n",
    "    return mean_impute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['age_mean_imputed'] = impute_mean(df, 'age', 'age_missingness')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compare_histograms(df = df,\n",
    "                   imputed_column = 'age_mean_imputed',\n",
    "                   original_column = 'age',\n",
    "                   missingness_column = 'age_missingness',\n",
    "                   x_label = 'Age',\n",
    "                   y_label = 'Frequency')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How to read the above chart:\n",
    "- The blue line is the true mean of all data (observed and unobserved).\n",
    "- The grey line is the mean of just the observed data. (i.e. no imputation)\n",
    "- The orange line is the mean of the observed and imputed data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{eqnarray*}\n",
    "s &=& \\sqrt{\\frac{\\sum_{i=1}^n(x_i - \\bar{x})^2}{n-1}} \\\\\n",
    "\\text{impute mean for values } k+1 \\text{ through } n \\Rightarrow s &=& \\sqrt{\\frac{\\sum_{i=1}^k(x_i - \\bar{x})^2}{n-1} + \\frac{\\sum_{i=k+1}^n(\\bar{x} - \\bar{x})^2}{n-1}} \\\\\n",
    "&=& \\sqrt{\\frac{\\sum_{i=1}^k(x_i - \\bar{x})^2}{n-1}} \\\\\n",
    "&\\Rightarrow& \\text{the denominator increases but numerator remains fixed} \\\\\n",
    "&\\Rightarrow& \\text{the sample standard deviation is underestimated} \\\\\n",
    "&\\Rightarrow& \\text{confidence intervals relying on the mean are narrower than they should be}\n",
    "\\end{eqnarray*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Median Imputation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def impute_median(df, impute_column, missingness_column):\n",
    "    \"\"\"\n",
    "    Imputes median for any value where data is marked missing.\n",
    "    \n",
    "    User must specify:\n",
    "        df = the pandas DataFrame the user wants to read in for analysis\n",
    "        impute_column = the name of the column in df that is missing\n",
    "        missingness_column = the name of the missingness indicator column\n",
    "        \n",
    "    Function returns:\n",
    "        median_impute = a column with the median imputed for any missing value.\n",
    "    \"\"\"\n",
    "    median_impute = [df.loc[i,impute_column] if df.loc[i,missingness_column] == 0 else np.median(df[impute_column]) for i in range(df.shape[0])]\n",
    "    \n",
    "    return median_impute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['age_median_imputed'] = impute_median(df, 'age', 'age_missingness')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compare_histograms(df = df,\n",
    "                   imputed_column = 'age_median_imputed',\n",
    "                   original_column = 'age',\n",
    "                   missingness_column = 'age_missingness',\n",
    "                   x_label = 'Age',\n",
    "                   y_label = 'Frequency')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Mode Imputation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def impute_mode(df, impute_column, missingness_column):\n",
    "    \"\"\"\n",
    "    Imputes mode for any value where data is marked missing.\n",
    "    \n",
    "    User must specify:\n",
    "        df = the pandas DataFrame the user wants to read in for analysis\n",
    "        impute_column = the name of the column in df that is missing\n",
    "        missingness_column = the name of the missingness indicator column\n",
    "        \n",
    "    Function returns:\n",
    "        mode_impute = a column with the mode imputed for any missing value.\n",
    "    \"\"\"\n",
    "    mode_impute = [df.loc[i,impute_column] if df.loc[i,missingness_column] == 0 else stats.mode(df[impute_column])[0][0] for i in range(df.shape[0])]\n",
    "    \n",
    "    return mode_impute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['age_mode_imputed'] = impute_mode(df, 'age', 'age_missingness')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compare_histograms(df = df,\n",
    "                   imputed_column = 'age_mode_imputed',\n",
    "                   original_column = 'age',\n",
    "                   missingness_column = 'age_missingness',\n",
    "                   x_label = 'Age',\n",
    "                   y_label = 'Frequency')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Regression Imputation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def regression_imputation(df, impute_column, X_columns, missingness_column, regression = 'linear'):\n",
    "    \"\"\"\n",
    "    Fits regression line to observed data, then imputes regression prediction\n",
    "    for any value where data is marked missing.\n",
    "    \n",
    "    User must specify:\n",
    "        df = the pandas DataFrame the user wants to read in for analysis\n",
    "        impute_column = the name of the column in df that is missing\n",
    "        X_columns = the names of the columns used as independent variables\n",
    "                    to impute the missing value\n",
    "        missingness_column = the name of the missingness indicator column\n",
    "        regression = the type of regression to run; only supports 'linear'\n",
    "                     for LinearRegression and 'logistic' for LogisticRegression\n",
    "        \n",
    "    Function returns:\n",
    "        regression_impute = a column with the regression value imputed for any missing value.\n",
    "        \n",
    "    NOTE: Only set up to do linear or logistic regression.\n",
    "    \"\"\"\n",
    "    \n",
    "    if regression == 'linear':\n",
    "        model = LinearRegression()\n",
    "    elif regression == 'logistic':\n",
    "        model = LogisticRegression()\n",
    "    \n",
    "    model.fit(df[X_columns], df[impute_column])\n",
    "    \n",
    "    regression_impute = [df.loc[i,'age'] if df.loc[i,'age_missingness'] == 0\n",
    "                         else model.predict(pd.DataFrame(df.loc[i,['children', 'partnered', 'income']]).T)[0] \n",
    "                         for i in range(df.shape[0])]\n",
    "    \n",
    "    return regression_impute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['age_regression_imputed'] = regression_imputation(df, 'age', ['children', 'partnered', 'income'], 'age_missingness')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compare_histograms(df = df,\n",
    "                   imputed_column = 'age_regression_imputed',\n",
    "                   original_column = 'age',\n",
    "                   missingness_column = 'age_missingness',\n",
    "                   x_label = 'Age',\n",
    "                   y_label = 'Frequency')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.std(df['age_regression_imputed'], ddof = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.std(df['age'], ddof = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Work in progress:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare_scatterplots(df, imputed_column, original_X_column, original_Y_column, missingness_column, x_label, y_label):\n",
    "    fig, (ax0, ax1) = plt.subplots(nrows = 1, ncols = 2, figsize = (20,8))\n",
    "\n",
    "    # Set axes of scatterplots.\n",
    "    x_rnge = max(df[original_X_column]) - min(df[original_X_column])\n",
    "    xmin = min(df[original_X_column]) - 0.02 * x_rnge\n",
    "    xmax = max(df[original_X_column]) + 0.02 * x_rnge\n",
    "    y_rnge = max(df[original_Y_column]) - min(df[original_Y_column])\n",
    "    ymin = min(df[original_Y_column]) - 0.02 * y_rnge\n",
    "    ymax = max(df[original_Y_column]) + 0.02 * y_rnge\n",
    "\n",
    "    ax0.set_xlim(xmin, xmax)\n",
    "    ax0.set_ylim(ymin, ymax)\n",
    "    ax1.set_xlim(xmin, xmax)\n",
    "    ax1.set_ylim(ymin, ymax)\n",
    "\n",
    "    # Set left labels.\n",
    "    ax0.set_title('Real Scatterplot', position = (0,1), ha = 'left', fontsize = 25)\n",
    "    ax0.set_xlabel(x_label, position = (0,0), ha = 'left', fontsize = 25, color = 'grey', alpha = 0.85)\n",
    "    ax0.set_ylabel(y_label, position = (0,1), ha = 'right', va = 'top', fontsize = 25, rotation = 0, color = 'grey', alpha = 0.85)\n",
    "    ax0.set_xticks([])\n",
    "    ax0.set_yticks([])\n",
    "\n",
    "    # Generate left scatterplot.\n",
    "    ax0.scatter(df[original_X_column], df[original_Y_column], color = '#185fad', alpha = 0.75, label = '')\n",
    "    ax0.legend(prop={'size': 15}, loc = 1)\n",
    "    \n",
    "    # Set right labels.\n",
    "    ax1.set_title('Observed + Imputed Scatterplot', position = (0,1), ha = 'left', fontsize = 25)\n",
    "    ax1.set_xlabel(x_label, position = (0,0), ha = 'left', fontsize = 25, color = 'grey', alpha = 0.85)\n",
    "    ax1.set_ylabel(y_label, position = (0,1), ha = 'right', va = 'top', fontsize = 25, rotation = 0, color = 'grey', alpha = 0.85)\n",
    "\n",
    "    # Generate right histogram.\n",
    "    ax1.scatter(df[original_Y_column][df[missingness_column] == 1], df[imputed_column][df[missingness_column] == 1], color = 'orange', alpha = 0.75, label = 'Imputed Values')\n",
    "    ax1.scatter(df[original_X_column][df[missingness_column] == 0], df[imputed_column][df[missingness_column] == 0], color = '#185fad', alpha = 0.75, label = 'Observed Values')\n",
    "\n",
    "    ax1.legend(prop={'size': 15}, loc = 1)\n",
    "    \n",
    "    plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compare_scatterplots(df = df,\n",
    "                     imputed_column = 'age_regression_imputed',\n",
    "                     original_X_column = 'children',\n",
    "                     original_Y_column = 'age',\n",
    "                     missingness_column = 'age_missingness',\n",
    "                     x_label = 'Children',\n",
    "                     y_label = 'Age')"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}