ch10_linear_regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch. 10: Linear Regression\n",
    "\n",
    "Topics to cover:\n",
    "\n",
    "1. Interpretation\n",
    "2. Frisch-Waugh Theorem\n",
    "3. Role that variance has on Linear Regression\n",
    "4. Linear Probability Models\n",
    "5. Including unnecessary controls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "from matplotlib.pyplot import cm\n",
    "import matplotlib.colors as colors\n",
    "from numpy import linalg as LA\n",
    "from scipy.linalg import svdvals\n",
    "from scipy import stats\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import statsmodels.api as sm\n",
    "\n",
    "# set plotting parameters from the beginning\n",
    "font = {'family' : 'monospace',\n",
    "        'weight' : 'normal',\n",
    "        'size'   : 14}\n",
    "axes = {\n",
    "        'titlesize' : 22,\n",
    "        'labelsize' : 20}\n",
    "figure = {'figsize':(10,4),\n",
    "         'autolayout':True}\n",
    "matplotlib.rc('font', **font)\n",
    "matplotlib.rc('axes', **axes)\n",
    "matplotlib.rc('figure', **figure)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Interpretation\n",
    "\n",
    "* Show that $\\alpha_1 = \\frac{Cov(x_1,y)}{Var(x_1)}$ in a one feature world\n",
    "* Show that $\\alpha_k = \\frac{Cov(\\tilde{x}_k,y)}{Var(\\tilde{x}_k)}$ in a several feature world\n",
    "\n",
    "where $\\tilde{x}_k$  are the residuals of a linear regression of $x_k$ on all other features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_xmatrix_rho(nobs, nfeats, rho, seed):\n",
    "    \"\"\"\n",
    "    Simulate a feature matrix with normally distributed features\n",
    "    \"\"\"\n",
    "    np.random.seed(seed)\n",
    "    # first step: construct the vcv with unit variances and rho elsewhere\n",
    "    pre_vcv = np.array([[rho]*nfeats]*nfeats)\n",
    "    iden_mtx = np.eye(nfeats)\n",
    "    vcv = iden_mtx + (1-iden_mtx)*pre_vcv\n",
    "    # second step: draw from \n",
    "    mu = [0]*nfeats\n",
    "    Xdf = pd.DataFrame(np.random.multivariate_normal(mean = mu, cov = vcv, size=nobs), \n",
    "                      columns = [f'x{i+1}' for i in range(nfeats)])\n",
    "    return Xdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_normal_linear_model(alpha, vcv_x, var_epsilon, seed, nobs, rho = None):\n",
    "    \"\"\"\n",
    "    Function to simulate a linear model with normally distributed errors\n",
    "    Inputs:\n",
    "        alpha: array with K user-provided coefficients (includes intercept)\n",
    "        vcv_x: array of dimension (K-1)x (K-1) covariance matrix for X.  Must be positive definite\n",
    "        var_epsilon: variance for normal errors\n",
    "        seed: random seed\n",
    "        nobs: number of observations in the sample\n",
    "        rho: if None --> vcv_x is passed by the user\n",
    "            Otherwise VCV(rho) and overrides what the user passes\n",
    "    output: y,X\n",
    "    \"\"\"\n",
    "    np.random.seed(seed)\n",
    "    K = len(alpha)\n",
    "    alpha = np.array(alpha).reshape((K,1))   # make it a column vector\n",
    "    # simulate K-1 normal random: all mean zero (means go to the intercept so it doesn't matter)\n",
    "    mu = np.array([0]*(K-1)).reshape((K-1,1))\n",
    "    if rho is None:\n",
    "        prex = np.random.multivariate_normal(mean=mu.flatten(), cov=vcv_x, size=nobs)\n",
    "    else:\n",
    "        nfeats= len(mu)\n",
    "        prex = simulate_xmatrix_rho(nobs=nobs, nfeats=nfeats, rho=rho, seed=seed)\n",
    "    ones = np.array([1]*nobs).reshape((nobs,1))  \n",
    "    X = np.concatenate((ones, prex), axis=1) # include first the column for the intercept\n",
    "    col_labels = [f'x{num}' for num in range(K)]\n",
    "    xdf = pd.DataFrame(X, columns = col_labels)\n",
    "    epsilon = np.sqrt(var_epsilon)*np.random.randn(nobs,1)\n",
    "    y = np.dot(X, alpha) + epsilon\n",
    "    ydf = pd.DataFrame(y, columns = ['y'])\n",
    "    return ydf, xdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def percentile(n):\n",
    "    \"\"\"\n",
    "    Percentile function to pass to Pandas agg method\n",
    "    Taken from: https://stackoverflow.com/questions/17578115/pass-percentiles-to-pandas-agg-function\n",
    "        Note that top answer doesn't work well to handle multiple columns so I used a proposed fix in\n",
    "        the thread (Thomas) that uses Pandas quantile method that works on any series\n",
    "    \"\"\"\n",
    "    def percentile_(x):\n",
    "        return x.quantile(n)\n",
    "    percentile_.__name__ = 'percentile_{:2.0f}'.format(n*100)\n",
    "    return percentile_\n",
    "\n",
    "def create_means_bounds_mc(df, qmin = 0.05, qmax = 0.95):\n",
    "    \"\"\"\n",
    "    Helper function to get the means and bounds for the plot_conf_intervals method\n",
    "    df: dataframe with the results from the MonteCarlo simulation\n",
    "    qmin, qmax: quantiles to create the CI (default is 90% CI)\n",
    "    \"\"\"\n",
    "    df_agg = df.agg([np.mean, percentile(qmin), percentile(qmax)])\n",
    "    return df_agg\n",
    "\n",
    "def plot_conf_intervals(means, bounds, var_labels, ax, true_params = None, plot_bars = True):\n",
    "    \"\"\"\n",
    "    Plot standard confidence intervals.  Box plots do the job, but this is more general function\n",
    "        means: array: has the means to be plotted (could be estimated parameters)\n",
    "        bounds: array: lower and upper bounds for the CI (size: 2 x number of columns)\n",
    "        var_labels: \n",
    "        ax: axis object to create the plot\n",
    "        true_params: array with true parameters if I want to plot them along (default: None)\n",
    "        plot_bars: Boolean: if True: plot the bars, False: just plot the CI and means as marker\n",
    "            Bars may unnecessarily clutter the plot (see first example below)\n",
    "    Output:\n",
    "        axis object with the plot\n",
    "    \"\"\"\n",
    "    # check dimensions first\n",
    "    if len(means)!=bounds.shape[1] or len(var_labels)!=len(means):\n",
    "        raise ValueError(\"You must pass the same number of variables for means and bounds\")\n",
    "    # plot means as bars, confidence intervals as lines\n",
    "    n_bars = len(means)\n",
    "    width = 0.5\n",
    "    G = 0.2*width # parameter to control the width of the CI\n",
    "    if plot_bars:\n",
    "        ax.bar(range(n_bars), means, color ='0.75', edgecolor = 'k', width = width, alpha = 0.5, \n",
    "              label='means')\n",
    "    else:\n",
    "        #x_scatter = [i-G*0.5 for i in range(n_bars)]\n",
    "        #ax.scatter(x_scatter, means, color = '0.5', edgecolor = 'k', marker = '.', s = 30, \n",
    "        #      label='means')\n",
    "        for i in range(n_bars):\n",
    "            if i==0:\n",
    "                ax.plot([i-G*0.5, i+G*0.5], [means[i], means[i]], color='k',ls='--', label='means')\n",
    "            else:\n",
    "                ax.plot([i-G*0.5, i+G*0.5], [means[i], means[i]], color='k',ls='--')\n",
    "                \n",
    "    for i in range(n_bars):\n",
    "        ymin_i, ymax_i = bounds[:,i]\n",
    "        if i==0:\n",
    "            ax.plot([i, i], [ymin_i, ymax_i], color ='k', alpha = 1, label='CI')\n",
    "        else:\n",
    "            ax.plot([i, i], [ymin_i, ymax_i], color ='k', alpha = 1)\n",
    "        ax.plot([i-G, i+G], [ymin_i, ymin_i], color ='k', alpha = 1, lw = 1)\n",
    "        ax.plot([i-G, i+G], [ymax_i, ymax_i], color ='k', alpha = 1, lw = 1)\n",
    "    # pass labels\n",
    "    ax.set_xticks(range(n_bars))\n",
    "    ax.set_xticklabels(var_labels)\n",
    "    # plot true parameters\n",
    "    if true_params is not None:\n",
    "        x_scatter_p = [i+G*0.5 for i in range(n_bars)]  # to improve visibility\n",
    "        ax.scatter(x_scatter_p, true_params, marker = 's', color = 'k', s=30,\n",
    "              label='true')\n",
    "        \n",
    "    xmin, xmax = ax.get_xlim()\n",
    "    ax.plot([xmin, xmax], [0, 0], ls = '--', color = '0.2')\n",
    "    ax.set_xlim([xmin, xmax]) # just to make the plot nicer: enforce plot's width\n",
    "    ax.legend()\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x0    0.000000\n",
       "x1    2.805773\n",
       "dtype: float64"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# only one feature\n",
    "alpha = [2, 3.5]\n",
    "var_x = [3]\n",
    "vcv_x = np.diag(var_x)\n",
    "var_epsilon = 1\n",
    "seed = 25431\n",
    "nobs = 100\n",
    "ydf, Xdf = simulate_normal_linear_model(alpha=alpha, vcv_x=vcv_x, var_epsilon=var_epsilon, \n",
    "                                        seed=seed, nobs=nobs)\n",
    "Xdf.var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_alpha_1feat(ydf, xdf):\n",
    "    \"\"\"Compute alpha using var-cov formula and linear regression for the simple case of\n",
    "        y = a + b x\n",
    "    Inputs:\n",
    "        ydf, xdf: dataframes with outcome and feature\n",
    "    Outputs:\n",
    "        Estimated coefficients from two methods: Cov() formula and linear regression\n",
    "    \"\"\"\n",
    "    # Using covariance formula\n",
    "    cat_mat = ydf.copy()\n",
    "    cat_mat['x'] = xdf['x1']  # concatenate [y|x] so I can use the .cov() method\n",
    "    vcv = cat_mat.cov()  \n",
    "    cov_xy = vcv['y'].loc['x']\n",
    "    var_x  = vcv['x'].loc['x']\n",
    "    beta_vcv = cov_xy/var_x\n",
    "    # using linear regression\n",
    "    reg = LinearRegression(fit_intercept=True).fit(xdf, ydf.values.flatten())\n",
    "    beta_reg = reg.coef_[0]\n",
    "\n",
    "    \n",
    "    return beta_vcv, beta_reg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alpha vcv formula = 3.531180168, \n",
      "Alpha OLS = 3.531180168\n"
     ]
    }
   ],
   "source": [
    "b_vcv, b_reg = compute_alpha_1feat(ydf=ydf, xdf=Xdf[['x1']])\n",
    "decimals = 10\n",
    "print(f'Alpha vcv formula = {b_vcv.round(decimals=decimals)}, \\nAlpha OLS = {b_reg.round(decimals=decimals)}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_alpha_n_feats(ydf, xdf, name_var):\n",
    "    \"\"\"\n",
    "    Compute linear regression coefficients by:\n",
    "        1. Orthogonalization (Cov formula)\n",
    "        2. OLS\n",
    "    Inputs: \n",
    "        ydf, xdf: dataframes with outcome and features\n",
    "        name_var: string: name of feature you want to compute\n",
    "    Outputs:\n",
    "        Coefficient for name_var using both methods\n",
    "            \n",
    "    \"\"\"\n",
    "    # Run regression of name_var on all other features and save residuals\n",
    "    cols_exc_x = np.array(list(set(xdf.columns) - set([name_var])))\n",
    "    new_x = xdf[cols_exc_x]\n",
    "    new_y = xdf[name_var]\n",
    "    reg_x = LinearRegression().fit(new_x, new_y.values.flatten())\n",
    "    resids_x = new_y - reg_x.predict(new_x)\n",
    "    # Pass residuals to Cov formula\n",
    "    cat_mat = ydf.copy()\n",
    "    cat_mat['x'] = resids_x\n",
    "    vcv = cat_mat.cov()\n",
    "    cov_xy = vcv['y'].loc['x']\n",
    "    var_x  = vcv['x'].loc['x']\n",
    "    beta_vcv = cov_xy/var_x\n",
    "    # using linear regression\n",
    "    reg = LinearRegression().fit(xdf, ydf.values.flatten())\n",
    "    all_betas = reg.coef_\n",
    "    ix_var = np.where(xdf.columns == name_var)\n",
    "    beta_reg = all_betas[ix_var][0]\n",
    "\n",
    "    return beta_vcv, beta_reg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alpha(x3) cov formula = 2.9534461492, \n",
      "        \n",
      "Alpha(x3) OLS = 2.9534461492\n",
      "        \n",
      "True alpha(x3) = 3\n"
     ]
    }
   ],
   "source": [
    "# several features\n",
    "alpha = [2, 3.5, -2, 3]\n",
    "var_x = [3]*3\n",
    "vcv_x = np.diag(var_x)\n",
    "var_epsilon = 1\n",
    "seed = 44169\n",
    "nobs = 100\n",
    "ydf, Xdf = simulate_normal_linear_model(alpha=alpha, vcv_x=vcv_x, var_epsilon=var_epsilon, \n",
    "                                        seed=seed, nobs=nobs)\n",
    "\n",
    "name_var = 'x3'\n",
    "b2_for, b2_for = compute_alpha_n_feats(ydf=ydf, xdf=Xdf, name_var=name_var)\n",
    "decimals = 10\n",
    "true_alpha = alpha[np.where(Xdf.columns == name_var)[0][0]]\n",
    "print(f\"\"\"Alpha({name_var}) cov formula = {np.around(b2_for, decimals=decimals)}, \n",
    "        \\nAlpha({name_var}) OLS = {np.around(b2_for, decimals=decimals)}\n",
    "        \\nTrue alpha({name_var}) = {true_alpha}\"\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Frisch-Waugh Theorem\n",
    "\n",
    "Suppose that \n",
    "$$\n",
    "y = \\alpha_0 + \\alpha_1 x_1 + \\alpha_2 x_2 + \\epsilon\n",
    "$$\n",
    "\n",
    "Call $x_{-k}$ the feature matrix where you _exclude_ feature $k$\n",
    "\n",
    "FW theorem says: \n",
    "* You can estimate $\\alpha_k$ by running OLS of $y$ on $(x_1, x_2)$, or\n",
    "* Run three regressions:\n",
    "    * Reg 1: y on $x_{-k}$ --> save residuals (`res_yk`)\n",
    "    * Reg 2: x_k on $x_{-k}$ --> save residuals (`res_xk`)\n",
    "    * Reg 3: res_yk on res_xk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_fw(ydf, xdf, var_name, version = 'residuals'):\n",
    "    \"\"\"\n",
    "    Check the Frisch-Waugh theorem:\n",
    "        Method 1: two-step regressions on partialled-out regressions\n",
    "        Method 2: one-step regression\n",
    "    Inputs:\n",
    "        ydf, xdf: dataframes with Y and X respectively\n",
    "        var_name: string: name of feature we want to apply the FW for\n",
    "        version: string: ['residuals','direct'] can be used to test\n",
    "            both covariance formulas presented in the chapter\n",
    "    \"\"\"\n",
    "    # METHOD 1: two steps regressions\n",
    "    nobs = ydf.shape[0]\n",
    "    cols_exc_k = np.array(list(set(xdf.columns) - set([var_name])))\n",
    "    x_k = xdf[cols_exc_k]\n",
    "    # reg 1:\n",
    "    reg_y = LinearRegression().fit(x_k, ydf.values.flatten())\n",
    "    res_yk = ydf.values.flatten() - reg_y.predict(x_k)\n",
    "    # reg 2:\n",
    "    new_y = xdf[var_name]\n",
    "    reg_x = LinearRegression().fit(x_k, new_y.values.flatten())\n",
    "    res_xk = new_y.values.flatten() - reg_x.predict(x_k)\n",
    "    res_xk = res_xk.reshape((nobs,1))\n",
    "    # reg 3:\n",
    "    if version=='residuals':\n",
    "        reg_res = LinearRegression().fit(res_xk, res_yk)\n",
    "    else:\n",
    "        reg_res = LinearRegression().fit(res_xk, ydf.values.flatten())\n",
    "    coef_fw = reg_res.coef_[0]\n",
    "    # METHOD 2: OLS directly\n",
    "    reg = LinearRegression().fit(xdf, ydf.values.flatten())\n",
    "    coef_all = reg.coef_\n",
    "    ix_var = np.where(xdf.columns == var_name)[0][0]\n",
    "    coef_ols = coef_all[ix_var]\n",
    "    \n",
    "    return coef_fw, coef_ols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Printing the results from OLS and FW two-step methods \n",
      "Version = residuals ---\n",
      "x1: FW two-steps = 3.66436, OLS = 3.66436\n",
      "x2: FW two-steps = -1.8564, OLS = -1.8564\n",
      "x3: FW two-steps = 2.95345, OLS = 2.95345\n"
     ]
    }
   ],
   "source": [
    "cols_to_include = set(Xdf.columns)-set(['x0'])\n",
    "decimals= 5\n",
    "print('--- Printing the results from OLS and FW two-step methods \\nVersion = residuals ---')\n",
    "for col in ['x1', 'x2', 'x3']:\n",
    "    a, b = check_fw(ydf, xdf=Xdf[cols_to_include], var_name=col, version='residuals')\n",
    "    print(f'{col}: FW two-steps = {a.round(decimals=decimals)}, OLS = {b.round(decimals=decimals)}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- Printing the results from OLS and FW two-step methods \n",
      "Version = Direct ---\n",
      "x1: FW two-steps = 3.66436, OLS = 3.66436\n",
      "x2: FW two-steps = -1.8564, OLS = -1.8564\n",
      "x3: FW two-steps = 2.95345, OLS = 2.95345\n"
     ]
    }
   ],
   "source": [
    "print('--- Printing the results from OLS and FW two-step methods \\nVersion = Direct ---')\n",
    "for col in ['x1', 'x2', 'x3']:\n",
    "    a, b = check_fw(ydf, xdf=Xdf[cols_to_include], var_name=col, version='direct')\n",
    "    print(f'{col}: FW two-steps = {a.round(decimals=decimals)}, OLS = {b.round(decimals=decimals)}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's simulate a more convoluted model to see the power of FW\n",
    "* y = f(x1,x2)\n",
    "* x2 = g(x1,z)\n",
    "\n",
    "Idea: `x2` is itself a function of `x1`\n",
    "\n",
    "Think of geographic dummies: they usually have a direct and an indirect effect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_categorical_variables(xdf):\n",
    "    \"\"\"This function automates finding categorical/dummy variables\n",
    "    Inputs:\n",
    "        xdf: dataframe with the features used in training a model\n",
    "    Outputs:\n",
    "        df_counts: a mapping of each feature in Xdf with it's type\n",
    "    \"\"\"\n",
    "    # first step: find those that might be dummies numerically \n",
    "    # This is important for binary dummies: for non-binary we need to be careful\n",
    "    xcols = xdf.columns\n",
    "    # get first a mapping of feature --> type\n",
    "    # Idea: count distinct values.  If more than 2 --> continuous (numerical)\n",
    "    df_counts = pd.DataFrame(index = xcols, columns = ['counts','type','modal'])\n",
    "    for c, col in enumerate(xcols):\n",
    "        prec = xdf[col].value_counts()\n",
    "        len_ix = len(prec.index)\n",
    "        df_counts['counts'].loc[col] = len_ix\n",
    "        # map to type and include the modal or mean for later use\n",
    "        if len_ix >= 3:\n",
    "            df_counts.type.loc[col] = 'numerical'\n",
    "            mode_val = xdf[col].mean()\n",
    "        elif len_ix == 1:\n",
    "            df_counts.type.loc[col] = 'intercept'\n",
    "            mode_val = prec.index[0]\n",
    "        else:\n",
    "            df_counts.type.loc[col] = 'categorical'\n",
    "            mode_val = prec.index[0]\n",
    "        df_counts['modal'].loc[col] = mode_val\n",
    "    \n",
    "    return df_counts\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_pdp(xdf, name_var, model, drop_outliers = True, pmin = 0.01, pmax = 0.99, \n",
    "                   dict_specific_xs = None):\n",
    "    \"\"\"\n",
    "    Create a partial dependence plot dataset: this function doesn't plot the results\n",
    "    It creates a grid for the selected variable (name_var) and all other variables are evaluated\n",
    "        on the means.\n",
    "    Inputs:\n",
    "        xdf: to get the means\n",
    "        var_to_simulate: specific var to create a grid (if binary, I need to take care of dummy variables)\n",
    "        model: model object from scikitlearn regression\n",
    "        drop_outliers: Bool: if True we first drop outliers before creating grid\n",
    "        pmin, pmax: percentiles to define what an outlier is\n",
    "        dict_specific_xs: Dictionary if user want's to evaluate on other value {feature:value}\n",
    "            This is useful when you want to evaluate on something different than the mean\n",
    "            or when you want to get \"interaction effects\" in the partial dependence plot\n",
    "    Outputs:\n",
    "        y_pred: dataframe with the PDP\n",
    "        flag_line: Boolean: True if line plot (numerical feature), False if bar plot (dummy variable)\n",
    "    \"\"\"\n",
    "    # 1.  check if I have categorial data\n",
    "    prelab = find_categorical_variables(xdf)\n",
    "    cols_cat = prelab.index[prelab.type == 'categorical']\n",
    "    cols_int = prelab.index[prelab.type == 'intercept']\n",
    "    # 2. Create grid for name_var but first drop outliers\n",
    "    flag_line = True  # default plot is line, except for dummy variables (bar)\n",
    "    if name_var in cols_cat: # dummy variables\n",
    "        grid_size = 2\n",
    "        lin_grid = np.array([0]*int(grid_size/2) + [1]*int(grid_size/2))\n",
    "        flag_line = False\n",
    "    elif name_var in cols_int:  # intercept\n",
    "        grid_size = 1\n",
    "        lin_grid = np.array([1])\n",
    "        flag_line = False\n",
    "    else:  # continuous\n",
    "        grid_size = 20\n",
    "        if drop_outliers == False:  # if no outlier dropping, set to min, max to 0,1\n",
    "            pmin, pmax = 0, 1\n",
    "        lin_grid = xdf[name_var].quantile(np.linspace(pmin, pmax, grid_size))\n",
    "    # 2. create matrix of means <-- change this if you want to evaluate on median or else\n",
    "    means_array = xdf.mean().values\n",
    "    df_mean = pd.DataFrame(np.tile(means_array, (grid_size,1)), columns=xdf.columns, index=lin_grid)\n",
    "    for c, col in enumerate(cols_cat):\n",
    "        df_mean[col] = prelab.loc[col].modal\n",
    "    # 3. replace in X and predict\n",
    "    df_mean[name_var] = df_mean.index\n",
    "    # 4. replace any specific Xs we have\n",
    "    if dict_specific_xs is not None:\n",
    "        for col in dict_specific_xs:\n",
    "            df_mean[col] = dict_specific_xs[col]\n",
    "\n",
    "    # 5. Use trained model to make a prediction on df_mean\n",
    "    y_pred = pd.DataFrame(model.predict(df_mean), columns = ['score'], index = lin_grid)\n",
    "\n",
    "    return y_pred, flag_line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_pdp(xdf, name_var, model, ax, ydf_string = 'Score', drop_outliers = False, \n",
    "             pmin = 0, pmax = 1, **kwargs):\n",
    "    \"\"\"\n",
    "    Plot PDP using the output from create_pdp\n",
    "    Inputs:\n",
    "        name_var --> String: to select the feature that needs to be simulated\n",
    "        xdf: matrix of features to create grid and simulation\n",
    "        model: model object to be used from SCIKIT-LEARN\n",
    "        ax: axis object to create plot\n",
    "        ydf_string: string for title\n",
    "        drop_outliers = True: if False: keep whole data, if True: cut the tails of the distribution\n",
    "        pmin, pmax: percentiles to control extreme observations in the pdp\n",
    "        kwargs: right now only line style\n",
    "    Output:\n",
    "        ax: axis object with plot\n",
    "        y_pred: dataframe with the current variable's grid  and predicted values of Y\n",
    "        flag_line: useful for debugging to check if a categorical variable was wrongly labeled as continuous\n",
    "            or viceversa\n",
    "    \"\"\"\n",
    "    # set default kwargs\n",
    "    ls = '-'\n",
    "    if kwargs:\n",
    "        if 'ls' in kwargs.keys():\n",
    "            ls = kwargs['ls']\n",
    "    # get prediction \n",
    "    y_pred, flag_line = create_pdp(xdf, name_var, model, drop_outliers=drop_outliers, pmin=pmin, pmax=pmax,\n",
    "                                   dict_specific_xs = None)\n",
    "    # plot\n",
    "    kind_plot = 'bar'\n",
    "    color = '0.7'\n",
    "    if flag_line:\n",
    "        kind_plot = 'line'\n",
    "        color = 'k'\n",
    "        y_pred.plot(ax = ax, kind = kind_plot, color = color, alpha=0.9, ls=ls)\n",
    "    else:\n",
    "        y_pred.plot(ax = ax, kind = kind_plot, color = color, alpha=0.9, ls=ls)\n",
    "    ax.legend().remove()\n",
    "    ax.set_title(f'PDP for {name_var}')\n",
    "    ax.set_xlabel(name_var)\n",
    "    ax.set_ylabel('Yhat')\n",
    "    return ax, y_pred, flag_line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_pdp_slope(xdf, model, drop_outliers, pmin, pmax, prop_factor=1, transform=None):\n",
    "    \"\"\"\n",
    "    Use the PDP of a model to compute the slope for comparison\n",
    "        with linear regression.  This is done for each MC draw\n",
    "    xdf: DF with all features used in model training\n",
    "    model: object storing the results of training\n",
    "    prop_factor: proportionality factor to translate from log to linear\n",
    "        alpha = beta*prop_factor (prof_factor = median(y) or AVG(y))\n",
    "    transform: transformation method in (None, 'log', 'quantile')\n",
    "    \"\"\"\n",
    "    cols = xdf.columns\n",
    "    df_slope = pd.DataFrame(index = cols, columns = ['slope'])\n",
    "    for c, col in enumerate(cols):\n",
    "        df_pdp, _ = create_pdp(xdf=xdf, name_var=col, model=model, \n",
    "                               drop_outliers=drop_outliers, pmin=pmin, pmax=pmax,)\n",
    "        x_pdp = df_pdp.index.values.reshape((len(df_pdp.index),1))\n",
    "        y_pdp = df_pdp.score.values\n",
    "        # linear regression to get the slope of the pdp: \n",
    "        #    intercept allows for a parallel shift --> what matters is the slope of the pdp\n",
    "        reg_pdp = LinearRegression(fit_intercept = True).fit(x_pdp, y_pdp)\n",
    "        slope_pdp = reg_pdp.coef_[0]\n",
    "        # if transform = log I need to translate this coefficient alpha = beta*y\n",
    "        if transform == 'log':\n",
    "            slope_pdp *= prop_factor\n",
    "        # store everything\n",
    "        df_slope['slope'][col] = slope_pdp\n",
    "        \n",
    "    return df_slope\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X1 Net Effect = 8.2\n"
     ]
    }
   ],
   "source": [
    "a0, a1, a2 = -0.5, -2, 1  # parameters for y DGP\n",
    "b0, b1 = 7, 10.2  # parameters for x2 DGP\n",
    "np.random.seed(24545)\n",
    "nobs = 100\n",
    "x1 = np.random.randn(nobs)\n",
    "x2 = b0 + b1*x1 + np.random.randn(nobs)\n",
    "ydf = pd.DataFrame(a0 + a1*x1 + a2*x2 + np.random.randn(nobs), columns = ['y'])\n",
    "xdf = pd.DataFrame(np.array([x1, x2]).T, columns = ['x1', 'x2'])\n",
    "\n",
    "# save true pars for later\n",
    "true_pars = [a1, a2]\n",
    "\n",
    "# get the net effect of x1: substitute the DGP of x2 in the DGP of y:\n",
    "# net effect = direct + indirect\n",
    "net_eff_x1 = a1 + a2*b1\n",
    "print(f'X1 Net Effect = {net_eff_x1}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.8662691 ,  0.97235941])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# run linear regression: what do we estimate?\n",
    "reg1 = LinearRegression(fit_intercept=True).fit(xdf, ydf)  # run regression\n",
    "alphay = reg1.coef_.flatten()\n",
    "alphay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# now run Gradient Boosting Regression\n",
    "drop_outliers = True\n",
    "pmin = 0.1\n",
    "pmax = 0.9\n",
    "reg_gb = GradientBoostingRegressor(random_state=0,max_depth=5, learning_rate=0.5,\n",
    "                                  n_estimators=100).fit(xdf, ydf.values.flatten())\n",
    "# compute slope\n",
    "slopes = compute_pdp_slope(xdf=xdf, \n",
    "                            model=reg_gb, \n",
    "                            drop_outliers=drop_outliers, \n",
    "                            pmin=pmin, pmax=pmax)\n",
    "\n",
    "fig, ax = plt.subplots(1,2)\n",
    "for i, var in enumerate(['x1','x2']):\n",
    "    # Get the slopes for both methods\n",
    "    slope_i = slopes.slope.loc[var].round(decimals=2)\n",
    "    ols_i = alphay[i].round(decimals=2)\n",
    "    true_i = true_pars[i]\n",
    "    # plot\n",
    "    ax[i], y_pred, flag_line = plot_pdp(xdf=xdf, name_var = var, model=reg_gb, ax=ax[i], \n",
    "                  ydf_string = 'Score', drop_outliers = drop_outliers, pmin = pmin, pmax = pmax)\n",
    "    ols_pdp = alphay[i]*y_pred.index\n",
    "    ax[i].plot(y_pred.index, ols_pdp, color = 'k', ls='--')\n",
    "    true_pdp = true_pars[i]*y_pred.index\n",
    "    ax[i].plot(y_pred.index, true_pdp, color = 'k', ls='dotted', alpha = 0.9)\n",
    "    ax[i].legend([f'PDP GB ({slope_i})', f'OLS ({ols_i})', f'True ({true_i})'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confounders\n",
    "\n",
    "* Simulate the case of $w \\rightarrow y$ and $w \\rightarrow x$\n",
    "* We can then run two separate regressions:\n",
    "\n",
    "$$\n",
    "y = \\alpha_0 + \\alpha_1 x + \\epsilon \\hspace{2mm}(\\text{spurious regression})\n",
    "$$\n",
    "\n",
    "$$\n",
    "y = \\beta_0 + \\beta_1 x + \\beta_2 w + \\eta \\hspace{2mm}(\\text{include the confounder as control})\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_coeffs(model, labels, ax, pmin = 0.05, pmax=0.95):\n",
    "    \"\"\"\n",
    "    Plot coefficients and 90% CI from statsmodel model object\n",
    "    Inputs:\n",
    "        model: statsmodel linear regression model object\n",
    "        labels: string array with labels for the variables\n",
    "        ax: axis object\n",
    "    Outputs:\n",
    "        ax: axis object with figure\n",
    "    \"\"\"\n",
    "    params = model.params\n",
    "    pvals = model.pvalues\n",
    "    std_err = np.sqrt(np.diag(model.cov_params()))\n",
    "    crit_val = ((pmax-pmin)+1)/2\n",
    "    ci_low, ci_high = params - stats.norm.ppf(crit_val)*std_err, params + stats.norm.ppf(crit_val)*std_err\n",
    "    K = len(params)\n",
    "    ax.bar(range(K), params, color = '0.5', alpha = 0.5, edgecolor = 'k')\n",
    "    ax.set_xticks(range(K))\n",
    "    ax.set_xticklabels(labels)\n",
    "    xmin, xmax = ax.get_xlim()\n",
    "    ax.plot([xmin, xmax], [0,0], ls = '--', color = '0.5')\n",
    "    G = 0.1\n",
    "    for i in range(K):\n",
    "        ax.plot([i,i],[ci_low[i], ci_high[i]], color = 'k')\n",
    "        ax.plot([i-G, i+G], [ci_low[i],ci_low[i]], color = 'k')\n",
    "        ax.plot([i-G, i+G], [ci_high[i],ci_high[i]], color = 'k')  \n",
    "    ci_length = int(np.around((pmax - pmin)*100, decimals=0))\n",
    "    ax.set_title(f'Estimated Coefficients and {ci_length}% CI')  \n",
    "    ax.set_xlim([xmin, xmax])\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# DGPs\n",
    "np.random.seed(10534)\n",
    "var_w = 1\n",
    "w = np.sqrt(var_w)*np.random.randn(nobs,1)\n",
    "slope_x = 1\n",
    "slope_y = -0.3\n",
    "var_ex, var_ey = 1,1\n",
    "x = 0.5 + slope_x*w  + np.sqrt(var_ex)*np.random.randn(nobs,1)\n",
    "y = 3 + slope_y*w + np.sqrt(var_ey)*np.random.randn(nobs,1)\n",
    "# arrange for training\n",
    "xdf0 = pd.DataFrame(x, columns = ['x'])\n",
    "xdf1 = pd.DataFrame(np.concatenate((w,x), axis=1), columns = ['w','x'])\n",
    "xmat0 = sm.add_constant(xdf0)\n",
    "xmat1 = sm.add_constant(xdf1)\n",
    "# regressions\n",
    "reg_sm0 = sm.OLS(y, xmat0).fit()\n",
    "reg_sm1 = sm.OLS(y, xmat1).fit()\n",
    "param_sp = reg_sm0.params.loc['x']\n",
    "# plot\n",
    "fig, ax = plt.subplots(1,2)\n",
    "ax[0] = plot_coeffs(model=reg_sm0, labels=xmat0.columns, ax=ax[0], pmin = 0.025, pmax=0.975)\n",
    "ttl = ax[0].set_title('Spurious Regression', fontsize = 18)\n",
    "ax[1] = plot_coeffs(model=reg_sm1, labels=xmat1.columns, ax=ax[1], pmin = 0.025, pmax=0.975)\n",
    "ttl = ax[1].set_title('Controlling for Confounder', fontsize = 18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simulate trend-stationary processes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_trend_ar1(nobs, coef_dict, seed):\n",
    "    \"\"\"\n",
    "    Simulate an AR1 time series with a trend\n",
    "    Inputs:\n",
    "        nobs: integer: number of observations\n",
    "        coef_dict: dictionary: with following keys\n",
    "            'intercept': value for the intercept\n",
    "            'ar1': autocorrelation coefficient for AR1 process\n",
    "            'trend': coefficient for trend component\n",
    "            'sigma_eps': variance for white noise\n",
    "            'y_init': initial value for y (y0)\n",
    "    Output:\n",
    "        ydf, Xdf: dataframes with features and simulated y\n",
    "    \"\"\"\n",
    "    # assign coefficients:\n",
    "    intercept = coef_dict['intercept']\n",
    "    rho = coef_dict['ar1']\n",
    "    beta = coef_dict['trend']\n",
    "    sigma_eps = coef_dict['sigma_eps']\n",
    "    y0 = coef_dict['y_init']\n",
    "    # Simulation\n",
    "    np.random.seed(seed)\n",
    "    white_noise = np.sqrt(sigma_eps)*np.random.randn(nobs)\n",
    "    # AR1 process needs to be generated iteratively\n",
    "    ydf = pd.DataFrame(index = range(nobs), columns = ['y'], dtype='float')\n",
    "    xdf = pd.DataFrame(index = range(nobs), columns = ['y_lag', 'trend'], dtype='float')\n",
    "    xdf['trend'] = np.arange(nobs)  # linear trend\n",
    "    ydf.y.loc[0] = y0\n",
    "    for i in range(1,nobs):\n",
    "        ydf.y.loc[i] = intercept + rho*ydf.y.loc[i-1] + beta*i + white_noise[i]\n",
    "        xdf.y_lag.loc[i] = ydf.y.loc[i-1]\n",
    "    \n",
    "    return ydf, xdf\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/pandas/core/indexing.py:670: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self._setitem_with_indexer(indexer, value)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Example of a Trend Stationary AR(1) Process')"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nobs = 100\n",
    "coef_dict = {'intercept' : 1, \n",
    "             'ar1' : 0.5,\n",
    "             'trend' : 1,\n",
    "             'sigma_eps' : 1000,\n",
    "             'y_init' : 0}\n",
    "seed = 14751\n",
    "y_t, x_t = simulate_trend_ar1(nobs, coef_dict, seed)\n",
    "fig, ax = plt.subplots()\n",
    "y_t.y.plot(ax = ax)\n",
    "ax.set_title('Example of a Trend Stationary AR(1) Process')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/pandas/core/indexing.py:670: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self._setitem_with_indexer(indexer, value)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Example of Trend Stationary AR(1) Processes')"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# simulate two processes that are uncorrelated but have a common trend\n",
    "coef_dict1 = {'intercept' : 1, \n",
    "             'ar1' : 0.5,\n",
    "             'trend' : 1,\n",
    "             'sigma_eps' : 1000,\n",
    "             'y_init' : 0}\n",
    "coef_dict2 = {'intercept' : 1, \n",
    "             'ar1' : 0.5,\n",
    "             'trend' : -1,\n",
    "             'sigma_eps' : 1000,\n",
    "             'y_init' : 0}\n",
    "seed1 = 14751\n",
    "seed2 = 5170\n",
    "y1_t, x1_t = simulate_trend_ar1(nobs, coef_dict1, seed1)\n",
    "y2_t, x2_t = simulate_trend_ar1(nobs, coef_dict2, seed2)\n",
    "fig, ax = plt.subplots()\n",
    "y1_t.y.plot(ax = ax, color = 'k', ls = '--')\n",
    "y2_t.y.plot(ax = ax, color = 'k', ls = '-')\n",
    "ax.legend(['y1', 'y2'])\n",
    "ax.set_title('Example of Trend Stationary AR(1) Processes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'OLS of Uncorrelated Trend-Stationary Time Series (95% CI)')"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# run a regression of y1 on y2\n",
    "xdf_t = pd.DataFrame(y2_t.values.flatten(), columns = ['y2'])\n",
    "ydf_t = pd.DataFrame\n",
    "xmat_t = sm.add_constant(xdf_t)\n",
    "reg_sm_t = sm.OLS(y1_t, xmat_t).fit()\n",
    "fig, ax = plt.subplots()\n",
    "ax = plot_coeffs(model=reg_sm_t, labels=xmat_t.columns, ax=ax, pmin = 0.025, pmax=0.975)\n",
    "ax.set_ylim([-1,5])\n",
    "xticks = ax.set_xticks([0,1])\n",
    "intercept = reg_sm_t.params.loc['const'].round(decimals=1)\n",
    "ax.annotate(f\"Truncated ({intercept})\",xy=(0.4, 4.9), xytext=(0.7, 4.0), verticalalignment='center',\n",
    "            arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"arc3\"))\n",
    "ax.set_title('OLS of Uncorrelated Trend-Stationary Time Series (95% CI)', fontsize = 18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regression by Backfitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reg_backfitting(ydf, xdf):\n",
    "    \"\"\"\n",
    "    Regression by backfitting.  Find least squares estimates using backfitting algorithm\n",
    "    At each iteration:\n",
    "        res_k: y - X(-k)'beta(-k)\n",
    "        Update beta_k <- OLS(res_k, x_k)\n",
    "    Inputs:\n",
    "        ydf, xdf: dataframes with outcome and features\n",
    "    Outputs:\n",
    "        beta_df: DF with full path of estimated coefficients\n",
    "        beta_ols: DF with OLS results for comparison\n",
    "    \n",
    "    \"\"\"\n",
    "    nobs, nvar = xdf.shape\n",
    "    beta = np.zeros((1,nvar)) # initialize with zeros\n",
    "    #beta = np.array([ydf.y.mean()]*nvar).reshape((1,nvar))  # you can initialize with ymean\n",
    "    dist = 1  # initialize distance\n",
    "    columns = xdf.columns\n",
    "    counter = 0\n",
    "    max_iter = 100\n",
    "    while dist > 1e-3 and counter < max_iter:\n",
    "        beta_iter = np.zeros((1,nvar))\n",
    "        for c,col in enumerate(columns):\n",
    "            # Compute res(-k) = y = x(-k)beta(-k)\n",
    "            ix_included = np.where(columns != col)[0]\n",
    "            cols_included = columns[ix_included]\n",
    "            x_incl = xdf[cols_included]\n",
    "            beta_inc  = beta[-1,ix_included]\n",
    "            res_exc_col = ydf.y.values - np.dot(x_incl, beta_inc.T)\n",
    "            # regression of res(-k) on x_k\n",
    "            reg_c = LinearRegression().fit(X=xdf[[col]], y=res_exc_col)  # run regression\n",
    "            beta_c = reg_c.coef_[0]\n",
    "            beta_iter[0,c] = beta_c\n",
    "        # save beta from this iteration\n",
    "        beta = np.concatenate((beta, beta_iter), axis=0)\n",
    "        # update distance\n",
    "        if counter > 1:\n",
    "            curr_beta = beta[counter,:]\n",
    "            prev_beta = beta[counter-1,:]\n",
    "            max_diff = np.max(curr_beta-prev_beta)\n",
    "            dist = np.abs(max_diff)\n",
    "        counter+=1\n",
    "    beta_df = pd.DataFrame(beta, columns = columns)\n",
    "    # run OLS for comparison\n",
    "    reg = LinearRegression().fit(X=xdf, y=ydf.values.flatten())\n",
    "    beta_ols = pd.Series(reg.coef_, index = columns, name = 'ols')\n",
    "    return beta_ols, beta_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# INDEPENDENT features\n",
    "alpha = [2, -7, 3.5, -2, 3]\n",
    "var_x = [2]*4\n",
    "vcv_x = np.diag(var_x)\n",
    "rho = 0.0\n",
    "var_epsilon = 1\n",
    "seed = 44169\n",
    "nobs = 100\n",
    "ydf, Xdf = simulate_normal_linear_model(alpha=alpha, vcv_x=vcv_x, var_epsilon=var_epsilon, \n",
    "                                        seed=seed, nobs=nobs, rho=None)\n",
    "# backfitting\n",
    "cols = ['x1','x2','x3','x4']\n",
    "b_ols, b_bf = reg_backfitting(ydf, xdf=Xdf[cols])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correlated features\n",
    "rho = 0.5\n",
    "ydf_rho, Xdf_rho = simulate_normal_linear_model(alpha=alpha, vcv_x=vcv_x, var_epsilon=var_epsilon, \n",
    "                                        seed=seed, nobs=nobs, rho=rho)\n",
    "# backfitting\n",
    "b_ols_rho, b_bf_rho = reg_backfitting(ydf_rho, xdf=Xdf_rho[cols])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_backfitting(beta_ols, beta_bf, ax, rho):\n",
    "    \"Plot backfitting iterations\"\n",
    "    nvars = beta_ols.shape[0]\n",
    "    colors = [f'{col}' for col in np.linspace(0,0.6,nvars)]\n",
    "    beta_bf.plot(ax=ax, color = colors)\n",
    "    xmin, xmax = ax.get_xlim()\n",
    "    ymin, ymax = ax.get_xlim()\n",
    "    for n, nme in enumerate(beta_ols.index):\n",
    "        y_n = beta_ols.loc[nme]\n",
    "        ax.plot([xmin,xmax], [y_n, y_n], ls = '--', color = colors[n])\n",
    "    #ax.set_xlim([0,6])\n",
    "    if rho is not None:\n",
    "        str_title = f'OLS - Backfitting: rho = {rho}'\n",
    "    else:\n",
    "        str_title = f'OLS - Backfitting: Independent'\n",
    "    ax.set_title(str_title)\n",
    "    ax.legend(bbox_to_anchor=(1.13, 1.0))\n",
    "    ax.set_xlabel('Iterations')   \n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,2, figsize = (18,4))\n",
    "ax[0] = plot_backfitting(beta_ols=b_ols, beta_bf=b_bf, ax=ax[0], rho = None)\n",
    "ax[1] = plot_backfitting(beta_ols=b_ols_rho, beta_bf=b_bf_rho, ax=ax[1], rho = rho)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional variables\n",
    "* What happens if you include more variables _than needed_?\n",
    "\n",
    "**Strategy**:\n",
    "* Simulate a simple linear model $y = \\alpha + \\beta x + \\epsilon$\n",
    "* Include more unrelated features $\\mathbf{Z}$ but correlated to $x$\n",
    "* Estimate bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_linear_extra_vars(alpha, rho, nvars, var_epsilon, nobs, seed):\n",
    "    \"\"\"\n",
    "    Simulate linear model y = alpha + beta*x, and Z correlated with x\n",
    "    \"\"\"\n",
    "    np.random.seed(seed)\n",
    "    K = len(alpha)\n",
    "    alpha = np.array(alpha).reshape((K,1))   # make it a column vector\n",
    "    # Simulate Z features\n",
    "    zdf = simulate_xmatrix_rho(nobs, nfeats=nvars, rho=rho, seed=seed)\n",
    "    xdf = pd.DataFrame(zdf.values[:,0], columns = ['x1'])\n",
    "    xdf['x0'] = 1\n",
    "    xdf = xdf[['x0','x1']]\n",
    "    epsilon = np.sqrt(var_epsilon)*np.random.randn(nobs,1)\n",
    "    y = np.dot(xdf.values, alpha) + epsilon\n",
    "    ydf = pd.DataFrame(y, columns = ['y'])\n",
    "    return ydf, xdf, zdf    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(         x1        x2\n",
       " 0 -0.245326 -0.613352\n",
       " 1 -0.726768  0.059366,\n",
       "    x0        x1\n",
       " 0   1 -0.245326\n",
       " 1   1 -0.726768)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha = [1,0]\n",
    "rho = 0\n",
    "nvars = 2\n",
    "var_epsilon = 0\n",
    "nobs = 2\n",
    "seed = 105\n",
    "y_test, x_test, z_test = simulate_linear_extra_vars(alpha, rho, nvars, var_epsilon, nobs, seed)\n",
    "assert np.all(y_test==1)\n",
    "z_test, x_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_montecarlo_linear_addvars(alpha, rho, nvars, var_epsilon, nobs, num_montecarlo, seed_mc):\n",
    "    \"\"\"\n",
    "    Run an MC simulation with more variables than needed (opposite of omitted variables)\n",
    "    Inputs:\n",
    "        alpha: float array with [intercept, slope] (bivariate regression)\n",
    "        rho: Correlation coefficient to generate Z~N(0,Sigma(rho))\n",
    "        nvars: Number of total variables (additional = nvars-1)\n",
    "        var_epsilon: Residual variance\n",
    "        nobs: Number of observations\n",
    "        num_montecarlo: Number of MC simulations\n",
    "        seed_mc: Seed of seeds for MC\n",
    "    Outputs:\n",
    "        \n",
    "    \"\"\"\n",
    "    # step 1, simulate the true DGP with only one feature AQUI\n",
    "    np.random.seed(seed_mc)\n",
    "    seed_arr = np.random.randint(low=1, high=10000, size=num_montecarlo, dtype=int)\n",
    "    K = len(alpha)\n",
    "    col_labels = [f'x{num}' for num in range(1,nvars+1)]\n",
    "    df_ols = pd.DataFrame(index = range(num_montecarlo), columns = col_labels, dtype='float')\n",
    "    df_gb = pd.DataFrame(index = range(num_montecarlo), columns = col_labels, dtype='float')\n",
    "    for i in range(num_montecarlo):\n",
    "        ydf, xdf, zdf = simulate_linear_extra_vars(alpha, rho, nvars, var_epsilon, nobs, seed=seed_arr[i])\n",
    "        # Linear regression: note that Zdf doesn't include the intercept\n",
    "        reg = LinearRegression().fit(zdf, ydf)\n",
    "        alpha_hat = reg.coef_.flatten()\n",
    "        df_ols.loc[i] = alpha_hat\n",
    "        # Plain-vanilla GB (no metaparameter optimization)\n",
    "        modgb = GradientBoostingRegressor(random_state=1283).fit(zdf, ydf.values.flatten())\n",
    "        df_pre_gb = compute_pdp_slope(xdf=zdf, model=modgb, drop_outliers=drop_outliers, \n",
    "                                     pmin=pmin, pmax=pmax)\n",
    "        df_gb.loc[i] = df_pre_gb.slope.values\n",
    "    # compute bias: first I need dims to match\n",
    "    true_params = np.array([0]*nvars)\n",
    "    true_params[0] = alpha[1]  # first should be the slope of the true DGP\n",
    "    bias_ols = df_ols - true_params\n",
    "    bias_gb = df_gb - true_params\n",
    "\n",
    "    #return bias_ols, bias_gb\n",
    "    return df_ols, df_gb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = [1,3]\n",
    "rho = 0.5\n",
    "nvars = 5\n",
    "var_epsilon = 1\n",
    "nobs = 100\n",
    "num_montecarlo = 300\n",
    "seed_mc = 105\n",
    "t_ols, t_gb = run_montecarlo_linear_addvars(alpha, rho, nvars, var_epsilon, nobs, num_montecarlo, seed_mc)\n",
    "bounds_ols = create_means_bounds_mc(df=t_ols, qmin = 0.05, qmax = 0.95)\n",
    "bounds_gb = create_means_bounds_mc(df=t_gb, qmin = 0.05, qmax = 0.95)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "percentile_ 5    2.755212\n",
       "Name: x1, dtype: float64"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bounds_ols['x1'].loc[['percentile_ 5']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,2, figsize = (18,5), sharey=True)\n",
    "dict_bd = {0:bounds_ols, 1:bounds_gb}\n",
    "dict_ttl = {0:'OLS', 1:'GB'}\n",
    "for i in range(2):\n",
    "    df_i = dict_bd[i]\n",
    "    k_i = len(df_i.columns)\n",
    "    ax[i].bar(range(k_i), df_i.loc['mean'], edgecolor = 'k', facecolor = '0.75')\n",
    "    for c, col in enumerate(df_i.columns):        \n",
    "        min_c, max_c = df_i[col].loc[['percentile_ 5','percentile_95']]\n",
    "        ax[i].plot([c,c],[min_c, max_c], ls = '-', color = 'k')\n",
    "    ax[i].set_title(f'Estimated Coefficients: Extra Vars ({dict_ttl[i]})')\n",
    "    xmin, xmax = ax[i].get_xlim()\n",
    "    ax[i].plot([xmin, xmax], [0,0], color = 'k', ls = '-', lw=1)\n",
    "    ax[i].set_xlim([xmin, xmax])\n",
    "    ax[i].set_xticks(range(k_i))\n",
    "    ax[i].set_xticklabels(df_i.columns, fontsize=18)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Not included in the chapter but useful\n",
    "\n",
    "* Ensembles are sensitive to correlated features even if not important.\n",
    "* Next simulation\n",
    "    * I include several uninformative features (2,3,4)\n",
    "    * Simulate a matrix $Z \\sim N(0, \\Sigma(\\rho))$ parameterized by the degree of correlation \n",
    "    * I create a grid of correlation parameters\n",
    "* I want to show that OLS is relatively insensitive to this correlation\n",
    "* While GB is not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's simulate on two fronts: correlation grid AND number of extra vars\n",
    "rho_grid = np.linspace(0.5,0.99,5)\n",
    "var_grid = range(2,5)  # 2, 3 and 4 features\n",
    "beta_ols_mc = pd.DataFrame(index = rho_grid, columns = var_grid)\n",
    "beta_gb_mc = pd.DataFrame(index = rho_grid, columns = var_grid)\n",
    "for r, rho_r in enumerate(rho_grid):\n",
    "    for v, nvar_r in enumerate(var_grid):\n",
    "        ols_v, gb_v = run_montecarlo_linear_addvars(alpha = alpha, \n",
    "                                                    rho = rho_r, \n",
    "                                                    nvars = nvar_r, \n",
    "                                                    var_epsilon = var_epsilon, \n",
    "                                                    nobs = nobs, \n",
    "                                                    num_montecarlo = num_montecarlo, \n",
    "                                                    seed_mc = seed_mc)\n",
    "        # get descriptive statistics\n",
    "        bounds_ols = create_means_bounds_mc(df=ols_v, qmin = 0.05, qmax = 0.95)['x1'].values\n",
    "        bounds_gb = create_means_bounds_mc(df=gb_v, qmin = 0.05, qmax = 0.95)['x1'].values        \n",
    "        # save results\n",
    "        beta_ols_mc[nvar_r].loc[rho_r] = ols_v['x1'].mean()\n",
    "        beta_gb_mc[nvar_r].loc[rho_r] = gb_v['x1'].mean()\n",
    "        #beta_ols_mc[nvar_r].loc[rho_r] = [val for val in bounds_ols]\n",
    "        #beta_gb_mc[nvar_r].loc[rho_r] = [val for val in bounds_gb]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,2, figsize = (18,4), sharey = True)\n",
    "colors = ['0.0', '0.4', '0.8']\n",
    "beta_ols_mc.plot(kind='line', ax = ax[0], color = colors)\n",
    "beta_gb_mc.plot(kind='line', ax = ax[1], color = colors)\n",
    "for i in range(2):\n",
    "    ax[i].set_title(f'Estimated Slope for # Extra Feats: {dict_ttl[i]}')\n",
    "    ax[i].set_xlabel('Correlation Coefficient for Features')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why we care about variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_vn_entropy(xdf):\n",
    "    \"\"\"\n",
    "    Compute Von Neumann Entropy = - SUM(lambda * ln(lambda)) \n",
    "        lambda: eigenvalues of X'X\n",
    "    \"\"\"\n",
    "    # compute the eigenvalues\n",
    "    xmat = xdf.values\n",
    "    xtx = np.dot(xmat.T, xmat)\n",
    "    evals, evec = LA.eig(xtx)\n",
    "    evals /= np.sum(evals)\n",
    "    # compute entropy\n",
    "    entropy = -np.sum(evals*np.log(evals))\n",
    "    return entropy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_grid = 11\n",
    "max_rho = 0.99\n",
    "rho_grid = np.linspace(0, max_rho, n_grid)\n",
    "seed = 35011\n",
    "df_entropy = pd.DataFrame(index = rho_grid, columns = ['entropy'])\n",
    "for r, rho in enumerate(rho_grid):\n",
    "    x_r = simulate_xmatrix_rho(nobs=100, nfeats=3, rho=rho, seed = seed)\n",
    "    vn_r = compute_vn_entropy(xdf=x_r)\n",
    "    df_entropy.entropy.loc[rho] = vn_r\n",
    "\n",
    "fig, ax = plt.subplots()    \n",
    "df_entropy.plot(ax=ax, color = 'k')\n",
    "ax.set_title('VN Entropy of Feature Matrix Given Rho')\n",
    "ax.set_xlabel('Correlation Between Features (rho)')\n",
    "ax.get_legend().remove()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Show impact of variance on estimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_montecarlo_linear(alpha, vcv_x, var_epsilon, nobs, num_montecarlo, seed_mc):\n",
    "    \"\"\"\n",
    "    Run a Montecarlo simulation with a linear model\n",
    "    Inputs:\n",
    "        alpha: array with K user-provided coefficients (includes intercept)\n",
    "        vcv_x: array of dimension (K-1)x (K-1) covariance matrix for X.  Must be positive definite\n",
    "        var_epsilon: variance for normal errors\n",
    "        nobs: number of observations in the sample\n",
    "        num_montecarlo: number of montecarlo samples\n",
    "        seed_mc: seed for the seeds of each simulation\n",
    "    output: \n",
    "        df_alpha: dataframe with the estimted coefficients (size= num_montecarlo x K)\n",
    "    \"\"\"\n",
    "    np.random.seed(seed_mc) # seed for generating a random seed: needed to get different samples\n",
    "    seed_arr = np.random.randint(low=1, high=10000, size=num_montecarlo, dtype=int)\n",
    "    K = len(alpha)\n",
    "    col_labels = [f'x{num}' for num in range(K)]\n",
    "    df_ols = pd.DataFrame(index = range(num_montecarlo), columns = col_labels, dtype='float')\n",
    "    df_gb = pd.DataFrame(index = range(num_montecarlo), columns = col_labels, dtype='float')\n",
    "    for i in range(num_montecarlo):\n",
    "        ydf, Xdf = simulate_normal_linear_model(alpha=alpha, vcv_x=vcv_x, var_epsilon=var_epsilon, \n",
    "                                            seed=seed_arr[i], nobs=nobs)\n",
    "        reg = LinearRegression(fit_intercept=False).fit(Xdf, ydf)  # run regression\n",
    "        alpha_hat = reg.coef_.flatten()\n",
    "        df_ols.loc[i] = alpha_hat\n",
    "        # Plain-vanilla GB (no metaparameter optimization)\n",
    "        modgb = GradientBoostingRegressor(random_state=1283).fit(Xdf, ydf.values.flatten())\n",
    "        df_pre_gb = compute_pdp_slope(xdf=Xdf, model=modgb, drop_outliers=drop_outliers, \n",
    "                                     pmin=pmin, pmax=pmax)\n",
    "        df_gb.loc[i] = df_pre_gb.slope.values\n",
    "\n",
    "        \n",
    "    return df_ols, df_gb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x0    0.000000\n",
       "x1    0.011226\n",
       "dtype: float64"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I want to simulate a model, but variances vary from very low to large\n",
    "alpha = [2, 3.5]\n",
    "var_x = [0.01]\n",
    "vcv_x = np.diag(var_x)\n",
    "var_epsilon = 1\n",
    "seed = 44191\n",
    "nobs = 100\n",
    "ydf, Xdf = simulate_normal_linear_model(alpha=alpha, vcv_x=vcv_x, var_epsilon=var_epsilon, \n",
    "                                        seed=seed, nobs=nobs)\n",
    "Xdf.var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a grid of variances to estimate bias\n",
    "G = 20\n",
    "gmax = 3\n",
    "var_grid = np.linspace(0.1, gmax, G)\n",
    "seed_mc = 71450\n",
    "num_montecarlo = 100\n",
    "df_results_ols = pd.DataFrame(index = var_grid, columns = ['mean', 'min_ci', 'max_ci'], dtype='float')\n",
    "df_results_gb = pd.DataFrame(index = var_grid, columns = ['mean', 'min_ci', 'max_ci'], dtype='float')\n",
    "for g, grd in enumerate(var_grid):\n",
    "    var_x = [grd]\n",
    "    vcv_x = np.diag(var_x)\n",
    "    df_g_ols, df_g_gb = run_montecarlo_linear(alpha, vcv_x, var_epsilon, nobs, num_montecarlo, seed_mc=seed_mc)\n",
    "    ci_ols = create_means_bounds_mc(df=df_g_ols, qmin = 0.05, qmax = 0.95)\n",
    "    ci_gb = create_means_bounds_mc(df=df_g_ols, qmin = 0.05, qmax = 0.95)\n",
    "    df_results_ols.loc[grd] = ci_ols['x1'].values\n",
    "    df_results_gb.loc[grd] = ci_gb['x1'].values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "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>mean</th>\n",
       "      <th>min_ci</th>\n",
       "      <th>max_ci</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0.100000</th>\n",
       "      <td>3.470934</td>\n",
       "      <td>2.945947</td>\n",
       "      <td>4.056516</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0.252632</th>\n",
       "      <td>3.481713</td>\n",
       "      <td>3.151416</td>\n",
       "      <td>3.850134</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              mean    min_ci    max_ci\n",
       "0.100000  3.470934  2.945947  4.056516\n",
       "0.252632  3.481713  3.151416  3.850134"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_results_gb.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,2, figsize = (16,4))\n",
    "dict_meth = {0:df_results_ols, 1:df_results_gb}\n",
    "for i in range(2):\n",
    "    df_i = dict_meth[i]\n",
    "    df_i[['min_ci', 'max_ci']].plot(ax = ax[i], color = 'k')\n",
    "    df_i['mean'].plot(ax=ax[i], color='k', ls='--')\n",
    "    ax[i].fill_between(df_i.index, df_i.max_ci, df_i.min_ci, color = '0.7')\n",
    "    ax[i].get_legend().remove()\n",
    "    ax[i].set_title(f'{dict_ttl[i]} Estimate and 95% CI')\n",
    "    ax[i].set_xlabel('Variance of x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grouping variables\n",
    "\n",
    "* I want to show that a regression of the form \n",
    "\n",
    "$$\n",
    "y_{is} = \\alpha + \\beta x + \\sum_s \\theta_s D_s + \\eta \\overline{z}_s+\\epsilon_{is}\n",
    "$$\n",
    "\n",
    "* Let's simulate this model: the only new thing is that I draw the dummies $D_s$ from a multinomial distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simulation\n",
    "np.random.seed(9110)\n",
    "nobs = 100\n",
    "alph = 5\n",
    "beta = 3\n",
    "theta = [-1,1]  # three states, leaving out one as reference \n",
    "eta = -2\n",
    "sigma_eps = 1\n",
    "epsilon = np.sqrt(sigma_eps)*np.random.randn(nobs,1)\n",
    "# simulate x and z as normal\n",
    "sigma_x = 0.1\n",
    "x = np.sqrt(sigma_x)*np.random.randn(nobs)\n",
    "sigma_z = 10\n",
    "mu_z = 7\n",
    "zdf = pd.DataFrame(mu_z + np.sqrt(sigma_z)*np.random.randn(nobs), columns = ['z'])\n",
    "# Simulate state dummies: multinomial\n",
    "dummies = pd.DataFrame(np.random.multinomial(n=1, pvals = [0.2, 0.5, 0.3], size = nobs), \n",
    "                      columns = [f'D{i}' for i in range(3)])\n",
    "# convert to a categorical variable to compute means\n",
    "dummies['cat'] = 1*dummies['D0'] + 2*dummies['D1'] + 3*dummies['D2']\n",
    "means_dict = zdf.z.groupby(dummies.cat).mean().to_dict()\n",
    "dummies['mean_z'] = dummies.cat.replace(means_dict)\n",
    "Xdf = pd.DataFrame([1]*nobs, columns = ['x0'])\n",
    "Xdf['x1'] = x\n",
    "Xdf[['D1','D2','mean_z']] = dummies[['D1','D2','mean_z']]\n",
    "alpha_array = np.array([alph, beta,theta[0], theta[1], eta]).reshape((5,1))\n",
    "ydf = np.dot(Xdf, alpha_array) + epsilon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Columns of X = ['x0' 'x1' 'D1' 'D2' 'mean_z']\n",
      "X: Rank = 4, total columns = 5\n",
      "X_[-meanz]: Rank = 4, total columns = 4\n"
     ]
    }
   ],
   "source": [
    "# Show that X is not full column rank (and thus, won't be invertible)\n",
    "print(f'Columns of X = {Xdf.columns.values}')\n",
    "rank_x = LA.matrix_rank(Xdf)\n",
    "nvars = Xdf.shape[1]\n",
    "print(f'X: Rank = {rank_x}, total columns = {nvars}')\n",
    "# what happens if we drop the means?\n",
    "X_nm = Xdf[[col for col in Xdf.columns if col != 'mean_z']]\n",
    "rank_xnm = LA.matrix_rank(X_nm)\n",
    "nvars_nm = X_nm.shape[1]\n",
    "print(f'X_[-meanz]: Rank = {rank_xnm}, total columns = {nvars_nm}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OLS coefficients from Scikit-learn = [[-0.15045264  3.29509116 -1.02220311  0.94077808 -1.14096089]]\n",
      "Determinant Original Xdf = -1.6837144268033516e-06\n",
      "Determinant Xdf exc. meanz = 277346.46779820765\n"
     ]
    }
   ],
   "source": [
    "# what happens if I try to run LinearRegression\n",
    "reg_lr = LinearRegression(fit_intercept = False).fit(Xdf, ydf)\n",
    "print(f'OLS coefficients from Scikit-learn = {reg_lr.coef_}')\n",
    "# But matrix is singular!\n",
    "xtx = np.dot(Xdf.T, Xdf)\n",
    "detX = LA.det(xtx)\n",
    "print(f'Determinant Original Xdf = {detX}')  # Det = 0!  Non-invertible\n",
    "xtx0 = np.dot(X_nm.T, X_nm)\n",
    "xtx0_inv = LA.inv(xtx0)\n",
    "detX0 = LA.det(xtx0)\n",
    "print(f'Determinant Xdf exc. meanz = {detX0}')  # Det>0 --> invertible\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what about gradient boosting?\n",
    "def compute_test_mse_gb(Xdf, ydf):\n",
    "    \"Run plain-vanilla GBR and compute the mse on the test sample\"\n",
    "    # split the samples and train\n",
    "    X_train, X_test, y_train, y_test = train_test_split(Xdf, ydf, random_state=0)\n",
    "    reg = GradientBoostingRegressor(random_state=0).fit(X_train, y_train.flatten())\n",
    "    y_hat = reg.predict(X_test)\n",
    "    mse = mean_squared_error(y_test, y_hat)\n",
    "    return mse, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.47464019303549 1.4675499901751963\n"
     ]
    }
   ],
   "source": [
    "mse_original, y_o = compute_test_mse_gb(Xdf, ydf)\n",
    "mse_dropped, y_d = compute_test_mse_gb(X_nm, ydf)\n",
    "# test that test samples are the same!\n",
    "assert np.all(y_o==y_d)\n",
    "print(mse_original, mse_dropped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run an MC to ensure that there's no improved predictive performance\n",
    "def simulate_state_model(alpha, nobs, seed):\n",
    "    \"Simulate a version of the model with state dummies\"\n",
    "    np.random.seed(seed)\n",
    "    alph = alpha[0]\n",
    "    beta = alpha[1]\n",
    "    theta = alpha[2:4]  # three states, leaving out one as reference \n",
    "    eta = alpha[4]\n",
    "    epsilon = np.random.randn(nobs,1)\n",
    "    # simulate x and z as normal\n",
    "    x = np.random.randn(nobs)\n",
    "    sigma_z = 10\n",
    "    mu_z = 7\n",
    "    zdf = pd.DataFrame(mu_z + np.sqrt(sigma_z)*np.random.randn(nobs), columns = ['z'])\n",
    "    # Simulate state dummies: multinomial\n",
    "    dummies = pd.DataFrame(np.random.multinomial(n=1, pvals = [0.2, 0.5, 0.3], size = nobs), \n",
    "                          columns = [f'D{i}' for i in range(3)])\n",
    "    # convert to a categorical variable to compute means\n",
    "    dummies['cat'] = 1*dummies['D0'] + 2*dummies['D1'] + 3*dummies['D2']\n",
    "    means_dict = zdf.z.groupby(dummies.cat).mean().to_dict()\n",
    "    dummies['mean_z'] = dummies.cat.replace(means_dict)\n",
    "    Xdf = pd.DataFrame([1]*nobs, columns = ['x0'])\n",
    "    Xdf['x1'] = x\n",
    "    Xdf[['D1','D2','mean_z']] = dummies[['D1','D2','mean_z']]\n",
    "    alpha_array = np.array([alph, beta,theta[0], theta[1], eta]).reshape((5,1))\n",
    "    ydf = np.dot(Xdf, alpha_array) + epsilon\n",
    "\n",
    "    # check rank condition as test\n",
    "    rank_x = LA.matrix_rank(Xdf)\n",
    "    assert rank_x == len(Xdf.columns) - 1\n",
    "\n",
    "    return ydf, Xdf\n",
    "\n",
    "alpha = [5,3,-1,1,-2]\n",
    "nobs = 100\n",
    "seed = 93193\n",
    "ys_df, xs_df = simulate_state_model(alpha, nobs, seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_mc_state_gbr(alpha, nobs, num_montecarlo, seed_mc):\n",
    "    \"Run an MC simulation of state dummies DGP\"\n",
    "    np.random.seed(seed_mc)\n",
    "    seed_arr = np.random.randint(low=1, high=10000, size=num_montecarlo, dtype=int)\n",
    "    mse_df = pd.DataFrame(index = range(num_montecarlo), columns = ['mse_original', 'msi_dropped'])\n",
    "    for i in range(num_montecarlo):\n",
    "        ydf, xdf = simulate_state_model(alpha, nobs, seed = seed_arr[i])\n",
    "        xdf_dr = xdf[[col for col in Xdf.columns if col != 'mean_z']]\n",
    "        # compute MSEs\n",
    "        mse_ori, _ = compute_test_mse_gb(xdf, ydf)\n",
    "        mse_dro, _ = compute_test_mse_gb(xdf_dr, ydf)\n",
    "        mse_df.loc[i] = [mse_ori, mse_dro]\n",
    "        \n",
    "    return mse_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = [5,3,-1,1,-2]\n",
    "nobs = 100\n",
    "seed = 93193\n",
    "num_montecarlo = 300\n",
    "mse_mc = run_mc_state_gbr(alpha, nobs, num_montecarlo, seed_mc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "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>mse_original</th>\n",
       "      <th>msi_dropped</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.813861</td>\n",
       "      <td>1.837272</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>percentile_ 5</th>\n",
       "      <td>1.074584</td>\n",
       "      <td>1.039161</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>percentile_95</th>\n",
       "      <td>2.713919</td>\n",
       "      <td>2.736431</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               mse_original  msi_dropped\n",
       "mean               1.813861     1.837272\n",
       "percentile_ 5      1.074584     1.039161\n",
       "percentile_95      2.713919     2.736431"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bounds_mse = create_means_bounds_mc(df=mse_mc, qmin = 0.05, qmax = 0.95)\n",
    "bounds_mse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0, 'Complete'), Text(0, 0, 'Dropped')]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plot_conf_intervals(means=bounds_mse.loc['mean'].values, \n",
    "                    bounds=bounds_mse.loc[['percentile_ 5', 'percentile_95']].values, \n",
    "                    var_labels = bounds_mse.columns, ax=ax)\n",
    "ax.set_title('GBR MonteCarlo: Means and 90% CI for MSE')\n",
    "ax.set_xticklabels(['Complete', 'Dropped'], fontsize =18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reverse Causality\n",
    "* Simulate this now\n",
    "\n",
    "$$\n",
    "\\begin{eqnarray}\n",
    "y &=& \\alpha_0 + \\alpha_1 x + \\epsilon \\\\\n",
    "z &=& \\beta_0 + \\beta_1 y + \\zeta\n",
    "\\end{eqnarray}\n",
    "$$\n",
    "\n",
    "What happens if you include $z$ as a _control_ in a regression for $y$?\n",
    "$$\n",
    "y = \\delta_0 + \\delta_1 x+ \\delta_2 z + \\iota\n",
    "$$\n",
    "\n",
    "**FW** says that the coefficient $\\delta_2$ can be found as\n",
    "\n",
    "$$\n",
    "\\delta_2 = \\frac{Cov(\\tilde{y}_x, \\tilde{z}_x)}{Var(\\tilde{z}_x)} = \\frac{Cov(\\epsilon, z)}{Var(z)} = 0\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simu_bad_control(alpha, beta, nobs, seed):\n",
    "    np.random.seed(seed)\n",
    "    \"Simulate the case of a bad control\"\n",
    "    # simulate y\n",
    "    xdf = pd.DataFrame([1]*nobs, columns=['x0'])\n",
    "    xdf['x1'] = np.random.randn(nobs)\n",
    "    ydf = pd.DataFrame(np.dot(xdf, alpha) + np.random.randn(nobs), columns = ['y'])\n",
    "    # simulate z\n",
    "    fdf = pd.DataFrame([1]*nobs, columns=['z0'])\n",
    "    fdf['y'] = y\n",
    "    zdf = pd.DataFrame(np.dot(fdf, beta) + np.random.randn(nobs), columns = ['z'])\n",
    "    \n",
    "    return ydf, zdf, xdf, fdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_mc_bad_control(alpha, beta, nobs, seed_mc, num_montecarlo):\n",
    "    \"Run an MC for bad control\"\n",
    "    np.random.seed(seed_mc)\n",
    "    seed_arr = np.random.randint(low=1, high=10000, size=num_montecarlo, dtype=int)\n",
    "    cols = ['intercept', 'x1', 'z']\n",
    "    df_ols = pd.DataFrame(index = range(num_montecarlo), columns = cols, dtype='float')\n",
    "    for i in range(num_montecarlo):\n",
    "        ydf, zdf, xdf, fdf = simu_bad_control(alpha, beta, nobs, seed=seed_arr[i])\n",
    "        x_aug = xdf.copy()\n",
    "        x_aug['z'] = zdf.z\n",
    "        # run ols\n",
    "        reg_i = LinearRegression(fit_intercept=False).fit(x_aug, ydf)\n",
    "        df_ols.loc[i] = reg_i.coef_\n",
    "\n",
    "        \n",
    "    return df_ols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "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>intercept</th>\n",
       "      <th>x1</th>\n",
       "      <th>z</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>-0.979992</td>\n",
       "      <td>0.986434</td>\n",
       "      <td>0.002472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>percentile_ 5</th>\n",
       "      <td>-1.275513</td>\n",
       "      <td>0.824417</td>\n",
       "      <td>-0.043035</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>percentile_95</th>\n",
       "      <td>-0.651035</td>\n",
       "      <td>1.143404</td>\n",
       "      <td>0.043756</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               intercept        x1         z\n",
       "mean           -0.979992  0.986434  0.002472\n",
       "percentile_ 5  -1.275513  0.824417 -0.043035\n",
       "percentile_95  -0.651035  1.143404  0.043756"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha = [-1,1]\n",
    "beta =[3,-3]\n",
    "nobs = 100\n",
    "seed_mc = 62119\n",
    "num_montecarlo = 300\n",
    "mc_bad_con = run_mc_bad_control(alpha, beta, nobs, seed_mc, num_montecarlo)\n",
    "bounds_bc = create_means_bounds_mc(df=mc_bad_con, qmin = 0.05, qmax = 0.95)\n",
    "bounds_bc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0, 'Intercept'), Text(0, 0, 'x1'), Text(0, 0, 'z')]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plot_conf_intervals(means=bounds_bc.loc['mean'].values, \n",
    "                    bounds=bounds_bc.loc[['percentile_ 5', 'percentile_95']].values, \n",
    "                    var_labels = bounds_bc.columns, ax=ax)\n",
    "ax.set_title('Reverse Causality MonteCarlo: Means and 90% CI for MSE', fontsize=20)\n",
    "ax.set_xticklabels(['Intercept', 'x1','z'], fontsize =18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fraud: feature machine\n",
    "\n",
    "* The idea is this: fraudsters _don't_ know the distribution of an outcome\n",
    "* We know it\n",
    "* They will try to appear \"normal\" but we should be able to identify what \"normal\" is\n",
    "* One alternative is to choose an extreme quantile (left or right tail) and normalize the feature with respect to this quantile --> intuition: let's help the algorithm learn what is abnormal or not\n",
    "\n",
    "$$\n",
    "Prob(y=1) = F(\\alpha + \\beta \\frac{x}{x_q} + \\epsilon \\geq 0) \n",
    "$$\n",
    "\n",
    "Where $x_q$ is some quantile of $x$, say, the 90% quantile that will serve as bench to define something abnormal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_fraud_probability(alpha, nobs, sigma_x, sigma_eps, seed):\n",
    "    \"Simulate the probability of fraud\"\n",
    "    np.random.seed(seed)\n",
    "    x = np.random.lognormal(mean=0, sigma = sigma_x, size = nobs)  # assume log-normality\n",
    "    x90 = np.percentile(x, 90)\n",
    "    xnorm = x/x90\n",
    "    z = alpha[0] + alpha[1]*xnorm + np.sqrt(sigma_eps)*np.random.randn(nobs)\n",
    "    y = 1*(z>=0)\n",
    "    xdf = pd.DataFrame([1]*nobs, columns = ['x0'])\n",
    "    xdf['x'] = x\n",
    "    xdf['xnorm'] = xnorm\n",
    "    ydf = pd.DataFrame(y, columns=['y'])\n",
    "    return ydf, xdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Normalized vs. OriginalFeature')"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alpha = [2,-10]\n",
    "sigma_x, sigma_eps = 0.4, 1\n",
    "seed = 61514\n",
    "nobs = 10000\n",
    "y_t, x_t = simulate_fraud_probability(alpha, nobs, sigma_x, sigma_eps, seed)\n",
    "y_t.mean()\n",
    "# check the histogram of the two features\n",
    "fig, ax = plt.subplots()\n",
    "ax.scatter(x_t['x'], x_t['xnorm'], facecolor='0.75', edgecolor='k', alpha= 0.7)\n",
    "ax.set_xlabel('Original Feature')\n",
    "ax.set_ylabel('Normalized Feature')\n",
    "ax.set_title('Normalized vs. OriginalFeature')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what about gradient boosting?\n",
    "def compute_test_mse_model(Xdf, ydf, model):\n",
    "    \"MSE for a given model object\"\n",
    "    y_hat = model.predict(Xdf)\n",
    "    mse = mean_squared_error(ydf, y_hat)\n",
    "    return mse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def balance_data(ydf, xdf, method):\n",
    "    '''\n",
    "    Balance the dataset using one method: over/under sampling\n",
    "    ydf, xdf: dataframes with outcome and features\n",
    "    method: ['over','under']\n",
    "    '''\n",
    "    # find minority class: if mean < 0.5 -> minority class = 1\n",
    "    min_class = 1*(ydf.mean() < 0.5)\n",
    "    # get indices for classes\n",
    "    loc_min = ydf == min_class\n",
    "    min_ix = ydf[loc_min].index\n",
    "    max_ix = ydf[loc_min==False].index\n",
    "    n_min = len(min_ix)\n",
    "    n_max = len(max_ix)\n",
    "    if method == 'over':\n",
    "        num_sml = n_max//n_min\n",
    "        sml_ix = np.random.choice(min_ix, size = n_max, replace = True)\n",
    "        sml_all = np.concatenate((sml_ix, max_ix),axis = 0)\n",
    "    elif method == 'under':\n",
    "        sml_ix = np.random.choice(max_ix, size = n_min, replace = True)\n",
    "        sml_all = np.concatenate((sml_ix, min_ix),axis = 0)\n",
    "    # ready to assemble everything\n",
    "    y_new = ydf.loc[sml_all]\n",
    "    x_new = xdf.loc[sml_all]\n",
    "    return y_new, x_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_mc_fraud(alpha, nobs, sigma_x, sigma_eps, seed_mc, num_montecarlo):\n",
    "    \"Run MC for fraud: estimate OLS and GBC\"\n",
    "    # step 1, simulate the true DGP with only one feature AQUI\n",
    "    np.random.seed(seed_mc)\n",
    "    seed_arr = np.random.randint(low=1, high=10000, size=num_montecarlo, dtype=int)\n",
    "    K = len(alpha)\n",
    "    cols = ['mse_ols', 'mse_ols_norm', 'mse_gb', 'mse_gb_norm']\n",
    "    df_results = pd.DataFrame(index = range(num_montecarlo), columns = cols)\n",
    "    for i in range(num_montecarlo):\n",
    "        # create dataset, split into train/test and balance train sample only\n",
    "        ydf, xdf_pre = simulate_fraud_probability(alpha, nobs, sigma_x, sigma_eps, seed = seed_arr[i])\n",
    "        X_train, X_test, y_train, y_test = train_test_split(xdf_pre, ydf, random_state=0)\n",
    "        xdf_train, xdf_test = X_train[['x']], X_test[['x']]\n",
    "        xdf_train_norm, xdf_test_norm = X_train[['xnorm']], X_test[['xnorm']]\n",
    "        y_b, x_b = balance_data(ydf=y_train, xdf=xdf_train, method='over')\n",
    "        y_b_norm, x_b_norm = balance_data(ydf=y_train, xdf=xdf_train_norm, method='over')\n",
    "        # Now the models: linear probability model and a \n",
    "        reg = LinearRegression().fit(x_b, y_b.values.flatten())\n",
    "        reg_norm = LinearRegression().fit(x_b_norm, y_b_norm.values.flatten())\n",
    "        gb = GradientBoostingRegressor(random_state=1283).fit(x_b, y_b.values.flatten())\n",
    "        gb_norm = GradientBoostingRegressor(random_state=1283).fit(x_b_norm, y_b_norm.values.flatten())\n",
    "        # I want to compute MSE in test\n",
    "        mse_ols = compute_test_mse_model(xdf_test, y_test, model=reg)\n",
    "        mse_ols_norm = compute_test_mse_model(xdf_test_norm, y_test, model=reg_norm)\n",
    "        mse_gb = compute_test_mse_model(xdf_test, y_test, model=gb)\n",
    "        mse_gb_norm = compute_test_mse_model(xdf_test_norm, y_test, model=gb_norm)\n",
    "        # save\n",
    "        df_results.loc[i] = [mse_ols, mse_ols_norm, mse_gb, mse_gb_norm]\n",
    "\n",
    "    return df_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = [2,-10]\n",
    "sigma_x, sigma_eps = 0.4, 1\n",
    "num_montecarlo = 300\n",
    "seed_mc = 61514\n",
    "nobs = 10000\n",
    "df_mc_fraud = run_mc_fraud(alpha, nobs, sigma_x, sigma_eps, seed_mc, num_montecarlo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'MSE Fraud Simulation')"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_fr_bounds = create_means_bounds_mc(df=df_mc_fraud, qmin = 0.05, qmax = 0.95)\n",
    "means = df_fr_bounds.loc['mean']\n",
    "bounds = df_fr_bounds.loc[['percentile_ 5','percentile_95']].values\n",
    "fig, ax = plt.subplots()\n",
    "ax = plot_conf_intervals(means, bounds, var_labels = df_fr_bounds.columns, ax=ax)\n",
    "ax.set_xticks(range(4))\n",
    "labs = [col.replace('mse_','').replace('_', ' ').replace('norm',\n",
    "                                                         'normalized').upper() for col in df_fr_bounds.columns]\n",
    "labs = ax.set_xticklabels(labs)\n",
    "ax.set_title('MSE Fraud Simulation')"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}