{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Linear regression diagnostics" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In real-life, relation between response and target variables are seldom linear. Here, we make use of outputs of statsmodels to visualise and identify potential problems that can occur from fitting linear regression model to non-linear relation. Primarily, the aim is to reproduce visualisations discussed in Potential Problems section (Chapter 3.3.3) of *An Introduction to Statistical Learning* (ISLR) book by James et al., Springer." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2023-01-26T15:15:05.503608Z", "iopub.status.busy": "2023-01-26T15:15:05.502527Z", "iopub.status.idle": "2023-01-26T15:15:06.092672Z", "shell.execute_reply": "2023-01-26T15:15:06.092078Z" } }, "outputs": [], "source": [ "import statsmodels\n", "import statsmodels.formula.api as smf\n", "import pandas as pd" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Simple multiple linear regression\n", "\n", "Firstly, let us load the Advertising data from Chapter 2 of ISLR book and fit a linear model to it." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2023-01-26T15:15:06.096844Z", "iopub.status.busy": "2023-01-26T15:15:06.096322Z", "iopub.status.idle": "2023-01-26T15:15:06.268547Z", "shell.execute_reply": "2023-01-26T15:15:06.267940Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0230.137.869.222.1
144.539.345.110.4
217.245.969.39.3
3151.541.358.518.5
4180.810.858.412.9
\n", "
" ], "text/plain": [ " TV Radio Newspaper Sales\n", "0 230.1 37.8 69.2 22.1\n", "1 44.5 39.3 45.1 10.4\n", "2 17.2 45.9 69.3 9.3\n", "3 151.5 41.3 58.5 18.5\n", "4 180.8 10.8 58.4 12.9" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Load data\n", "data_url = \"https://raw.githubusercontent.com/nguyen-toan/ISLR/07fd968ea484b5f6febc7b392a28eb64329a4945/dataset/Advertising.csv\"\n", "df = pd.read_csv(data_url).drop('Unnamed: 0', axis=1)\n", "df.head()" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2023-01-26T15:15:06.273882Z", "iopub.status.busy": "2023-01-26T15:15:06.271010Z", "iopub.status.idle": "2023-01-26T15:15:06.301822Z", "shell.execute_reply": "2023-01-26T15:15:06.301192Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "
Dep. Variable: R-squared: Sales 0.897 OLS 0.896 Least Squares 570.3 Thu, 26 Jan 2023 1.58e-96 15:15:06 -386.18 200 780.4 196 793.6 3 nonrobust
\n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "
coef std err t P>|t| [0.025 0.975] 2.9389 0.312 9.422 0.000 2.324 3.554 0.0458 0.001 32.809 0.000 0.043 0.049 0.1885 0.009 21.893 0.000 0.172 0.206 -0.0010 0.006 -0.177 0.860 -0.013 0.011
\n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "\n", " \n", "\n", "
 Omnibus: Durbin-Watson: 60.414 2.084 0 151.241 -1.327 1.44e-33 6.332 454

Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified." ], "text/latex": [ "\\begin{center}\n", "\\begin{tabular}{lclc}\n", "\\toprule\n", "\\textbf{Dep. Variable:} & Sales & \\textbf{ R-squared: } & 0.897 \\\\\n", "\\textbf{Model:} & OLS & \\textbf{ Adj. R-squared: } & 0.896 \\\\\n", "\\textbf{Method:} & Least Squares & \\textbf{ F-statistic: } & 570.3 \\\\\n", "\\textbf{Date:} & Thu, 26 Jan 2023 & \\textbf{ Prob (F-statistic):} & 1.58e-96 \\\\\n", "\\textbf{Time:} & 15:15:06 & \\textbf{ Log-Likelihood: } & -386.18 \\\\\n", "\\textbf{No. Observations:} & 200 & \\textbf{ AIC: } & 780.4 \\\\\n", "\\textbf{Df Residuals:} & 196 & \\textbf{ BIC: } & 793.6 \\\\\n", "\\textbf{Df Model:} & 3 & \\textbf{ } & \\\\\n", "\\textbf{Covariance Type:} & nonrobust & \\textbf{ } & \\\\\n", "\\bottomrule\n", "\\end{tabular}\n", "\\begin{tabular}{lcccccc}\n", " & \\textbf{coef} & \\textbf{std err} & \\textbf{t} & \\textbf{P$> |$t$|$} & \\textbf{[0.025} & \\textbf{0.975]} \\\\\n", "\\midrule\n", "\\textbf{Intercept} & 2.9389 & 0.312 & 9.422 & 0.000 & 2.324 & 3.554 \\\\\n", "\\textbf{TV} & 0.0458 & 0.001 & 32.809 & 0.000 & 0.043 & 0.049 \\\\\n", "\\textbf{Radio} & 0.1885 & 0.009 & 21.893 & 0.000 & 0.172 & 0.206 \\\\\n", "\\textbf{Newspaper} & -0.0010 & 0.006 & -0.177 & 0.860 & -0.013 & 0.011 \\\\\n", "\\bottomrule\n", "\\end{tabular}\n", "\\begin{tabular}{lclc}\n", "\\textbf{Omnibus:} & 60.414 & \\textbf{ Durbin-Watson: } & 2.084 \\\\\n", "\\textbf{Prob(Omnibus):} & 0.000 & \\textbf{ Jarque-Bera (JB): } & 151.241 \\\\\n", "\\textbf{Skew:} & -1.327 & \\textbf{ Prob(JB): } & 1.44e-33 \\\\\n", "\\textbf{Kurtosis:} & 6.332 & \\textbf{ Cond. No. } & 454. \\\\\n", "\\bottomrule\n", "\\end{tabular}\n", "%\\caption{OLS Regression Results}\n", "\\end{center}\n", "\n", "Notes: \\newline\n", " [1] Standard Errors assume that the covariance matrix of the errors is correctly specified." ], "text/plain": [ "\n", "\"\"\"\n", " OLS Regression Results \n", "==============================================================================\n", "Dep. Variable: Sales R-squared: 0.897\n", "Model: OLS Adj. R-squared: 0.896\n", "Method: Least Squares F-statistic: 570.3\n", "Date: Thu, 26 Jan 2023 Prob (F-statistic): 1.58e-96\n", "Time: 15:15:06 Log-Likelihood: -386.18\n", "No. Observations: 200 AIC: 780.4\n", "Df Residuals: 196 BIC: 793.6\n", "Df Model: 3 \n", "Covariance Type: nonrobust \n", "==============================================================================\n", " coef std err t P>|t| [0.025 0.975]\n", "------------------------------------------------------------------------------\n", "Intercept 2.9389 0.312 9.422 0.000 2.324 3.554\n", "TV 0.0458 0.001 32.809 0.000 0.043 0.049\n", "Radio 0.1885 0.009 21.893 0.000 0.172 0.206\n", "Newspaper -0.0010 0.006 -0.177 0.860 -0.013 0.011\n", "==============================================================================\n", "Omnibus: 60.414 Durbin-Watson: 2.084\n", "Prob(Omnibus): 0.000 Jarque-Bera (JB): 151.241\n", "Skew: -1.327 Prob(JB): 1.44e-33\n", "Kurtosis: 6.332 Cond. No. 454.\n", "==============================================================================\n", "\n", "Notes:\n", "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", "\"\"\"" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Fitting linear model\n", "res = smf.ols(formula= \"Sales ~ TV + Radio + Newspaper\", data=df).fit()\n", "res.summary()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Diagnostic Figures/Table\n", "\n", "In the following first we present a base code that we will later use to generate following diagnostic plots:\n", "\n", " a. residual\n", " b. qq\n", " c. scale location\n", " d. leverage\n", "\n", "and a table\n", "\n", " a. vif" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2023-01-26T15:15:06.304826Z", "iopub.status.busy": "2023-01-26T15:15:06.304607Z", "iopub.status.idle": "2023-01-26T15:15:06.764358Z", "shell.execute_reply": "2023-01-26T15:15:06.763675Z" } }, "outputs": [], "source": [ "# base code\n", "import numpy as np\n", "import seaborn as sns\n", "from statsmodels.tools.tools import maybe_unwrap_results\n", "from statsmodels.graphics.gofplots import ProbPlot\n", "from statsmodels.stats.outliers_influence import variance_inflation_factor\n", "import matplotlib.pyplot as plt\n", "from typing import Type\n", "\n", "style_talk = 'seaborn-talk' #refer to plt.style.available\n", "\n", "class Linear_Reg_Diagnostic():\n", " \"\"\"\n", " Diagnostic plots to identify potential problems in a linear regression fit.\n", " Mainly,\n", " a. non-linearity of data\n", " b. Correlation of error terms\n", " c. non-constant variance \n", " d. outliers\n", " e. high-leverage points\n", " f. collinearity\n", "\n", " Author:\n", " Prajwal Kafle (p33ajkafle@gmail.com, where 3 = r)\n", " Does not come with any sort of warranty. \n", " Please test the code one your end before using.\n", " \"\"\"\n", "\n", " def __init__(self, \n", " results: Type[statsmodels.regression.linear_model.RegressionResultsWrapper]) -> None:\n", " \"\"\"\n", " For a linear regression model, generates following diagnostic plots:\n", "\n", " a. residual\n", " b. qq\n", " c. scale location and\n", " d. leverage\n", "\n", " and a table\n", "\n", " e. vif\n", "\n", " Args:\n", " results (Type[statsmodels.regression.linear_model.RegressionResultsWrapper]): \n", " must be instance of statsmodels.regression.linear_model object\n", "\n", " Raises:\n", " TypeError: if instance does not belong to above object\n", "\n", " Example:\n", " >>> import numpy as np\n", " >>> import pandas as pd\n", " >>> import statsmodels.formula.api as smf\n", " >>> x = np.linspace(-np.pi, np.pi, 100)\n", " >>> y = 3*x + 8 + np.random.normal(0,1, 100)\n", " >>> df = pd.DataFrame({'x':x, 'y':y})\n", " >>> res = smf.ols(formula= \"y ~ x\", data=df).fit()\n", " >>> cls = Linear_Reg_Diagnostic(res)\n", " >>> cls(plot_context=\"seaborn-paper\") \n", "\n", " In case you do not need all plots you can also independently make an individual plot/table\n", " in following ways\n", "\n", " >>> cls = Linear_Reg_Diagnostic(res)\n", " >>> cls.residual_plot()\n", " >>> cls.qq_plot()\n", " >>> cls.scale_location_plot()\n", " >>> cls.leverage_plot()\n", " >>> cls.vif_table()\n", " \"\"\"\n", "\n", " if isinstance(results, statsmodels.regression.linear_model.RegressionResultsWrapper) is False:\n", " raise TypeError(\"result must be instance of statsmodels.regression.linear_model.RegressionResultsWrapper object\")\n", "\n", " self.results = maybe_unwrap_results(results)\n", "\n", " self.y_true = self.results.model.endog\n", " self.y_predict = self.results.fittedvalues\n", " self.xvar = self.results.model.exog\n", " self.xvar_names = self.results.model.exog_names\n", "\n", " self.residual = np.array(self.results.resid)\n", " influence = self.results.get_influence()\n", " self.residual_norm = influence.resid_studentized_internal\n", " self.leverage = influence.hat_matrix_diag\n", " self.cooks_distance = influence.cooks_distance[0]\n", " self.nparams = len(self.results.params)\n", "\n", " def __call__(self, plot_context='seaborn-paper'):\n", " # print(plt.style.available)\n", " with plt.style.context(plot_context):\n", " fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(10,10))\n", " self.residual_plot(ax=ax[0,0])\n", " self.qq_plot(ax=ax[0,1])\n", " self.scale_location_plot(ax=ax[1,0])\n", " self.leverage_plot(ax=ax[1,1])\n", " plt.show()\n", " \n", " self.vif_table()\n", " return fig, ax\n", "\n", "\n", " def residual_plot(self, ax=None):\n", " \"\"\"\n", " Residual vs Fitted Plot\n", "\n", " Graphical tool to identify non-linearity.\n", " (Roughly) Horizontal red line is an indicator that the residual has a linear pattern\n", " \"\"\"\n", " if ax is None:\n", " fig, ax = plt.subplots()\n", "\n", " sns.residplot(\n", " x=self.y_predict, \n", " y=self.residual, \n", " lowess=True,\n", " scatter_kws={'alpha': 0.5},\n", " line_kws={'color': 'red', 'lw': 1, 'alpha': 0.8}, \n", " ax=ax)\n", "\n", " # annotations\n", " residual_abs = np.abs(self.residual)\n", " abs_resid = np.flip(np.sort(residual_abs))\n", " abs_resid_top_3 = abs_resid[:3]\n", " for i, _ in enumerate(abs_resid_top_3):\n", " ax.annotate(\n", " i, \n", " xy=(self.y_predict[i], self.residual[i]), \n", " color='C3')\n", "\n", " ax.set_title('Residuals vs Fitted', fontweight=\"bold\")\n", " ax.set_xlabel('Fitted values')\n", " ax.set_ylabel('Residuals')\n", " return ax\n", "\n", " def qq_plot(self, ax=None):\n", " \"\"\"\n", " Standarized Residual vs Theoretical Quantile plot\n", "\n", " Used to visually check if residuals are normally distributed.\n", " Points spread along the diagonal line will suggest so.\n", " \"\"\"\n", " if ax is None:\n", " fig, ax = plt.subplots()\n", " \n", " QQ = ProbPlot(self.residual_norm)\n", " QQ.qqplot(line='45', alpha=0.5, lw=1, ax=ax)\n", "\n", " # annotations\n", " abs_norm_resid = np.flip(np.argsort(np.abs(self.residual_norm)), 0)\n", " abs_norm_resid_top_3 = abs_norm_resid[:3]\n", " for r, i in enumerate(abs_norm_resid_top_3):\n", " ax.annotate(\n", " i, \n", " xy=(np.flip(QQ.theoretical_quantiles, 0)[r], self.residual_norm[i]), \n", " ha='right', color='C3')\n", "\n", " ax.set_title('Normal Q-Q', fontweight=\"bold\")\n", " ax.set_xlabel('Theoretical Quantiles')\n", " ax.set_ylabel('Standardized Residuals')\n", " return ax\n", " \n", " def scale_location_plot(self, ax=None):\n", " \"\"\"\n", " Sqrt(Standarized Residual) vs Fitted values plot\n", "\n", " Used to check homoscedasticity of the residuals.\n", " Horizontal line will suggest so.\n", " \"\"\"\n", " if ax is None:\n", " fig, ax = plt.subplots()\n", "\n", " residual_norm_abs_sqrt = np.sqrt(np.abs(self.residual_norm))\n", "\n", " ax.scatter(self.y_predict, residual_norm_abs_sqrt, alpha=0.5);\n", " sns.regplot(\n", " x=self.y_predict, \n", " y=residual_norm_abs_sqrt,\n", " scatter=False, ci=False,\n", " lowess=True,\n", " line_kws={'color': 'red', 'lw': 1, 'alpha': 0.8}, \n", " ax=ax)\n", "\n", " # annotations\n", " abs_sq_norm_resid = np.flip(np.argsort(residual_norm_abs_sqrt), 0)\n", " abs_sq_norm_resid_top_3 = abs_sq_norm_resid[:3]\n", " for i in abs_sq_norm_resid_top_3:\n", " ax.annotate(\n", " i, \n", " xy=(self.y_predict[i], residual_norm_abs_sqrt[i]), \n", " color='C3')\n", " ax.set_title('Scale-Location', fontweight=\"bold\")\n", " ax.set_xlabel('Fitted values')\n", " ax.set_ylabel(r'$\\sqrt{|\\mathrm{Standardized\\ Residuals}|}$');\n", " return ax\n", "\n", " def leverage_plot(self, ax=None):\n", " \"\"\"\n", " Residual vs Leverage plot\n", "\n", " Points falling outside Cook's distance curves are considered observation that can sway the fit\n", " aka are influential.\n", " Good to have none outside the curves.\n", " \"\"\"\n", " if ax is None:\n", " fig, ax = plt.subplots()\n", "\n", " ax.scatter(\n", " self.leverage, \n", " self.residual_norm, \n", " alpha=0.5);\n", " \n", " sns.regplot(\n", " x=self.leverage, \n", " y=self.residual_norm,\n", " scatter=False,\n", " ci=False,\n", " lowess=True,\n", " line_kws={'color': 'red', 'lw': 1, 'alpha': 0.8},\n", " ax=ax)\n", "\n", " # annotations\n", " leverage_top_3 = np.flip(np.argsort(self.cooks_distance), 0)[:3]\n", " for i in leverage_top_3:\n", " ax.annotate(\n", " i, \n", " xy=(self.leverage[i], self.residual_norm[i]),\n", " color = 'C3')\n", "\n", " xtemp, ytemp = self.__cooks_dist_line(0.5) # 0.5 line\n", " ax.plot(xtemp, ytemp, label=\"Cook's distance\", lw=1, ls='--', color='red')\n", " xtemp, ytemp = self.__cooks_dist_line(1) # 1 line\n", " ax.plot(xtemp, ytemp, lw=1, ls='--', color='red')\n", " \n", " ax.set_xlim(0, max(self.leverage)+0.01)\n", " ax.set_title('Residuals vs Leverage', fontweight=\"bold\")\n", " ax.set_xlabel('Leverage')\n", " ax.set_ylabel('Standardized Residuals')\n", " ax.legend(loc='upper right')\n", " return ax\n", "\n", " def vif_table(self):\n", " \"\"\"\n", " VIF table\n", "\n", " VIF, the variance inflation factor, is a measure of multicollinearity.\n", " VIF > 5 for a variable indicates that it is highly collinear with the \n", " other input variables.\n", " \"\"\"\n", " vif_df = pd.DataFrame()\n", " vif_df[\"Features\"] = self.xvar_names\n", " vif_df[\"VIF Factor\"] = [variance_inflation_factor(self.xvar, i) for i in range(self.xvar.shape[1])]\n", "\n", " print(vif_df\n", " .sort_values(\"VIF Factor\")\n", " .round(2))\n", " \n", "\n", " def __cooks_dist_line(self, factor):\n", " \"\"\"\n", " Helper function for plotting Cook's distance curves\n", " \"\"\"\n", " p = self.nparams \n", " formula = lambda x: np.sqrt((factor * p * (1 - x)) / x)\n", " x = np.linspace(0.001, max(self.leverage), 50)\n", " y = formula(x)\n", " return x, y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Making use of the \n", "\n", " * fitted model on the Advertising data above and \n", " * the base code provided\n", "now we generate diagnostic plots one by one." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2023-01-26T15:15:06.767559Z", "iopub.status.busy": "2023-01-26T15:15:06.767261Z", "iopub.status.idle": "2023-01-26T15:15:06.775720Z", "shell.execute_reply": "2023-01-26T15:15:06.775170Z" } }, "outputs": [], "source": [ "cls = Linear_Reg_Diagnostic(res)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**A. Residual vs Fitted values**\n", "\n", "Graphical tool to identify non-linearity.\n", "\n", "In the graph red (roughly) horizontal line is an indicator that the residual has a linear pattern." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2023-01-26T15:15:06.779107Z", "iopub.status.busy": "2023-01-26T15:15:06.778272Z", "iopub.status.idle": "2023-01-26T15:15:07.015097Z", "shell.execute_reply": "2023-01-26T15:15:07.014528Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "