linear_regression_from_ds_handbook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "anaconda-cloud": {},
    "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.5.1"
    },
    "colab": {
      "name": "linear-regression-from-ds-handbook",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zHafE2BrAPyk"
      },
      "source": [
        "# Setup for Screen Reader"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qq9srwIE97QR"
      },
      "source": [
        "!pip install colab-a11y-utils\n",
        "!pip install audio-plot-lib\n",
        "\n",
        "import audio_plot_lib as apl\n",
        "from colab_a11y_utils import set_sound_notifications\n",
        "set_sound_notifications()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3v_g8eyr-FGo"
      },
      "source": [
        "# From Python Data Science Handbook\n",
        "\n",
        "The original is at the following URL, with the text unchanged and only some of the code modified.\n",
        "\n",
        "https://jakevdp.github.io/PythonDataScienceHandbook/05.06-linear-regression.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "bvPbq_3B9r7H"
      },
      "source": [
        "<!--BOOK_INFORMATION-->\n",
        "<img align=\"left\" style=\"padding-right:10px;\" src=\"https://github.com/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/figures/PDSH-cover-small.png?raw=1\">\n",
        "\n",
        "*This notebook contains an excerpt from the [Python Data Science Handbook](http://shop.oreilly.com/product/0636920034919.do) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/PythonDataScienceHandbook).*\n",
        "\n",
        "*The text is released under the [CC-BY-NC-ND license](https://creativecommons.org/licenses/by-nc-nd/3.0/us/legalcode), and code is released under the [MIT license](https://opensource.org/licenses/MIT). If you find this content useful, please consider supporting the work by [buying the book](http://shop.oreilly.com/product/0636920034919.do)!*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "urDQh07P9r7T"
      },
      "source": [
        "<!--NAVIGATION-->\n",
        "< [In Depth: Naive Bayes Classification](05.05-Naive-Bayes.ipynb) | [Contents](Index.ipynb) | [In-Depth: Support Vector Machines](05.07-Support-Vector-Machines.ipynb) >\n",
        "\n",
        "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/05.06-Linear-Regression.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iaC7eEpP9r7U"
      },
      "source": [
        "# In Depth: Linear Regression"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0A4s9bR19r7V"
      },
      "source": [
        "Just as naive Bayes (discussed earlier in [In Depth: Naive Bayes Classification](05.05-Naive-Bayes.ipynb)) is a good starting point for classification tasks, linear regression models are a good starting point for regression tasks.\n",
        "Such models are popular because they can be fit very quickly, and are very interpretable.\n",
        "You are probably familiar with the simplest form of a linear regression model (i.e., fitting a straight line to data) but such models can be extended to model more complicated data behavior.\n",
        "\n",
        "In this section we will start with a quick intuitive walk-through of the mathematics behind this well-known problem, before seeing how before moving on to see how linear models can be generalized to account for more complicated patterns in data.\n",
        "\n",
        "We begin with the standard imports:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "Oma9XA6c9r7V"
      },
      "source": [
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns; sns.set()\n",
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "squznSef9r7W"
      },
      "source": [
        "## Simple Linear Regression\n",
        "\n",
        "We will start with the most familiar linear regression, a straight-line fit to data.\n",
        "A straight-line fit is a model of the form\n",
        "$$\n",
        "y = ax + b\n",
        "$$\n",
        "where $a$ is commonly known as the *slope*, and $b$ is commonly known as the *intercept*.\n",
        "\n",
        "Consider the following data, which is scattered about a line with a slope of 2 and an intercept of -5:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "faE9MVTb9r7X"
      },
      "source": [
        "rng = np.random.RandomState(1)\n",
        "x = 10 * rng.rand(50)\n",
        "y = 2 * x - 5 + rng.randn(50)\n",
        "# original\n",
        "# plt.scatter(x, y);\n",
        "\n",
        "apl.interactive.plot(y.tolist(), x.tolist(), title=\"data graph\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "n11eZF609r7Y"
      },
      "source": [
        "We can use Scikit-Learn's ``LinearRegression`` estimator to fit this data and construct the best-fit line:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Go7Ezv2s9r7Z"
      },
      "source": [
        "from sklearn.linear_model import LinearRegression\n",
        "model = LinearRegression(fit_intercept=True)\n",
        "\n",
        "model.fit(x[:, np.newaxis], y)\n",
        "\n",
        "xfit = np.linspace(0, 10, 1000)\n",
        "yfit = model.predict(xfit[:, np.newaxis])\n",
        "\n",
        "# original\n",
        "# plt.scatter(x, y)\n",
        "# plt.plot(xfit, yfit);\n",
        "\n",
        "labels = [0]*len(x) + [1]*len(xfit)  # label 0 is data, label 1 is best-fit line\n",
        "xplot = x.tolist() + xfit.tolist()\n",
        "yplot = y.tolist() + yfit.tolist()\n",
        "\n",
        "# You can switch the label of the data to be voiced by double-clicking on it.\n",
        "# Make sure that the training data with label 0 overlaps with the best-fit line with label 1.\n",
        "apl.interactive.plot(yplot, xplot, label=labels, title=\"data and best-fit line\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "WyPRdMlh9r7a"
      },
      "source": [
        "The slope and intercept of the data are contained in the model's fit parameters, which in Scikit-Learn are always marked by a trailing underscore.\n",
        "Here the relevant parameters are ``coef_`` and ``intercept_``:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "5Yc5FOpC9r7a"
      },
      "source": [
        "print(\"Model slope:    \", model.coef_[0])\n",
        "print(\"Model intercept:\", model.intercept_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qk4JsYgX9r7b"
      },
      "source": [
        "We see that the results are very close to the inputs, as we might hope."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hm3dnnJj9r7b"
      },
      "source": [
        "The ``LinearRegression`` estimator is much more capable than this, however—in addition to simple straight-line fits, it can also handle multidimensional linear models of the form\n",
        "$$\n",
        "y = a_0 + a_1 x_1 + a_2 x_2 + \\cdots\n",
        "$$\n",
        "where there are multiple $x$ values.\n",
        "Geometrically, this is akin to fitting a plane to points in three dimensions, or fitting a hyper-plane to points in higher dimensions.\n",
        "\n",
        "The multidimensional nature of such regressions makes them more difficult to visualize, but we can see one of these fits in action by building some example data, using NumPy's matrix multiplication operator:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "UWBqpa4-9r7b"
      },
      "source": [
        "rng = np.random.RandomState(1)\n",
        "X = 10 * rng.rand(100, 3)\n",
        "y = 0.5 + np.dot(X, [1.5, -2., 1.])\n",
        "\n",
        "model.fit(X, y)\n",
        "print(model.intercept_)\n",
        "print(model.coef_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Fo4tkOmx9r7c"
      },
      "source": [
        "Here the $y$ data is constructed from three random $x$ values, and the linear regression recovers the coefficients used to construct the data.\n",
        "\n",
        "In this way, we can use the single ``LinearRegression`` estimator to fit lines, planes, or hyperplanes to our data.\n",
        "It still appears that this approach would be limited to strictly linear relationships between variables, but it turns out we can relax this as well."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "9O5EUxHu9r7c"
      },
      "source": [
        "## Basis Function Regression\n",
        "\n",
        "One trick you can use to adapt linear regression to nonlinear relationships between variables is to transform the data according to *basis functions*.\n",
        "We have seen one version of this before, in the ``PolynomialRegression`` pipeline used in [Hyperparameters and Model Validation](05.03-Hyperparameters-and-Model-Validation.ipynb) and [Feature Engineering](05.04-Feature-Engineering.ipynb).\n",
        "The idea is to take our multidimensional linear model:\n",
        "$$\n",
        "y = a_0 + a_1 x_1 + a_2 x_2 + a_3 x_3 + \\cdots\n",
        "$$\n",
        "and build the $x_1, x_2, x_3,$ and so on, from our single-dimensional input $x$.\n",
        "That is, we let $x_n = f_n(x)$, where $f_n()$ is some function that transforms our data.\n",
        "\n",
        "For example, if $f_n(x) = x^n$, our model becomes a polynomial regression:\n",
        "$$\n",
        "y = a_0 + a_1 x + a_2 x^2 + a_3 x^3 + \\cdots\n",
        "$$\n",
        "Notice that this is *still a linear model*—the linearity refers to the fact that the coefficients $a_n$ never multiply or divide each other.\n",
        "What we have effectively done is taken our one-dimensional $x$ values and projected them into a higher dimension, so that a linear fit can fit more complicated relationships between $x$ and $y$."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "CPSQjxLG9r7d"
      },
      "source": [
        "### Polynomial basis functions\n",
        "\n",
        "This polynomial projection is useful enough that it is built into Scikit-Learn, using the ``PolynomialFeatures`` transformer:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "HpajEGN89r7d"
      },
      "source": [
        "from sklearn.preprocessing import PolynomialFeatures\n",
        "x = np.array([2, 3, 4])\n",
        "poly = PolynomialFeatures(3, include_bias=False)\n",
        "poly.fit_transform(x[:, None])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "xMkaCTd09r7e"
      },
      "source": [
        "We see here that the transformer has converted our one-dimensional array into a three-dimensional array by taking the exponent of each value.\n",
        "This new, higher-dimensional data representation can then be plugged into a linear regression.\n",
        "\n",
        "As we saw in [Feature Engineering](05.04-Feature-Engineering.ipynb), the cleanest way to accomplish this is to use a pipeline.\n",
        "Let's make a 7th-degree polynomial model in this way:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "MUXdGbHW9r7e"
      },
      "source": [
        "from sklearn.pipeline import make_pipeline\n",
        "poly_model = make_pipeline(PolynomialFeatures(7),\n",
        "                           LinearRegression())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "i9sbWtBa9r7e"
      },
      "source": [
        "With this transform in place, we can use the linear model to fit much more complicated relationships between $x$ and $y$. \n",
        "For example, here is a sine wave with noise:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "QISAJHBa9r7e"
      },
      "source": [
        "rng = np.random.RandomState(1)\n",
        "x = 10 * rng.rand(50)\n",
        "y = np.sin(x) + 0.1 * rng.randn(50)\n",
        "\n",
        "poly_model.fit(x[:, np.newaxis], y)\n",
        "yfit = poly_model.predict(xfit[:, np.newaxis])\n",
        "\n",
        "# original\n",
        "#plt.scatter(x, y)\n",
        "#plt.plot(xfit, yfit);\n",
        "\n",
        "labels = [0]*len(x) + [1]*len(xfit)  # label 0 is data, label 1 is best-fit line\n",
        "xplot = x.tolist() + xfit.tolist()\n",
        "yplot = y.tolist() + yfit.tolist()\n",
        "\n",
        "# You can switch the label of the data to be voiced by double-clicking on it.\n",
        "# Make sure that the training data with label 0 overlaps with the best-fit line with label 1.\n",
        "apl.interactive.plot(yplot, xplot, label=labels, title=\"data and polynomial best-fit line\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "y2JDPDMj9r7f"
      },
      "source": [
        "Our linear model, through the use of 7th-order polynomial basis functions, can provide an excellent fit to this non-linear data!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qCeQi3Rw9r7f"
      },
      "source": [
        "### Gaussian basis functions\n",
        "\n",
        "Of course, other basis functions are possible.\n",
        "For example, one useful pattern is to fit a model that is not a sum of polynomial bases, but a sum of Gaussian bases.\n",
        "The result might look something like the following figure:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Ie5o6VNP9r7f"
      },
      "source": [
        "![](https://github.com/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/figures/05.06-gaussian-basis.png?raw=1)\n",
        "[figure source in Appendix](#Gaussian-Basis)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "tgpDzkxm9r7f"
      },
      "source": [
        "The shaded regions in the plot are the scaled basis functions, and when added together they reproduce the smooth curve through the data.\n",
        "These Gaussian basis functions are not built into Scikit-Learn, but we can write a custom transformer that will create them, as shown here and illustrated in the following figure (Scikit-Learn transformers are implemented as Python classes; reading Scikit-Learn's source is a good way to see how they can be created):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "eJ99uxtz9r7g"
      },
      "source": [
        "from sklearn.base import BaseEstimator, TransformerMixin\n",
        "\n",
        "class GaussianFeatures(BaseEstimator, TransformerMixin):\n",
        "    \"\"\"Uniformly spaced Gaussian features for one-dimensional input\"\"\"\n",
        "    \n",
        "    def __init__(self, N, width_factor=2.0):\n",
        "        self.N = N\n",
        "        self.width_factor = width_factor\n",
        "    \n",
        "    @staticmethod\n",
        "    def _gauss_basis(x, y, width, axis=None):\n",
        "        arg = (x - y) / width\n",
        "        return np.exp(-0.5 * np.sum(arg ** 2, axis))\n",
        "        \n",
        "    def fit(self, X, y=None):\n",
        "        # create N centers spread along the data range\n",
        "        self.centers_ = np.linspace(X.min(), X.max(), self.N)\n",
        "        self.width_ = self.width_factor * (self.centers_[1] - self.centers_[0])\n",
        "        return self\n",
        "        \n",
        "    def transform(self, X):\n",
        "        return self._gauss_basis(X[:, :, np.newaxis], self.centers_,\n",
        "                                 self.width_, axis=1)\n",
        "    \n",
        "gauss_model = make_pipeline(GaussianFeatures(20),\n",
        "                            LinearRegression())\n",
        "gauss_model.fit(x[:, np.newaxis], y)\n",
        "yfit = gauss_model.predict(xfit[:, np.newaxis])\n",
        "\n",
        "plt.scatter(x, y)\n",
        "plt.plot(xfit, yfit)\n",
        "plt.xlim(0, 10);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "pDLJ4go59r7h"
      },
      "source": [
        "We put this example here just to make clear that there is nothing magic about polynomial basis functions: if you have some sort of intuition into the generating process of your data that makes you think one basis or another might be appropriate, you can use them as well."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "-Kiu4H4O9r7h"
      },
      "source": [
        "## Regularization\n",
        "\n",
        "The introduction of basis functions into our linear regression makes the model much more flexible, but it also can very quickly lead to over-fitting (refer back to [Hyperparameters and Model Validation](05.03-Hyperparameters-and-Model-Validation.ipynb) for a discussion of this).\n",
        "For example, if we choose too many Gaussian basis functions, we end up with results that don't look so good:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "KvEtrJg29r7h"
      },
      "source": [
        "model = make_pipeline(GaussianFeatures(30),\n",
        "                      LinearRegression())\n",
        "model.fit(x[:, np.newaxis], y)\n",
        "\n",
        "# original\n",
        "#plt.scatter(x, y)\n",
        "#plt.plot(xfit, model.predict(xfit[:, np.newaxis]))\n",
        "#plt.xlim(0, 10)\n",
        "#plt.ylim(-1.5, 1.5);\n",
        "\n",
        "yfit = model.predict(xfit[:, np.newaxis])\n",
        "labels = [0]*len(x) + [1]*len(xfit)  # label 0 is data, label 1 is best-fit line\n",
        "xplot = x.tolist() + xfit.tolist()\n",
        "yplot = y.tolist() + yfit.tolist()\n",
        "\n",
        "# You can switch the label of the data to be voiced by double-clicking on it.\n",
        "# Make sure that the training data with label 0 overlaps with the best-fit line with label 1.\n",
        "apl.interactive.plot(yplot, xplot, label=labels, width=700,\n",
        "                     title=\"data and gaussian best-fit line\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "KO5yIUN79r7i"
      },
      "source": [
        "With the data projected to the 30-dimensional basis, the model has far too much flexibility and goes to extreme values between locations where it is constrained by data.\n",
        "We can see the reason for this if we plot the coefficients of the Gaussian bases with respect to their locations:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "vVuwF67n9r7i"
      },
      "source": [
        "# original\n",
        "#def basis_plot(model, title=None):\n",
        "#    fig, ax = plt.subplots(2, sharex=True)\n",
        "#    model.fit(x[:, np.newaxis], y)\n",
        "#    ax[0].scatter(x, y)\n",
        "#    ax[0].plot(xfit, model.predict(xfit[:, np.newaxis]))\n",
        "#    ax[0].set(xlabel='x', ylabel='y', ylim=(-1.5, 1.5))\n",
        "#    \n",
        "#    if title:\n",
        "#        ax[0].set_title(title)\n",
        "#\n",
        "#    ax[1].plot(model.steps[0][1].centers_,\n",
        "#               model.steps[1][1].coef_)\n",
        "#    ax[1].set(xlabel='basis location',\n",
        "#              ylabel='coefficient',\n",
        "#              xlim=(0, 10))\n",
        "\n",
        "def basis_plot(model, title=\"\"):\n",
        "    model.fit(x[:, np.newaxis], y)\n",
        "    yfit = model.predict(xfit[:, np.newaxis])\n",
        "    \n",
        "    labels = [0]*len(x) + [1]*len(xfit)  # label 0 is data, label 1 is best-fit line\n",
        "    xplot = x.tolist() + xfit.tolist()\n",
        "    yplot = y.tolist() + yfit.tolist()\n",
        "    apl.interactive.plot(yplot, xplot, label=labels,\n",
        "                     title=\"data and best-fit line \" + title, height=200)\n",
        "    \n",
        "    apl.interactive.plot(model.steps[1][1].coef_.tolist(), model.steps[0][1].centers_.tolist(),\n",
        "                        title=\"basis location x and coefficient y \" + title, height=200)\n",
        "\n",
        "model = make_pipeline(GaussianFeatures(30), LinearRegression())\n",
        "basis_plot(model)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "fkomYCdu9r7i"
      },
      "source": [
        "The lower panel of this figure shows the amplitude of the basis function at each location.\n",
        "This is typical over-fitting behavior when basis functions overlap: the coefficients of adjacent basis functions blow up and cancel each other out.\n",
        "We know that such behavior is problematic, and it would be nice if we could limit such spikes expliticly in the model by penalizing large values of the model parameters.\n",
        "Such a penalty is known as *regularization*, and comes in several forms."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "7VpRzgs49r7j"
      },
      "source": [
        "### Ridge regression ($L_2$ Regularization)\n",
        "\n",
        "Perhaps the most common form of regularization is known as *ridge regression* or $L_2$ *regularization*, sometimes also called *Tikhonov regularization*.\n",
        "This proceeds by penalizing the sum of squares (2-norms) of the model coefficients; in this case, the penalty on the model fit would be \n",
        "$$\n",
        "P = \\alpha\\sum_{n=1}^N \\theta_n^2\n",
        "$$\n",
        "where $\\alpha$ is a free parameter that controls the strength of the penalty.\n",
        "This type of penalized model is built into Scikit-Learn with the ``Ridge`` estimator:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "XngBJRbR9r7j"
      },
      "source": [
        "from sklearn.linear_model import Ridge\n",
        "model = make_pipeline(GaussianFeatures(30), Ridge(alpha=0.1))\n",
        "basis_plot(model, title='Ridge Regression')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "li4HEntK9r7k"
      },
      "source": [
        "The $\\alpha$ parameter is essentially a knob controlling the complexity of the resulting model.\n",
        "In the limit $\\alpha \\to 0$, we recover the standard linear regression result; in the limit $\\alpha \\to \\infty$, all model responses will be suppressed.\n",
        "One advantage of ridge regression in particular is that it can be computed very efficiently—at hardly more computational cost than the original linear regression model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "8fjnQ8nv9r7l"
      },
      "source": [
        "### Lasso regression ($L_1$ regularization)\n",
        "\n",
        "Another very common type of regularization is known as lasso, and involves penalizing the sum of absolute values (1-norms) of regression coefficients:\n",
        "$$\n",
        "P = \\alpha\\sum_{n=1}^N |\\theta_n|\n",
        "$$\n",
        "Though this is conceptually very similar to ridge regression, the results can differ surprisingly: for example, due to geometric reasons lasso regression tends to favor *sparse models* where possible: that is, it preferentially sets model coefficients to exactly zero.\n",
        "\n",
        "We can see this behavior in duplicating the ridge regression figure, but using L1-normalized coefficients:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "J2douci19r7l"
      },
      "source": [
        "from sklearn.linear_model import Lasso\n",
        "model = make_pipeline(GaussianFeatures(30), Lasso(alpha=0.001))\n",
        "basis_plot(model, title='Lasso Regression')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "bA8LPHJk9r7m"
      },
      "source": [
        "With the lasso regression penalty, the majority of the coefficients are exactly zero, with the functional behavior being modeled by a small subset of the available basis functions.\n",
        "As with ridge regularization, the $\\alpha$ parameter tunes the strength of the penalty, and should be determined via, for example, cross-validation (refer back to [Hyperparameters and Model Validation](05.03-Hyperparameters-and-Model-Validation.ipynb) for a discussion of this)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "JahlsV-W9r7m"
      },
      "source": [
        "## Example: Predicting Bicycle Traffic"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "KmQcHtpq9r7m"
      },
      "source": [
        "As an example, let's take a look at whether we can predict the number of bicycle trips across Seattle's Fremont Bridge based on weather, season, and other factors.\n",
        "We have seen this data already in [Working With Time Series](03.11-Working-with-Time-Series.ipynb).\n",
        "\n",
        "In this section, we will join the bike data with another dataset, and try to determine the extent to which weather and seasonal factors—temperature, precipitation, and daylight hours—affect the volume of bicycle traffic through this corridor.\n",
        "Fortunately, the NOAA makes available their daily [weather station data](http://www.ncdc.noaa.gov/cdo-web/search?datasetid=GHCND) (I used station ID USW00024233) and we can easily use Pandas to join the two data sources.\n",
        "We will perform a simple linear regression to relate weather and other information to bicycle counts, in order to estimate how a change in any one of these parameters affects the number of riders on a given day.\n",
        "\n",
        "In particular, this is an example of how the tools of Scikit-Learn can be used in a statistical modeling framework, in which the parameters of the model are assumed to have interpretable meaning.\n",
        "As discussed previously, this is not a standard approach within machine learning, but such interpretation is possible for some models.\n",
        "\n",
        "Let's start by loading the two datasets, indexing by date:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "P7g9igRZ9r7m"
      },
      "source": [
        "!curl -o FremontBridge.csv https://data.seattle.gov/api/views/65db-xm6k/rows.csv?accessType=DOWNLOAD"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wts-Pvit9r7m"
      },
      "source": [
        "import pandas as pd\n",
        "counts = pd.read_csv('FremontBridge.csv', index_col='Date', parse_dates=True)\n",
        "weather = pd.read_csv('https://raw.githubusercontent.com/jakevdp/PythonDataScienceHandbook/master/notebooks/data/BicycleWeather.csv', index_col='DATE', parse_dates=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "WfrSjQ2S9r7n"
      },
      "source": [
        "Next we will compute the total daily bicycle traffic, and put this in its own dataframe:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "DnNMWDyn9r7n"
      },
      "source": [
        "daily = counts.resample('d').sum()\n",
        "daily['Total'] = daily.sum(axis=1)\n",
        "daily = daily[['Total']] # remove other columns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "4sdOD3YW9r7n"
      },
      "source": [
        "We saw previously that the patterns of use generally vary from day to day; let's account for this in our data by adding binary columns that indicate the day of the week:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "deletable": true,
        "editable": true,
        "id": "qgyKPRfb9r7n"
      },
      "source": [
        "days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']\n",
        "for i in range(7):\n",
        "    daily[days[i]] = (daily.index.dayofweek == i).astype(float)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "NiiT2-e99r7n"
      },
      "source": [
        "Similarly, we might expect riders to behave differently on holidays; let's add an indicator of this as well:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "gjFfAISp9r7o"
      },
      "source": [
        "from pandas.tseries.holiday import USFederalHolidayCalendar\n",
        "cal = USFederalHolidayCalendar()\n",
        "holidays = cal.holidays('2012', '2016')\n",
        "daily = daily.join(pd.Series(1, index=holidays, name='holiday'))\n",
        "daily['holiday'].fillna(0, inplace=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "mdVyiLrw9r7o"
      },
      "source": [
        "We also might suspect that the hours of daylight would affect how many people ride; let's use the standard astronomical calculation to add this information:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "UMjQJ7vL9r7o"
      },
      "source": [
        "def hours_of_daylight(date, axis=23.44, latitude=47.61):\n",
        "    \"\"\"Compute the hours of daylight for the given date\"\"\"\n",
        "    days = (date - pd.datetime(2000, 12, 21)).days\n",
        "    m = (1. - np.tan(np.radians(latitude))\n",
        "         * np.tan(np.radians(axis) * np.cos(days * 2 * np.pi / 365.25)))\n",
        "    return 24. * np.degrees(np.arccos(1 - np.clip(m, 0, 2))) / 180.\n",
        "\n",
        "daily['daylight_hrs'] = list(map(hours_of_daylight, daily.index))\n",
        "\n",
        "# original\n",
        "#daily[['daylight_hrs']].plot()\n",
        "#plt.ylim(8, 17)\n",
        "\n",
        "apl.interactive.plot(daily['daylight_hrs'].values.tolist(),\n",
        "                     title=\"hours of daylight since {} until {}\".format(daily.index[0], daily.index[-1]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Md1AyFxc9r7o"
      },
      "source": [
        "We can also add the average temperature and total precipitation to the data.\n",
        "In addition to the inches of precipitation, let's add a flag that indicates whether a day is dry (has zero precipitation):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FSvh8JeW9r7p"
      },
      "source": [
        "# temperatures are in 1/10 deg C; convert to C\n",
        "weather['TMIN'] /= 10\n",
        "weather['TMAX'] /= 10\n",
        "weather['Temp (C)'] = 0.5 * (weather['TMIN'] + weather['TMAX'])\n",
        "\n",
        "# precip is in 1/10 mm; convert to inches\n",
        "weather['PRCP'] /= 254\n",
        "weather['dry day'] = (weather['PRCP'] == 0).astype(int)\n",
        "\n",
        "daily = daily.join(weather[['PRCP', 'Temp (C)', 'dry day']])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Z1O-W9_g9r7p"
      },
      "source": [
        "Finally, let's add a counter that increases from day 1, and measures how many years have passed.\n",
        "This will let us measure any observed annual increase or decrease in daily crossings:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "HPHmvtvd9r7p"
      },
      "source": [
        "daily['annual'] = (daily.index - daily.index[0]).days / 365."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hZqY_-5Y9r7p"
      },
      "source": [
        "Now our data is in order, and we can take a look at it:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "y__YO-kr9r7p"
      },
      "source": [
        "daily.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dQ6MkO4L9r7q"
      },
      "source": [
        "With this in place, we can choose the columns to use, and fit a linear regression model to our data.\n",
        "We will set ``fit_intercept = False``, because the daily flags essentially operate as their own day-specific intercepts:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Pza0TAqt9r7q"
      },
      "source": [
        "# Drop any rows with null values\n",
        "daily.dropna(axis=0, how='any', inplace=True)\n",
        "\n",
        "column_names = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun', 'holiday',\n",
        "                'daylight_hrs', 'PRCP', 'dry day', 'Temp (C)', 'annual']\n",
        "X = daily[column_names]\n",
        "y = daily['Total']\n",
        "\n",
        "model = LinearRegression(fit_intercept=False)\n",
        "model.fit(X, y)\n",
        "daily['predicted'] = model.predict(X)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1knxLqia9r7q"
      },
      "source": [
        "Finally, we can compare the total and predicted bicycle traffic visually:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ViCCfDJL9r7q"
      },
      "source": [
        "# original\n",
        "#daily[['Total', 'predicted']].plot(alpha=0.5);\n",
        "\n",
        "label = [0]*len(daily.index) + [1]*len(daily.index)\n",
        "xplot = list(range(len(daily.index))) * 2\n",
        "yplot = daily[\"Total\"].values.tolist() + daily[\"predicted\"].values.tolist()\n",
        "apl.interactive.plot(yplot, xplot, label=label, title=\"total and predicted\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "y-3lJ7kz9r7r"
      },
      "source": [
        "It is evident that we have missed some key features, especially during the summer time.\n",
        "Either our features are not complete (i.e., people decide whether to ride to work based on more than just these) or there are some nonlinear relationships that we have failed to take into account (e.g., perhaps people ride less at both high and low temperatures).\n",
        "Nevertheless, our rough approximation is enough to give us some insights, and we can take a look at the coefficients of the linear model to estimate how much each feature contributes to the daily bicycle count:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FVp7y5mB9r7r"
      },
      "source": [
        "params = pd.Series(model.coef_, index=X.columns)\n",
        "params"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "3Sh1Y-D49r7r"
      },
      "source": [
        "These numbers are difficult to interpret without some measure of their uncertainty.\n",
        "We can compute these uncertainties quickly using bootstrap resamplings of the data:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "7_w_v7PA9r7s"
      },
      "source": [
        "from sklearn.utils import resample\n",
        "np.random.seed(1)\n",
        "err = np.std([model.fit(*resample(X, y)).coef_\n",
        "              for i in range(1000)], 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "JYuxg0sA9r7s"
      },
      "source": [
        "With these errors estimated, let's again look at the results:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "O6QbFqpe9r7s"
      },
      "source": [
        "print(pd.DataFrame({'effect': params.round(0),\n",
        "                    'error': err.round(0)}))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "V7hc1QGu9r7t"
      },
      "source": [
        "We first see that there is a relatively stable trend in the weekly baseline: there are many more riders on weekdays than on weekends and holidays.\n",
        "We see that for each additional hour of daylight, 129 ± 9 more people choose to ride; a temperature increase of one degree Celsius encourages 65 ± 4 people to grab their bicycle; a dry day means an average of 548 ± 33 more riders, and each inch of precipitation means 665 ± 62 more people leave their bike at home.\n",
        "Once all these effects are accounted for, we see a modest increase of 27 ± 18 new daily riders each year.\n",
        "\n",
        "Our model is almost certainly missing some relevant information. For example, nonlinear effects (such as effects of precipitation *and* cold temperature) and nonlinear trends within each variable (such as disinclination to ride at very cold and very hot temperatures) cannot be accounted for in this model.\n",
        "Additionally, we have thrown away some of the finer-grained information (such as the difference between a rainy morning and a rainy afternoon), and we have ignored correlations between days (such as the possible effect of a rainy Tuesday on Wednesday's numbers, or the effect of an unexpected sunny day after a streak of rainy days).\n",
        "These are all potentially interesting effects, and you now have the tools to begin exploring them if you wish!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qByMKWQw9r7t"
      },
      "source": [
        "<!--NAVIGATION-->\n",
        "< [In Depth: Naive Bayes Classification](05.05-Naive-Bayes.ipynb) | [Contents](Index.ipynb) | [In-Depth: Support Vector Machines](05.07-Support-Vector-Machines.ipynb) >\n",
        "\n",
        "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/05.06-Linear-Regression.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
      ]
    }
  ]
}