solutions_validation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "hide": true
   },
   "source": [
    "# Validation and Regularization\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "hide": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "//anaconda/envs/py3l/lib/python3.6/site-packages/matplotlib/__init__.py:855: MatplotlibDeprecationWarning: \n",
      "examples.directory is deprecated; in the future, examples will be found relative to the 'datapath' directory.\n",
      "  \"found relative to the 'datapath' directory.\".format(key))\n",
      "//anaconda/envs/py3l/lib/python3.6/site-packages/matplotlib/__init__.py:846: MatplotlibDeprecationWarning: \n",
      "The text.latex.unicode rcparam was deprecated in Matplotlib 2.2 and will be removed in 3.1.\n",
      "  \"2.2\", name=key, obj_type=\"rcparam\", addendum=addendum)\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib as mpl\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "pd.set_option('display.width', 500)\n",
    "pd.set_option('display.max_columns', 100)\n",
    "pd.set_option('display.notebook_repr_html', True)\n",
    "import seaborn.apionly as sns\n",
    "sns.set_style(\"whitegrid\")\n",
    "sns.set_context(\"poster\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "hide": true
   },
   "outputs": [],
   "source": [
    "def make_simple_plot():\n",
    "    fig, axes=plt.subplots(figsize=(12,5), nrows=1, ncols=2);\n",
    "    axes[0].set_ylabel(\"$y$\")\n",
    "    axes[0].set_xlabel(\"$x$\")\n",
    "    axes[1].set_xlabel(\"$x$\")\n",
    "    axes[1].set_yticklabels([])\n",
    "    axes[0].set_ylim([-2,2])\n",
    "    axes[1].set_ylim([-2,2])\n",
    "    plt.tight_layout();\n",
    "    return axes\n",
    "def make_plot():\n",
    "    fig, axes=plt.subplots(figsize=(20,8), nrows=1, ncols=2);\n",
    "    axes[0].set_ylabel(\"$p_R$\")\n",
    "    axes[0].set_xlabel(\"$x$\")\n",
    "    axes[1].set_xlabel(\"$x$\")\n",
    "    axes[1].set_yticklabels([])\n",
    "    axes[0].set_ylim([0,1])\n",
    "    axes[1].set_ylim([0,1])\n",
    "    axes[0].set_xlim([0,1])\n",
    "    axes[1].set_xlim([0,1])\n",
    "    plt.tight_layout();\n",
    "    return axes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PART 1: Reading in and sampling from the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>f</th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.047790</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.011307</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.051199</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.010000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.054799</td>\n",
       "      <td>0.02</td>\n",
       "      <td>0.007237</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.058596</td>\n",
       "      <td>0.03</td>\n",
       "      <td>0.000056</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.062597</td>\n",
       "      <td>0.04</td>\n",
       "      <td>0.010000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          f     x         y\n",
       "0  0.047790  0.00  0.011307\n",
       "1  0.051199  0.01  0.010000\n",
       "2  0.054799  0.02  0.007237\n",
       "3  0.058596  0.03  0.000056\n",
       "4  0.062597  0.04  0.010000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.read_csv(\"data/noisypopulation.csv\")\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x=df.f.values\n",
    "f=df.x.values\n",
    "y = df.y.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200, 3)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From 200 points on this curve, we'll make a random choice of 60 points. We do it by choosing the indexes randomly, and then using these indexes as a way of grtting the appropriate samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   5,   7,  13,  15,  17,  21,  22,  31,  33,  35,  45,  49,\n",
       "        50,  52,  54,  56,  63,  67,  73,  75,  83,  85,  93, 101, 105,\n",
       "       106, 109, 114, 115, 116, 118, 125, 126, 128, 129, 136, 137, 141,\n",
       "       143, 146, 147, 153, 159, 163, 166, 167, 170, 173, 174, 176, 177,\n",
       "       179, 181, 186, 187, 188, 196, 197, 198])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indexes=np.sort(np.random.choice(x.shape[0], size=60, replace=False))\n",
    "indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "samplex = x[indexes]\n",
    "samplef = f[indexes]\n",
    "sampley = y[indexes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "figure_type": "m"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x,f, 'k-', alpha=0.6, label=\"f\");\n",
    "plt.plot(x[indexes], y[indexes], 's', alpha=0.3, ms=10, label=\"in-sample y (observed)\");\n",
    "plt.plot(x, y, '.', alpha=0.8, label=\"population y\");\n",
    "plt.xlabel('$x$');\n",
    "plt.ylabel('$y$')\n",
    "plt.legend(loc=4);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample_df=pd.DataFrame(dict(x=x[indexes],f=f[indexes],y=y[indexes]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Fit on training set and predict on test set\n",
    "\n",
    "We will do the split of testing and training for you in order to illustrate how this can be done.\n",
    "\n",
    "### Train-test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n",
      "(48,)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "datasize=sample_df.shape[0]\n",
    "print(datasize)\n",
    "#split dataset using the index, as we have x,f, and y that we want to split.\n",
    "itrain,itest = train_test_split(np.arange(60),train_size=0.8)\n",
    "print(itrain.shape)\n",
    "xtrain= sample_df.x[itrain].values\n",
    "ftrain = sample_df.f[itrain].values\n",
    "ytrain = sample_df.y[itrain].values\n",
    "xtest= sample_df.x[itest].values\n",
    "ftest = sample_df.f[itest].values\n",
    "ytest = sample_df.y[itest].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.93740313, 0.74749804, 0.5       , 0.86324832, 0.86498738,\n",
       "       0.75811544, 0.30236371, 0.55303512, 0.79915732, 0.61791142,\n",
       "       0.87686794, 0.84900884, 0.263258  , 0.71452966, 0.89736275,\n",
       "       0.7260675 , 0.83285715, 0.28547034, 0.1216725 , 0.80873507,\n",
       "       0.16685535, 0.90319952, 0.79767162, 0.90132828, 0.76641959,\n",
       "       0.8695251 , 0.71136277, 0.0668072 , 0.17532394, 0.13566606,\n",
       "       0.76481781, 0.52657646, 0.62445669, 0.83749401, 0.86433394,\n",
       "       0.86498914, 0.58831352, 0.46017216, 0.47342354, 0.65542174,\n",
       "       0.41754779, 0.70438695, 0.6761895 , 0.94520071, 0.04779035,\n",
       "       0.736742  , 0.10872571, 0.85662853])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_df.x[itrain].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll need to create polynomial features, ie add 1, x, x^2 and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `scikit-learn` interface\n",
    "\n",
    "Scikit-learn is the main python machine learning library. It consists of many learners which can learn models from data, as well as a lot of utility functions such as `train_test_split`. It can be used in python by the incantation `import sklearn`.\n",
    "\n",
    "The library has a very well defined interface. This makes the library a joy to use, and surely contributes to its popularity. As the [scikit-learn API paper](http://arxiv.org/pdf/1309.0238v1.pdf) [Buitinck, Lars, et al. \"API design for machine learning software: experiences from the scikit-learn project.\" arXiv preprint arXiv:1309.0238 (2013).] says:\n",
    "\n",
    ">All objects within scikit-learn share a uniform common basic API consisting of three complementary interfaces: **an estimator interface for building and ﬁtting models, a predictor interface for making predictions and a transformer interface for converting data**. The estimator interface is at the core of the library. It deﬁnes instantiation mechanisms of objects and exposes a `fit` method for learning a model from training data. All supervised and unsupervised learning algorithms (e.g., for classiﬁcation, regression or clustering) are oﬀered as objects implementing this interface. Machine learning tasks like feature extraction, feature selection or dimensionality reduction are also provided as estimators.\n",
    "\n",
    "We'll use the \"estimator\" interface here, specifically the estimator `PolynomialFeatures`. The API paper again:\n",
    "\n",
    ">Since it is common to modify or ﬁlter data before feeding it to a learning algorithm, some estimators in the library implement a transformer interface which deﬁnes a transform method. It takes as input some new data X and yields as output a transformed version of X. Preprocessing, feature selection, feature extraction and dimensionality reduction algorithms are all provided as transformers within the library.\n",
    "\n",
    "To start with we have one **feature** `x` to predict `y`, what we will do is the transformation:\n",
    "\n",
    "$$ x \\rightarrow 1, x, x^2, x^3, ..., x^d $$\n",
    "\n",
    "for some power $d$. Our job then is to **fit** for the coefficients of these features in the polynomial\n",
    "\n",
    "$$ a_0 + a_1 x + a_2 x^2 + ... + a_d x^d. $$\n",
    "\n",
    "In other words, we have transformed a function of one feature, into a (rather simple) **linear** function of many features. To do this we first construct the estimator as `PolynomialFeatures(d)`, and then transform these features into a d-dimensional space using the method `fit_transform`.\n",
    "\n",
    "![fit_transform](images/sklearntrans.jpg)\n",
    "\n",
    "Here is an example. The reason for using `[[1],[2],[3]]` as opposed to `[1,2,3]` is that scikit-learn expects data to be stored in a two-dimensional array or matrix with size `[n_samples, n_features]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1,2,3]).reshape(-1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To transform `[1,2,3]` into [[1],[2],[3]] we need to do a reshape.\n",
    "\n",
    "![reshape](images/reshape.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.77741499],\n",
       "       [0.94140369],\n",
       "       [0.64306616],\n",
       "       [0.726772  ],\n",
       "       [0.49278995],\n",
       "       [0.69392487],\n",
       "       [0.79483368],\n",
       "       [0.78974405],\n",
       "       [0.75803635],\n",
       "       [0.77836014],\n",
       "       [0.84927603],\n",
       "       [0.0758813 ]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xtest.reshape(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "//anaconda/envs/py3l/lib/python3.6/site-packages/sklearn/utils/validation.py:395: DeprecationWarning: Passing 1d arrays as data is deprecated in 0.17 and will raise ValueError in 0.19. Reshape your data either using X.reshape(-1, 1) if your data has a single feature or X.reshape(1, -1) if it contains a single sample.\n",
      "  DeprecationWarning)\n",
      "//anaconda/envs/py3l/lib/python3.6/site-packages/sklearn/utils/validation.py:395: DeprecationWarning: Passing 1d arrays as data is deprecated in 0.17 and will raise ValueError in 0.19. Reshape your data either using X.reshape(-1, 1) if your data has a single feature or X.reshape(1, -1) if it contains a single sample.\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1.00000000e+00, 7.77414988e-01, 9.41403687e-01, 6.43066163e-01,\n",
       "        7.26772002e-01, 4.92789947e-01, 6.93924870e-01, 7.94833680e-01,\n",
       "        7.89744050e-01, 7.58036348e-01, 7.78360136e-01, 8.49276033e-01,\n",
       "        7.58813002e-02, 6.04374064e-01, 7.31861336e-01, 4.99929274e-01,\n",
       "        5.65003448e-01, 3.83102291e-01, 5.39467595e-01, 6.17915616e-01,\n",
       "        6.13958861e-01, 5.89308818e-01, 6.05108836e-01, 6.60239918e-01,\n",
       "        5.89912601e-02, 8.86240902e-01, 6.05384857e-01, 6.84185843e-01,\n",
       "        4.63914273e-01, 6.53263431e-01, 7.48259357e-01, 7.43467960e-01,\n",
       "        7.13618213e-01, 7.32751102e-01, 7.99511589e-01, 7.14349358e-02,\n",
       "        4.13534090e-01, 4.67362483e-01, 3.16896540e-01, 4.46239604e-01,\n",
       "        5.11130645e-01, 5.07857676e-01, 4.87467526e-01, 5.00537067e-01,\n",
       "        5.46140680e-01, 4.87966966e-02, 5.28197544e-01, 3.58145936e-01,\n",
       "        5.04325167e-01, 5.77662865e-01, 5.73963865e-01, 5.50919594e-01,\n",
       "        5.65690355e-01, 6.17230043e-01, 5.51484045e-02, 2.42841931e-01,\n",
       "        3.41959200e-01, 3.91686047e-01, 3.89177928e-01, 3.73552691e-01,\n",
       "        3.83568050e-01, 4.18514691e-01, 3.73935419e-02, 4.81531725e-01,\n",
       "        5.51554858e-01, 5.48023037e-01, 5.26020274e-01, 5.40123457e-01,\n",
       "        5.89333761e-01, 5.26559214e-02, 6.31760579e-01, 6.27715169e-01,\n",
       "        6.02512820e-01, 6.18666851e-01, 6.75033195e-01, 6.03130130e-02,\n",
       "        6.23695664e-01, 5.98654695e-01, 6.14705286e-01, 6.70710694e-01,\n",
       "        5.99268053e-02, 5.74619105e-01, 5.90025275e-01, 6.43782103e-01,\n",
       "        5.75207836e-02, 6.05844502e-01, 6.61042609e-01, 5.90629792e-02,\n",
       "        7.21269781e-01, 6.44441696e-02, 5.75797172e-03, 4.69849456e-01,\n",
       "        5.68959972e-01, 3.88652510e-01, 4.39242149e-01, 2.97829463e-01,\n",
       "        4.19390194e-01, 4.80376861e-01, 4.77300821e-01, 4.58137508e-01,\n",
       "        4.70420679e-01, 5.13280408e-01, 4.58606898e-02, 6.88976960e-01,\n",
       "        4.70635262e-01, 5.31896329e-01, 3.60653909e-01, 5.07856783e-01,\n",
       "        5.81708039e-01, 5.77983136e-01, 5.54777494e-01, 5.69651690e-01,\n",
       "        6.21552293e-01, 5.55345897e-02, 3.21487600e-01, 3.63334599e-01,\n",
       "        2.46360120e-01, 3.46913356e-01, 3.97360624e-01, 3.94816169e-01,\n",
       "        3.78964561e-01, 3.89125018e-01, 4.24577951e-01, 3.79352833e-02,\n",
       "        4.10628687e-01, 2.78428019e-01, 3.92069944e-01, 4.49083769e-01,\n",
       "        4.46208111e-01, 4.28293150e-01, 4.39776161e-01, 4.79843887e-01,\n",
       "        4.28731962e-02, 1.88788957e-01, 2.65844207e-01, 3.04502603e-01,\n",
       "        3.02552754e-01, 2.90405461e-01, 2.98191551e-01, 3.25359594e-01,\n",
       "        2.90702999e-02, 3.74349981e-01, 4.28787013e-01, 4.26041323e-01,\n",
       "        4.08936045e-01, 4.19900071e-01, 4.58156899e-01, 4.09355025e-02,\n",
       "        4.91140143e-01, 4.87995181e-01, 4.68402497e-01, 4.80960883e-01,\n",
       "        5.24780923e-01, 4.68882403e-02, 4.84870358e-01, 4.65403133e-01,\n",
       "        4.77881103e-01, 5.21420546e-01, 4.65879966e-02, 4.46717504e-01,\n",
       "        4.58694492e-01, 5.00485856e-01, 4.47175193e-02, 4.70992596e-01,\n",
       "        5.13904432e-01, 4.59164452e-02, 5.60725938e-01, 5.00998634e-02,\n",
       "        4.47633351e-03, 8.34310453e-01, 5.69911536e-01, 6.44095075e-01,\n",
       "        4.36730607e-01, 6.14984603e-01, 7.04414117e-01, 6.99903479e-01,\n",
       "        6.71802816e-01, 6.89814589e-01, 7.52663158e-01, 6.72491119e-02,\n",
       "        3.89302517e-01, 4.39976765e-01, 2.98327571e-01, 4.20091608e-01,\n",
       "        4.81180274e-01, 4.78099089e-01, 4.58903726e-01, 4.71207440e-01,\n",
       "        5.14138850e-01, 4.59373901e-02, 4.97247115e-01, 3.37159905e-01,\n",
       "        4.74773572e-01, 5.43813951e-01, 5.40331698e-01, 5.18637737e-01,\n",
       "        5.32542986e-01, 5.81062639e-01, 5.19169113e-02, 2.28612290e-01,\n",
       "        3.21921651e-01, 3.68734688e-01, 3.66373536e-01, 3.51663881e-01,\n",
       "        3.61092377e-01, 3.93991273e-01, 3.52024182e-02, 4.53315742e-01,\n",
       "        5.19235777e-01, 5.15910908e-01, 4.95197426e-01, 5.08474213e-01,\n",
       "        5.54800976e-01, 4.95704785e-02, 5.94741738e-01, 5.90933375e-01,\n",
       "        5.67207790e-01, 5.82415255e-01, 6.35478738e-01, 5.67788929e-02,\n",
       "        5.87149398e-01, 5.63575737e-01, 5.78685823e-01, 6.31409520e-01,\n",
       "        5.64153155e-02, 5.40948544e-01, 5.55451969e-01, 6.06058845e-01,\n",
       "        5.41502778e-02, 5.70344248e-01, 6.22307950e-01, 5.56021063e-02,\n",
       "        6.79006031e-01, 6.06679789e-02, 5.42057580e-03, 2.65929781e-01,\n",
       "        3.00544999e-01, 2.03785442e-01, 2.86961590e-01, 3.28690823e-01,\n",
       "        3.26586087e-01, 3.13473872e-01, 3.21878451e-01, 3.51204592e-01,\n",
       "        3.13795044e-02, 3.39665968e-01, 2.30311533e-01, 3.24314450e-01,\n",
       "        3.71475442e-01, 3.69096740e-01, 3.54277750e-01, 3.63776326e-01,\n",
       "        3.96919756e-01, 3.54640729e-02, 1.56163429e-01, 2.19902391e-01,\n",
       "        2.51880043e-01, 2.50267157e-01, 2.40219096e-01, 2.46659634e-01,\n",
       "        2.69132637e-01, 2.40465215e-02, 3.09656759e-01, 3.54686266e-01,\n",
       "        3.52415072e-01, 3.38265840e-01, 3.47335119e-01, 3.78980601e-01,\n",
       "        3.38612413e-02, 4.06263851e-01, 4.03662386e-01, 3.87455607e-01,\n",
       "        3.97843719e-01, 4.34091007e-01, 3.87852579e-02, 4.01077578e-01,\n",
       "        3.84974578e-01, 3.95296170e-01, 4.31311353e-01, 3.85369008e-02,\n",
       "        3.69518103e-01, 3.79425290e-01, 4.13994487e-01, 3.69896696e-02,\n",
       "        3.89598099e-01, 4.25094134e-01, 3.79814034e-02, 4.63824191e-01,\n",
       "        4.14418649e-02, 3.70275678e-03, 3.83879186e-01, 2.60290439e-01,\n",
       "        3.66529412e-01, 4.19829197e-01, 4.17140867e-01, 4.00392937e-01,\n",
       "        4.11127912e-01, 4.48585515e-01, 4.00803164e-02, 1.76490717e-01,\n",
       "        2.48526372e-01, 2.84666452e-01, 2.82843622e-01, 2.71487638e-01,\n",
       "        2.78766520e-01, 3.04164760e-01, 2.71765793e-02, 3.49963776e-01,\n",
       "        4.00854629e-01, 3.98287800e-01, 3.82296808e-01, 3.92546606e-01,\n",
       "        4.28311278e-01, 3.82688494e-02, 4.59145901e-01, 4.56205811e-01,\n",
       "        4.37889448e-01, 4.49629746e-01, 4.90595227e-01, 4.38338093e-02,\n",
       "        4.53284547e-01, 4.35085472e-01, 4.46750592e-01, 4.87453754e-01,\n",
       "        4.35531243e-02, 4.17617077e-01, 4.28813851e-01, 4.67882808e-01,\n",
       "        4.18044951e-02, 4.40310822e-01, 4.80427261e-01, 4.29253196e-02,\n",
       "        5.24198683e-01, 4.68362182e-02, 4.18473263e-03, 1.19670062e-01,\n",
       "        1.68514056e-01, 1.93018946e-01, 1.91782970e-01, 1.84083011e-01,\n",
       "        1.89018479e-01, 2.06239832e-01, 1.84271615e-02, 2.37293993e-01,\n",
       "        2.71800689e-01, 2.70060243e-01, 2.59217503e-01, 2.66167409e-01,\n",
       "        2.90417753e-01, 2.59483087e-02, 3.11325262e-01, 3.09331725e-01,\n",
       "        2.96912260e-01, 3.04872805e-01, 3.32649572e-01, 2.97216465e-02,\n",
       "        3.07350953e-01, 2.95011015e-01, 3.02920585e-01, 3.30519487e-01,\n",
       "        2.95313272e-02, 2.83166518e-01, 2.90758524e-01, 3.17249348e-01,\n",
       "        2.83456639e-02, 2.98554080e-01, 3.25755152e-01, 2.91056423e-02,\n",
       "        3.55434497e-01, 3.17574389e-02, 2.83747057e-03, 3.34146840e-01,\n",
       "        3.82737633e-01, 3.80286815e-01, 3.65018550e-01, 3.74805100e-01,\n",
       "        4.08953354e-01, 3.65392534e-02, 4.38394377e-01, 4.35587167e-01,\n",
       "        4.18098630e-01, 4.29308315e-01, 4.68422322e-01, 4.18526997e-02,\n",
       "        4.32797933e-01, 4.15421382e-01, 4.26559286e-01, 4.65422831e-01,\n",
       "        4.15847006e-02, 3.98742488e-01, 4.09433212e-01, 4.46736412e-01,\n",
       "        3.99151023e-02, 4.20410567e-01, 4.58713907e-01, 4.09852701e-02,\n",
       "        5.00507039e-01, 4.47194120e-02, 3.99559978e-03, 5.02144585e-01,\n",
       "        4.98929158e-01, 4.78897482e-01, 4.91737250e-01, 5.36539118e-01,\n",
       "        4.79388141e-02, 4.95734320e-01, 4.75830914e-01, 4.88588465e-01,\n",
       "        5.33103449e-01, 4.76318432e-02, 4.56726617e-01, 4.68971961e-01,\n",
       "        5.11699698e-01, 4.57194561e-02, 4.81545615e-01, 5.25418930e-01,\n",
       "        4.69452451e-02, 5.73289514e-01, 5.12223965e-02, 4.57662985e-03,\n",
       "        4.92559940e-01, 4.72783984e-01, 4.85459842e-01, 5.29689780e-01,\n",
       "        4.73268379e-02, 4.53802019e-01, 4.65968950e-01, 5.08423085e-01,\n",
       "        4.54266966e-02, 4.78462091e-01, 5.22054467e-01, 4.66446364e-02,\n",
       "        5.69618518e-01, 5.08943995e-02, 4.54732390e-03, 4.35582167e-01,\n",
       "        4.47260605e-01, 4.88010234e-01, 4.36028448e-02, 4.59252154e-01,\n",
       "        5.01094325e-01, 4.47718850e-02, 5.46748711e-01, 4.88510230e-02,\n",
       "        4.36475185e-03, 4.71565209e-01, 5.14529216e-01, 4.59722685e-02,\n",
       "        5.61407645e-01, 5.01607727e-02, 4.48177565e-03, 6.12557139e-01,\n",
       "        5.47308888e-02, 4.89010738e-03, 4.36922380e-04]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PolynomialFeatures(3).fit_transform(xtest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.00000000e+00, 7.77414988e-01, 6.04374064e-01, 4.69849456e-01],\n",
       "       [1.00000000e+00, 9.41403687e-01, 8.86240902e-01, 8.34310453e-01],\n",
       "       [1.00000000e+00, 6.43066163e-01, 4.13534090e-01, 2.65929781e-01],\n",
       "       [1.00000000e+00, 7.26772002e-01, 5.28197544e-01, 3.83879186e-01],\n",
       "       [1.00000000e+00, 4.92789947e-01, 2.42841931e-01, 1.19670062e-01],\n",
       "       [1.00000000e+00, 6.93924870e-01, 4.81531725e-01, 3.34146840e-01],\n",
       "       [1.00000000e+00, 7.94833680e-01, 6.31760579e-01, 5.02144585e-01],\n",
       "       [1.00000000e+00, 7.89744050e-01, 6.23695664e-01, 4.92559940e-01],\n",
       "       [1.00000000e+00, 7.58036348e-01, 5.74619105e-01, 4.35582167e-01],\n",
       "       [1.00000000e+00, 7.78360136e-01, 6.05844502e-01, 4.71565209e-01],\n",
       "       [1.00000000e+00, 8.49276033e-01, 7.21269781e-01, 6.12557139e-01],\n",
       "       [1.00000000e+00, 7.58813002e-02, 5.75797172e-03, 4.36922380e-04]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PolynomialFeatures(3).fit_transform(xtest.reshape(-1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Polynomial features\n",
    "\n",
    "We'll write a function to encapsulate what we learnt about creating the polynomial features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def make_features(train_set, test_set, degrees):\n",
    "    train_dict = {}\n",
    "    test_dict = {}\n",
    "    for d in degrees:\n",
    "        traintestdict={}\n",
    "        train_dict[d] = PolynomialFeatures(d).fit_transform(train_set.reshape(-1,1))\n",
    "        test_dict[d] = PolynomialFeatures(d).fit_transform(test_set.reshape(-1,1))\n",
    "    return train_dict, test_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Doing the fit\n",
    "\n",
    "We first create our features, and some arrays to store the errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "degrees=range(21)\n",
    "train_dict, test_dict = make_features(xtrain, xtest, degrees)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "error_train=np.empty(len(degrees))\n",
    "error_test=np.empty(len(degrees))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the fitting process? We first loop over all the **hypothesis set**s that we wish to consider: in our case this is a loop over the complexity parameter $d$, the degree of the polynomials we will try and fit. That is we start with ${\\cal H_0}$, the set of all 0th order polynomials, then do ${\\cal H_1}$, then ${\\cal H_2}$, and so on... We use the notation ${\\cal H}$ to indicate a hypothesis set. Then for each degree $d$, we obtain a best fit model. We then \"test\" this model by predicting on the test chunk, obtaining the test set error for the best-fit polynomial coefficients and for degree $d$. We move on to the next degree $d$ and repeat the process, just like before. We compare all the test set errors, and pick the degree $d_*$ and the model in ${\\cal H_{d_*}}$ which minimizes this test set error.\n",
    "\n",
    ">**YOUR TURN HERE**: For each degree d, train on the training set and predict on the test set. Store the training MSE in `error_train` and test MSE in `error_test`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#for each degree, we now fit on the training set and predict on the test set\n",
    "#we accumulate the MSE on both sets in error_train and error_test\n",
    "for d in degrees:#for increasing polynomial degrees 0,1,2...\n",
    "    Xtrain = train_dict[d]\n",
    "    Xtest = test_dict[d]\n",
    "    #set up model\n",
    "    est = LinearRegression()\n",
    "    #fit\n",
    "    est.fit(Xtrain, ytrain)\n",
    "    #predict\n",
    "    #your code here\n",
    "    prediction_on_training = est.predict(Xtrain)\n",
    "    prediction_on_test = est.predict(Xtest)\n",
    "    #calculate mean squared error\n",
    "    error_train[d] = mean_squared_error(ytrain, prediction_on_training)\n",
    "    error_test[d] = mean_squared_error(ytest, prediction_on_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can find the best degree thus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bestd = np.argmin(error_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(degrees, error_train, marker='o', label='train (in-sample)')\n",
    "plt.plot(degrees, error_test, marker='o', label='test')\n",
    "plt.axvline(bestd, 0,0.5, color='r', label=\"min test error at d=%d\"%bestd, alpha=0.3)\n",
    "plt.ylabel('mean squared error')\n",
    "plt.xlabel('degree')\n",
    "plt.legend(loc='upper left')\n",
    "plt.yscale(\"log\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![m:caption](images/complexity-error-plot.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we have done in picking a given $d$ as the best hypothesis is that we have used the test set as a training set. \n",
    "If we choose the best $d$ based on minimizing the test set error, we have then \"fit for\" hyperparameter $d$ on the test set. \n",
    "\n",
    "In this case, the test-set error will underestimate the true out of sample error. Furthermore, we have **contaminated the test set** by fitting for $d$ on it; it is no longer a true test set.\n",
    "\n",
    "Thus, we introduce a new **validation set** on which the complexity parameter $d$ is fit, and leave out a test set which we can use to estimate the true out-of-sample performance of our learner. The place of this set in the scheme of things is shown below:\n",
    "\n",
    "![m:caption](images/train-validate-test.png)\n",
    "\n",
    "We have split the old training set into a **new smaller training set** and a **validation set**, holding the old test aside for FINAL testing AFTER we have \"fit\" for complexity $d$. Obviously we have decreased the size of the data available for training further, but this is a price we must pay for obtaining a good estimate of the out-of-sample risk $\\cal{E}_{out}$ (also denoted as risk $R_{out}$) through the test risk $\\cal{E}_{test}$ ($R_{test}$).\n",
    "\n",
    "![m:caption](images/train-validate-test-cont.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The validation process is illustrated in these two figures. We first loop over the complexity parameter $d$, the degree of the polynomials we will try and fit. Then for each degree $d$, we obtain a best fit model $g^-_d$ where the \"minus\" superscript indicates that we fit our model on the new training set which is obtained by removing (\"minusing\") a validation chunk (often the same size as the test chunk) from the old training set. We then \"test\" this model on the validation chunk, obtaining the validation error for the best-fit polynomial coefficients and for degree $d$. We move on to the next degree $d$ and repeat the process, just like before. We compare all the validation set errors, just like we did with the test errors earlier, and pick the degree $d_*$ which minimizes this validation set error.\n",
    "\n",
    "![caption](images/train-validate-test3.png)\n",
    "\n",
    "Having picked the hyperparameter $d_*$, we retrain using the hypothesis set $\\cal{H}_{*}$ on the entire old training-set to find the parameters of the polynomial of order $d_*$ and the corresponding best fit hypothesis $g_*$. Note that we left the minus off the $g$ to indicate that it was trained on the entire old traing set. We now compute the test error on the test set as an estimate of the test risk $\\cal{E}_{test}$.\n",
    "\n",
    "Thus the **validation** set if the set on which the hyperparameter is fit. This method of splitting the data $\\cal{D}$ is called the **train-validate-test** split."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fit on training and predict on validation\n",
    "\n",
    "\n",
    "We carry out this process for one training/validation split below. Note the smaller size of the new training set. We hold the test set at the same size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#we split the training set down further\n",
    "intrain,invalid = train_test_split(itrain,train_size=36, test_size=12)\n",
    "# why not just use xtrain, xtest here? its the indices we need. How could you use xtrain and xtest?\n",
    "xntrain= sample_df.x[intrain].values\n",
    "fntrain = sample_df.f[intrain].values\n",
    "yntrain = sample_df.y[intrain].values\n",
    "xnvalid= sample_df.x[invalid].values\n",
    "fnvalid = sample_df.f[invalid].values\n",
    "ynvalid = sample_df.y[invalid].values\n",
    "\n",
    "degrees=range(21)\n",
    "train_dict, valid_dict = make_features(xntrain, xnvalid, degrees)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    ">YOUR TURN HERE: Train on the smaller training set. Fit for d on the validation set.  Store the respective MSEs in `error_train` and `error_valid`. Then retrain on the entire training set using this d. Label the test set MSE with the variable `err`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "error_train=np.empty(len(degrees))\n",
    "error_valid=np.empty(len(degrees))\n",
    "#for each degree, we now fit on the smaller training set and predict on the validation set\n",
    "#we accumulate the MSE on both sets in error_train and error_valid\n",
    "#we then find the degree of polynomial that minimizes the MSE on the validation set.\n",
    "#your code here\n",
    "for d in degrees:#for increasing polynomial degrees 0,1,2...\n",
    "    #Create polynomials from x\n",
    "    Xntrain = train_dict[d]\n",
    "    Xnvalid = valid_dict[d]\n",
    "    #fit a model linear in polynomial coefficients on the new smaller training set\n",
    "    est = LinearRegression()\n",
    "    est.fit(Xntrain, yntrain)\n",
    "    #predict on new training and validation sets and calculate mean squared error\n",
    "    error_train[d] = mean_squared_error(yntrain, est.predict(Xntrain))\n",
    "    error_valid[d] = mean_squared_error(ynvalid, est.predict(Xnvalid))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#calculate the degree at which validation error is minimized\n",
    "mindeg = np.argmin(error_valid)\n",
    "mindeg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#fit on WHOLE training set now. \n",
    "##you will need to remake polynomial features on the whole training set\n",
    "#Put MSE on the test set in variable err.\n",
    "#your code here\n",
    "postvalid_train_dict, test_dict = make_features(xtrain, xtest, degrees)\n",
    "features_at_mindeg = postvalid_train_dict[mindeg]\n",
    "test_features_at_mindeg = test_dict[mindeg]\n",
    "est = LinearRegression()\n",
    "est.fit(features_at_mindeg, ytrain) # fit\n",
    "#predict on the test set now and calculate error\n",
    "pred = est.predict(test_features_at_mindeg)\n",
    "err = mean_squared_error(ytest, pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We plot the training error and validation error against the degree of the polynomial, and show the test set error at the $d$ which minimizes the validation set error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(degrees, error_train, marker='o', label='train (in-sample)')\n",
    "plt.plot(degrees, error_valid, marker='o', label='validation')\n",
    "plt.plot([mindeg], [err], marker='s', markersize=10, label='test', alpha=0.5, color='r')\n",
    "plt.ylabel('mean squared error')\n",
    "plt.xlabel('degree')\n",
    "plt.legend(loc='upper left')\n",
    "plt.yscale(\"log\")\n",
    "print(mindeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> YOUR TURN HERE: Run the set of cells for the validation process again and again. What do you see? The validation error minimizing polynomial degree might change! What happened?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross Validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. You should worry that a given split exposes us to the peculiarity of the data set that got randomly chosen for us. This naturally leads us to want to choose multiple such random splits and somehow average over this process to find the \"best\" validation minimizing polynomial degree or complexity $d$.\n",
    "2. The multiple splits process also allows us to get an estimate of how consistent our prediction error is: in other words, just like in the hair example, it gives us a distribution.\n",
    "3. Furthermore the validation set that we left out has two competing demands on it. The larger the set is, the better is our estimate of the out-of-sample error. So we'd like to hold out as much as possible. But the smaller the validation set is, the more data we have to train our model on. This allows us to have more smaller sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The idea is illustrated in the figure below, for a given hypothesis set $\\cal{H}_a$ with complexity parameter $d=a$ (the polynomial degree). We do the train/validate split, not once but multiple times. \n",
    "\n",
    "In the figure below we create 4-folds from the training set part of our data set $\\cal{D}$. By this we mean that we divide our set roughly into 4 equal parts. As illustrated below, this can be done in 4 different ways, or folds. In each fold we train a model on 3 of the parts. The model so trained is denoted as $g^-_{Fi}$, for example $g^-_{F3}$ . The minus sign in the superscript once again indicates that we are training on a reduced set. The $F3$ indicates that this model was trained on the third fold. Note that the model trained on each fold will be different!\n",
    "\n",
    "For each fold, after training the model, we calculate the risk or error on the remaining one validation part. We then add the validation errors together from the different folds, and divide by the number of folds to calculate an average error. Note again that this average error is an average over different models $g^-_{Fi}$. We use this error as the validation error for $d=a$ in the validation process described earlier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![m:caption](images/train-cv2.png)\n",
    "\n",
    "Note that the number of folds is equal to the number of splits in the data. For example, if we have 5 splits, there will be 5 folds. To illustrate cross-validation consider below fits in $\\cal{H}_0$ and $\\cal{H}_1$ (means and straight lines) to a sine curve, with only 3 data points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The entire description of K-fold Cross-validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We put thogether this scheme to calculate the error for a given polynomial degree $d$ with the method we used earlier to choose a model given the validation-set risk as a function of $d$:\n",
    "\n",
    "1. create `n_folds` partitions of the training data. \n",
    "2. We then train on `n_folds -1` of these partitions, and test on the remaining partition. There are `n_folds` such combinations of partitions (or folds), and thus we obtain `n_fold` risks.\n",
    "3. We average the error or risk of all such combinations to obtain, for each value of $d$, $R_{dCV}$.\n",
    "4. We move on to the next value of $d$, and repeat 3\n",
    "5. and then find the optimal value of d that minimizes risk $d=*$.\n",
    "5. We finally use that value to make the final fit in $\\cal{H}_*$ on the entire old training set.\n",
    "\n",
    "![caption](images/train-cv3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can also shown that **cross-validation error is an unbiased estimate of the out of sample-error**.\n",
    "\n",
    "Let us now do 4-fold cross-validation on our  data set. We increase the complexity from degree 0 to degree 20. In each case we take the old training set, split in 4 ways into 4 folds, train on 3 folds, and calculate the validation error on the remaining one. We then average the erros over the four folds to get a cross-validation error for that $d$. Then we did what we did before: find the hypothesis space $\\cal{H}_*$ with the lowest cross-validation error, and refit it using the entire training set. We can then use the test set to estimate $E_{out}$.\n",
    "\n",
    "We will use `KFold` from `scikit-learn`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(array([12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,\n",
       "         29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,\n",
       "         46, 47]), array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])),\n",
       " (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 24, 25, 26, 27, 28,\n",
       "         29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,\n",
       "         46, 47]), array([12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23])),\n",
       " (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "         17, 18, 19, 20, 21, 22, 23, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,\n",
       "         46, 47]), array([24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35])),\n",
       " (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "         17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n",
       "         34, 35]), array([36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]))]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "n_folds=4\n",
    "kfold = KFold(n_folds)\n",
    "list(kfold.split(range(48)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is wrong with the above? Why must we do the below?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(array([ 0,  1,  2,  3,  5,  6,  7,  8,  9, 10, 11, 12, 14, 16, 18, 19, 20,\n",
       "         21, 22, 23, 24, 25, 26, 30, 31, 32, 33, 34, 36, 37, 40, 41, 42, 43,\n",
       "         44, 45]), array([ 4, 13, 15, 17, 27, 28, 29, 35, 38, 39, 46, 47])),\n",
       " (array([ 0,  1,  2,  3,  4,  5,  6,  8,  9, 10, 11, 13, 14, 15, 17, 18, 20,\n",
       "         21, 22, 23, 24, 25, 27, 28, 29, 31, 34, 35, 38, 39, 41, 42, 44, 45,\n",
       "         46, 47]), array([ 7, 12, 16, 19, 26, 30, 32, 33, 36, 37, 40, 43])),\n",
       " (array([ 0,  2,  3,  4,  5,  7,  8,  9, 10, 12, 13, 14, 15, 16, 17, 18, 19,\n",
       "         20, 26, 27, 28, 29, 30, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43,\n",
       "         46, 47]), array([ 1,  6, 11, 21, 22, 23, 24, 25, 31, 42, 44, 45])),\n",
       " (array([ 1,  4,  6,  7, 11, 12, 13, 15, 16, 17, 19, 21, 22, 23, 24, 25, 26,\n",
       "         27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39, 40, 42, 43, 44, 45,\n",
       "         46, 47]), array([ 0,  2,  3,  5,  8,  9, 10, 14, 18, 20, 34, 41]))]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kfold = KFold(n_folds, shuffle=True)\n",
    "list(kfold.split(range(48)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4-fold CV on our data set\n",
    "\n",
    ">YOUR TURN HERE: Carry out 4-Fold validation. For each fold, you will need to first create the polynomial features. for each degree polynomial, fit on the smaller training set and predict on the validation set. Store the MSEs, for each degree and each fold, in `train_errors` and `valid_errors`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n_folds=4\n",
    "degrees=range(21)\n",
    "train_errors = np.zeros((21,4))\n",
    "valid_errors = np.zeros((21,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "fold = 0\n",
    "for train, valid in KFold(n_folds, shuffle=True).split(range(48)): # split data into train/test groups, 4 times\n",
    "    train_dict, valid_dict = make_features(xtrain[train], xtrain[valid], degrees)\n",
    "    for d in degrees:\n",
    "        est = LinearRegression()\n",
    "        est.fit(train_dict[d], ytrain[train]) # fit\n",
    "        train_errors[d, fold] = mean_squared_error(ytrain[train], est.predict(train_dict[d])) # evaluate score function on held-out data\n",
    "        valid_errors[d, fold] = mean_squared_error(ytrain[valid], est.predict(valid_dict[d])) # evaluate score function on held-out data\n",
    "    fold += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We average the MSEs over the folds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mean_train_errors = train_errors.mean(axis=1)\n",
    "mean_valid_errors = valid_errors.mean(axis=1)\n",
    "std_train_errors = train_errors.std(axis=1)\n",
    "std_valid_errors = valid_errors.std(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We find the degree that minimizes the `cross-validation` error, and just like before, refit the model on the entire training set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mindeg = np.argmin(mean_valid_errors)\n",
    "print(mindeg)\n",
    "post_cv_train_dict, test_dict=make_features(xtrain, xtest, degrees)\n",
    "#fit on whole training set now.\n",
    "est = LinearRegression()\n",
    "est.fit(post_cv_train_dict[mindeg], ytrain) # fit\n",
    "pred = est.predict(test_dict[mindeg])\n",
    "err = mean_squared_error(pred, ytest)\n",
    "errtr=mean_squared_error(ytrain, est.predict(post_cv_train_dict[mindeg]))\n",
    "c0=sns.color_palette()[0]\n",
    "c1=sns.color_palette()[1]\n",
    "#plt.errorbar(degrees, [r[0] for r in results], yerr=[r[3] for r in results], marker='o', label='CV error', alpha=0.5)\n",
    "plt.plot(degrees, mean_train_errors, marker='o', label='CV error', alpha=0.9)\n",
    "plt.plot(degrees, mean_valid_errors, marker='o', label='CV error', alpha=0.9)\n",
    "\n",
    "\n",
    "plt.fill_between(degrees, mean_valid_errors-std_valid_errors, mean_valid_errors+std_valid_errors, color=c1, alpha=0.2)\n",
    "\n",
    "\n",
    "plt.plot([mindeg], [err], 'o',  label='test set error')\n",
    "\n",
    "plt.ylabel('mean squared error')\n",
    "plt.xlabel('degree')\n",
    "plt.legend(loc='upper right')\n",
    "plt.yscale(\"log\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the cross-validation error minimizes at a low degree, and then increases. Because we have so few data points the spread in fold errors increases as well."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}