ch02-missing-data-imputation/Recipe-09-Performing-multivariate-imputation-by-chained-equations-MICE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performing multivariate imputation with MICE, KNN or Random Forests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import BayesianRidge\n",
    "\n",
    "from sklearn.experimental import enable_iterative_imputer\n",
    "from sklearn.impute import IterativeImputer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>A2</th>\n",
       "      <th>A3</th>\n",
       "      <th>A8</th>\n",
       "      <th>A11</th>\n",
       "      <th>A14</th>\n",
       "      <th>A15</th>\n",
       "      <th>A16</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>30.83</td>\n",
       "      <td>0.000</td>\n",
       "      <td>1.25</td>\n",
       "      <td>1</td>\n",
       "      <td>202.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>58.67</td>\n",
       "      <td>4.460</td>\n",
       "      <td>3.04</td>\n",
       "      <td>6</td>\n",
       "      <td>43.0</td>\n",
       "      <td>560</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>24.50</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>280.0</td>\n",
       "      <td>824</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>27.83</td>\n",
       "      <td>1.540</td>\n",
       "      <td>3.75</td>\n",
       "      <td>5</td>\n",
       "      <td>100.0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>20.17</td>\n",
       "      <td>5.625</td>\n",
       "      <td>1.71</td>\n",
       "      <td>0</td>\n",
       "      <td>120.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      A2     A3    A8  A11    A14  A15  A16\n",
       "0  30.83  0.000  1.25    1  202.0    0    1\n",
       "1  58.67  4.460  3.04    6   43.0  560    1\n",
       "2  24.50    NaN   NaN    0  280.0  824    1\n",
       "3  27.83  1.540  3.75    5  100.0    3    1\n",
       "4  20.17  5.625  1.71    0  120.0    0    1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load data with numerical variables\n",
    "\n",
    "variables = ['A2','A3','A8', 'A11', 'A14', 'A15', 'A16']\n",
    "\n",
    "data = pd.read_csv('creditApprovalUCI.csv', usecols=variables)\n",
    "\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((483, 6), (207, 6))"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's separate into training and testing set\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    data.drop('A16', axis=1), data['A16'], test_size=0.3, random_state=0)\n",
    "\n",
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A2     0.022774\n",
       "A3     0.140787\n",
       "A8     0.140787\n",
       "A11    0.000000\n",
       "A14    0.014493\n",
       "A15    0.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find the percentage of missing data within those variables\n",
    "\n",
    "X_train.isnull().mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's create a MICE imputer using Bayes as estimator\n",
    "imputer = IterativeImputer(estimator= BayesianRidge(),\n",
    "                           max_iter=10, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IterativeImputer(add_indicator=False,\n",
       "                 estimator=BayesianRidge(alpha_1=1e-06, alpha_2=1e-06,\n",
       "                                         alpha_init=None, compute_score=False,\n",
       "                                         copy_X=True, fit_intercept=True,\n",
       "                                         lambda_1=1e-06, lambda_2=1e-06,\n",
       "                                         lambda_init=None, n_iter=300,\n",
       "                                         normalize=False, tol=0.001,\n",
       "                                         verbose=False),\n",
       "                 imputation_order='ascending', initial_strategy='mean',\n",
       "                 max_iter=10, max_value=None, min_value=None,\n",
       "                 missing_values=nan, n_nearest_features=None, random_state=0,\n",
       "                 sample_posterior=False, skip_complete=False, tol=0.001,\n",
       "                 verbose=0)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imputer.fit(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform the data - replace the missing values\n",
    "\n",
    "X_train = imputer.transform(X_train)\n",
    "X_test = imputer.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0\n",
       "1    0\n",
       "2    0\n",
       "3    0\n",
       "4    0\n",
       "5    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(X_train).isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import BayesianRidge\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import ExtraTreesRegressor\n",
    "from sklearn.neighbors import KNeighborsRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((483, 6), (207, 6))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    data.drop('A16', axis=1), data['A16'], test_size=0.3, random_state=0)\n",
    "\n",
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "imputer_bayes = IterativeImputer(estimator=BayesianRidge(),\n",
    "                                 max_iter=10,\n",
    "                                 random_state=0)\n",
    "\n",
    "imputer_knn = IterativeImputer(estimator=KNeighborsRegressor(n_neighbors=5),\n",
    "                                 max_iter=10,\n",
    "                                 random_state=0)\n",
    "\n",
    "imputer_nonLin = IterativeImputer(estimator=DecisionTreeRegressor(max_features='sqrt', random_state=0),\n",
    "                                 max_iter=10,\n",
    "                                 random_state=0)\n",
    "\n",
    "imputer_missForest = IterativeImputer(estimator=ExtraTreesRegressor(n_estimators=10, random_state=0),\n",
    "                                 max_iter=10,\n",
    "                                 random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sole\\Anaconda3\\envs\\feml\\lib\\site-packages\\sklearn\\impute\\_iterative.py:638: ConvergenceWarning: [IterativeImputer] Early stopping criterion not reached.\n",
      "  \" reached.\", ConvergenceWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "IterativeImputer(add_indicator=False,\n",
       "                 estimator=ExtraTreesRegressor(bootstrap=False, ccp_alpha=0.0,\n",
       "                                               criterion='mse', max_depth=None,\n",
       "                                               max_features='auto',\n",
       "                                               max_leaf_nodes=None,\n",
       "                                               max_samples=None,\n",
       "                                               min_impurity_decrease=0.0,\n",
       "                                               min_impurity_split=None,\n",
       "                                               min_samples_leaf=1,\n",
       "                                               min_samples_split=2,\n",
       "                                               min_weight_fraction_leaf=0.0,\n",
       "                                               n_estimators=10, n_jobs=None,\n",
       "                                               oob_score=False, random_state=0,\n",
       "                                               verbose=0, warm_start=False),\n",
       "                 imputation_order='ascending', initial_strategy='mean',\n",
       "                 max_iter=10, max_value=None, min_value=None,\n",
       "                 missing_values=nan, n_nearest_features=None, random_state=0,\n",
       "                 sample_posterior=False, skip_complete=False, tol=0.001,\n",
       "                 verbose=0)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imputer_bayes.fit(X_train)\n",
    "imputer_knn.fit(X_train)\n",
    "imputer_nonLin.fit(X_train)\n",
    "imputer_missForest.fit(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_bayes = imputer_bayes.transform(X_train)\n",
    "X_train_knn = imputer_knn.transform(X_train)\n",
    "X_train_nonLin = imputer_nonLin.transform(X_train)\n",
    "X_train_missForest = imputer_missForest.transform(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictors = [var for var in variables if var !='A16']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_bayes = pd.DataFrame(X_train_bayes, columns = predictors)\n",
    "X_train_knn = pd.DataFrame(X_train_knn, columns = predictors)\n",
    "X_train_nonLin = pd.DataFrame(X_train_nonLin, columns = predictors)\n",
    "X_train_missForest = pd.DataFrame(X_train_missForest, columns = predictors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "X_train['A3'].plot(kind='kde', ax=ax, color='blue')\n",
    "X_train_bayes['A3'].plot(kind='kde', ax=ax, color='green')\n",
    "X_train_knn['A3'].plot(kind='kde', ax=ax, color='red')\n",
    "X_train_nonLin['A3'].plot(kind='kde', ax=ax, color='black')\n",
    "X_train_missForest['A3'].plot(kind='kde', ax=ax, color='orange')\n",
    "\n",
    "# add legends\n",
    "lines, labels = ax.get_legend_handles_labels()\n",
    "labels = ['A3 original', 'A3 bayes', 'A3 knn', 'A3 Trees', 'A3 missForest']\n",
    "ax.legend(lines, labels, loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "feml",
   "language": "python",
   "name": "feml"
  },
  "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.7.3"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}