bearml/basics/splitting_tutorial_1_nb.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Tutorial for Splitting Datasets - Part 1\n",
    "\n",
    "In this tutorial we investigate the concept of splitting data in multiple\n",
    "partitions using pandas dataframes. The presented concepts are intensified\n",
    "in a practical example, where a function is approximated using polynomial regression.\n",
    "\n",
    "|                  |                                                                                                                                                                                                                                                                  |\n",
    "|------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n",
    "| Requirements   \t | \t- Basic python skills                                                                                                                                                                                                                                           |\n",
    "| Learning Goals \t | \t- Understanding basics of a pandas dataframe <br/>- Concept of splitting data into multiple partitions <br/>- Various splitting strategies for dataframes. <br/>- Understanding cross-validation <br/>- Application of cross-validation in a practical use-case |\n",
    "| Limitations    \t | - The tutorial only handles pandas dataframes and a numpy array in the practical use-case.                                                                                                                                                                       |\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.054105913Z",
     "start_time": "2023-05-17T12:58:47.338798567Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Splitting a Pandas Dataframe\n",
    "\n",
    "The most basic form of a \"dataset\" is a simple pandas dataframe.\n",
    "This is solely suitable for tabular data and only if it fits in memory.\n",
    "However, we can still use this to demonstrate the basic concepts on how to split a dataset\n",
    "so that a proper and reproducible evaluation is possible.\n",
    "\n",
    "First, let's create a dummy dataframe, which has two columns: 1x dummy feature and 1x dummy labels with a ratio of 75/25 aka 25% positive labels."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   feat  label\n",
      "0     0      0\n",
      "1     1      0\n",
      "2     2      0\n",
      "3     3      0\n",
      "4     4      0\n"
     ]
    }
   ],
   "source": [
    "df = pd.DataFrame({\n",
    "    'feat': list(range(100)),\n",
    "    'label': [0] * 75 + [1] * 25\n",
    "})\n",
    "\n",
    "print(df.head())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.066629974Z",
     "start_time": "2023-05-17T12:58:48.058166648Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Generally, we start of with the concept of splitting our dataframe into two partitions: `train` and `test`.\n",
    "Later, we'll introduce the concept of `train`, `validation` and `test` splits.\n",
    "\n",
    "An easy way to split an indexable data structure into two partitions and avoid shuffling is by creating a permuted array containing indices. After determining the desired partition sizes, these indices can be used to collect data from the dataframe.\n",
    "In this example we do an 80/20 split, which implies that a fifth of the full dataframe is reserved for evaluation.\n",
    "\n",
    "A dataframe can be sliced by the `.iloc` method, whereas numpy or torch do not need this specification when performing index selection.\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Permuted indices:  [83 57  7 45 50 39 90 54 12 65 76 62 71 44 14 37 73 67  5 84 87 26 52 27\n",
      " 85  0 88  9 86 31 55 20 63 15 33 79 24 78  4 21  8  6 11 42  2 82 96 58\n",
      " 56 34 47 68 29 80 25 35 97 48 46 10 51 92 36 98  3 95 94 18 41 91 89 81\n",
      " 72 53 60 93 70 16 32 17 13 30 75 43 99 28  1 66 61 19 40 49 59 23 38 22\n",
      " 64 69 77 74]\n"
     ]
    }
   ],
   "source": [
    "idxs = np.random.permutation(len(df))\n",
    "print('Permuted indices: ', idxs)\n",
    "\n",
    "train_size = 0.8\n",
    "train_idxs = idxs[:int(len(idxs) * train_size)]\n",
    "test_idxs = idxs[int(len(idxs) * train_size):]\n",
    "\n",
    "train_df = df.iloc[train_idxs]\n",
    "test_df = df.iloc[test_idxs]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.074551661Z",
     "start_time": "2023-05-17T12:58:48.065400524Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "The previous approach requires the additional `numpy` library. In cases where installation or utilization of different packages is not usable, one can also sample a predefined fraction randomly from a dataframe. Afterward, the test dataframe is obtained by checking if an index is already contained in the `train_df`. The `~` negates the boolean values returned from the `isin` function."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "train_df = df.sample(frac=0.8)\n",
    "test_df = df[~df.index.isin(train_df.index)]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.125396818Z",
     "start_time": "2023-05-17T12:58:48.078217465Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Splitting a Dataframe with scikit-learn\n",
    "\n",
    "A more convenient approach to splitting is by using the `scikit-learn` package.\n",
    "This package contains a variety of functions that simplify various splitting strategies.\n",
    "\n",
    "The most basic variant is the `train_test_split` function. It only requires the desired size of the training dataset:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TRAIN DATASET\n",
      "    feat  label\n",
      "71    71      0\n",
      "8      8      0\n",
      "82    82      1\n",
      "81    81      1\n",
      "46    46      0\n",
      "TEST DATASET\n",
      "    feat  label\n",
      "24    24      0\n",
      "2      2      0\n",
      "65    65      0\n",
      "67    67      0\n",
      "99    99      1\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "train_df, test_df = train_test_split(df, train_size=0.8)\n",
    "\n",
    "print('TRAIN DATASET')\n",
    "print(train_df.head())\n",
    "\n",
    "print('TEST DATASET')\n",
    "print(test_df.head())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.644830594Z",
     "start_time": "2023-05-17T12:58:48.085114568Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "As we noted in the introduction, we would like to create a reproducible splitting strategy.\n",
    "In its current form the splitting function returns a different result on every execution though:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Split 1:\n",
      "    feat  label\n",
      "98    98      1\n",
      "38    38      0\n",
      "57    57      0\n",
      "10    10      0\n",
      "92    92      1\n",
      "--------------------\n",
      "Split 2:\n",
      "    feat  label\n",
      "42    42      0\n",
      "11    11      0\n",
      "81    81      1\n",
      "58    58      0\n",
      "85    85      1\n",
      "--------------------\n",
      "Split 3:\n",
      "    feat  label\n",
      "41    41      0\n",
      "50    50      0\n",
      "40    40      0\n",
      "97    97      1\n",
      "28    28      0\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    train_df, test_df = train_test_split(df, train_size=0.8)\n",
    "    print(f'Split {i + 1}:')\n",
    "    print(train_df.head())\n",
    "    print('-' * 20)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.655822230Z",
     "start_time": "2023-05-17T12:58:48.647951052Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "To achieve a reproducible behavior seeding is necessary. More precisely, seeding implies providing a parameter aka *random seed*, which leads to identical random splits each time the function is executed."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Split 1:\n",
      "    feat  label\n",
      "10    10      0\n",
      "73    73      0\n",
      "76    76      1\n",
      "53    53      0\n",
      "52    52      0\n",
      "--------------------\n",
      "Split 2:\n",
      "    feat  label\n",
      "10    10      0\n",
      "73    73      0\n",
      "76    76      1\n",
      "53    53      0\n",
      "52    52      0\n",
      "--------------------\n",
      "Split 3:\n",
      "    feat  label\n",
      "10    10      0\n",
      "73    73      0\n",
      "76    76      1\n",
      "53    53      0\n",
      "52    52      0\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    train_df, test_df = train_test_split(df, train_size=0.8, random_state=1337)\n",
    "    print(f'Split {i + 1}:')\n",
    "    print(train_df.head())\n",
    "    print('-' * 20)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.721476411Z",
     "start_time": "2023-05-17T12:58:48.657489066Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "A fully random split is sufficient in cases of somewhat evenly distributed labels.\n",
    "In a highly unbalanced setting as it often occurs in medical settings or anomaly detection,\n",
    "this can lead to unwanted side effects.\n",
    "\n",
    "Let's imagine the following example, where our dummy dataframe only has 5% of positive labels.\n",
    "If we do a random split, it could happen that our test set does not even contain a single example of our\n",
    "positive class! To ensure a fair evaluation of our algorithm, the distribution of the labels in the test set\n",
    "should roughly match the one of the training set."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label\n",
      "0    20\n",
      "Name: count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "df_2 = pd.DataFrame({\n",
    "    'feat': list(range(100)),\n",
    "    'label': [0] * 95 + [1] * 5\n",
    "})\n",
    "\n",
    "_, test_df = train_test_split(df_2, train_size=0.8, random_state=1337)\n",
    "print(test_df['label'].value_counts())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.722315353Z",
     "start_time": "2023-05-17T12:58:48.674868485Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "To counter this problem, we can use **stratification**, which is a technique for partitioning a dataset into training and test sets while maintaining the same proportion of each class or target variable category in both sets as in the original dataset. This ensures that the model trained on the training set is representative of the overall distribution of the target variable and can generalize well to new data.\n",
    "Stratification can be achieved by providing the `stratify` argument. The passed object should be a vector-style element of the same length as the dataframe. In our example, we stratify the split according to the labels, but this is not a necessity. A stratification criterion could also reflect certain features or criteria, e.g. matching an age distribution or ensuring balanced ethnicity."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label\n",
      "0    19\n",
      "1     1\n",
      "Name: count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "_, test_df = train_test_split(\n",
    "    df_2, train_size=0.8, random_state=1337, stratify=df_2['label']\n",
    ")\n",
    "print(test_df['label'].value_counts())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.722946086Z",
     "start_time": "2023-05-17T12:58:48.691267762Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "In our simple example the stratification results in one sample of the positive class in the test set, which reflects the previously defined ratio of 95/5 negative to positive class.\n",
    "\n",
    "Lastly, it's worth mentioning that the `train_test_split` function does not require a pandas dataframe but - according to the documentation - allows `lists, numpy arrays, scipy-sparse matrices or pandas dataframes`."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Defining a Training, Validation AND Test Split\n",
    "\n",
    "When working with machine learning models, it's important to evaluate their performance on data that hasn't been seen during training. To achieve this, we can split our dataset into three parts: a training set, a validation set, and a test set.\n",
    "The training set is used to train the model, the validation set is used to tune hyperparameters and make decisions about the model architecture, and the test set is used to evaluate the final performance of the model.\n",
    "Scikit-learn does not provide a convenience function for doing this triplet split, but we can do so easily by ourselves:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [],
   "source": [
    "from typing import Tuple, Optional\n",
    "\n",
    "\n",
    "def train_val_test_split(\n",
    "        df: pd.DataFrame,\n",
    "        ratios: Tuple[float, float, float],\n",
    "        random_state: Optional[float] = None\n",
    ") -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:\n",
    "    \"\"\"Do a train, val and test split on a dataframe.\"\"\"\n",
    "    assert sum(ratios) == 1., 'Splitting ratios do not add up to 1.'\n",
    "\n",
    "    train_val_df, test_df = train_test_split(\n",
    "        df, test_size=ratios[2], random_state=random_state\n",
    "    )\n",
    "\n",
    "    num_train_samples = int(len(df) * ratios[0])\n",
    "    train_df, val_df = train_test_split(\n",
    "        train_val_df, train_size=num_train_samples, random_state=random_state\n",
    "    )\n",
    "    return train_df, val_df, test_df"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.804880422Z",
     "start_time": "2023-05-17T12:58:48.711786806Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "The above function executes the scikit learn splitting procedure twice in a row, which leads to the desired results.\n",
    "It is easily extendable to work with stratification as well.\n",
    "Let's try it out!"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train size: 70, val size: 15, test size: 15,\n"
     ]
    }
   ],
   "source": [
    "train_df, val_df, test_df = train_val_test_split(df, ratios=(0.7, 0.15, 0.15))\n",
    "\n",
    "print(\n",
    "    f'Train size: {len(train_df)}, val size: {len(val_df)}, test size: {len(test_df)},'\n",
    ")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.818222911Z",
     "start_time": "2023-05-17T12:58:48.762925593Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Cross-validation\n",
    "\n",
    "With our splitting procedure in place, we can advance our training setup and utilize the so-called\n",
    "**cross validation**.\n",
    "Cross-validation is another strategy to evaluate the performance of a predictive model.\n",
    "The basic idea behind cross-validation is to split the available data into multiple sets, or \"folds,\" and use these folds to train and test the model multiple times.\n",
    "By doing this, we can get a better estimate of how the model will perform on new, unseen data.\n",
    "\n",
    "Cross-validation typically consists of multiple phases:\n",
    "    - Split the data: The first step in cross-validation is to split the available data (aka our data minus the designated test partition) into k equal-sized folds. For example, if we're using 5-fold cross-validation, we'll split the data into 5 folds, with each fold containing a fifth of the data.\n",
    "    - Train the model: Next, we'll train the model using k-1 of the folds. For example, if we're using a 5-fold cross-validation, we'll train the model using 4 of the folds and leave one fold out for testing.\n",
    "    - Validate the model: We'll then evaluate the model using the remaining fold that we left out in step 2. This gives us a rough  estimate of how the model will perform on the test set.\n",
    "    - Repetition: The training and validation steps are repeated until each fold was once utilized as validation set. This will give us k estimates of how the model will perform on new data.\n",
    "    - Final Evaluation: Evaluate the performance: Finally, we'll evaluate the performance of the model by aggregating the obtained metrics from each fold.\n",
    "\n",
    "Following this procedure gives us a sound estimate whether our current hyperparameters lead to a model that generalizes well.\n",
    "A depiction of cross-validation can be found in the [sklearn documentation](https://scikit-learn.org/stable/_images/grid_search_cross_validation.png), which visualizes the described steps in a simplified fashion.\n",
    "\n",
    "Note that in machine learning the ultimate goal is to create a model, which has a high generalization factor and not to overfit on the test set. Cross-validation allows to perform hyperparameter search without specifically investigating the fit on the unseen test data.\n",
    "In current deep learning literature you will notice that you won't find this concept very often. This has multiple reasons.\n",
    "First, training large models is time and resource intensive. Doing a large hyperparameter search and fitting a model for multiple folds is often simply not in the budget.\n",
    "Second, a lot of research tries to beat state-of-the-art on some benchmarks like CIFAR10 or Imagenet.\n",
    "The goal is literally to maximize performance on the test set without regarding a classic evaluation scheme.\n",
    "This leads to hyperparameters that are specifically tweaked to the test set, which is in contrast to the points we discussed here previously.\n",
    "\n",
    "One important last thing to note is that cross-validation is typically used for evaluating model performance during development.\n",
    "Once the desired performance of the model is achieved, it is trained on all folds and then used to make predictions on new data (aka our real test set).\n",
    "\n",
    "To do cross-validation in python, the scikit-learn library provides a few utilities like `KFold`:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold 0, train size: 64, validation size: 16\n",
      "Validation indices: [ 3  4  5  6  8 11 19 28 40 46 52 65 66 69 78 79]\n",
      "--------------------\n",
      "Fold 1, train size: 64, validation size: 16\n",
      "Validation indices: [ 7 15 18 22 27 29 30 34 41 53 54 57 64 67 70 76]\n",
      "--------------------\n",
      "Fold 2, train size: 64, validation size: 16\n",
      "Validation indices: [ 0 12 13 21 23 24 36 38 39 42 45 47 58 60 62 72]\n",
      "--------------------\n",
      "Fold 3, train size: 64, validation size: 16\n",
      "Validation indices: [ 1  9 20 31 33 35 37 44 49 55 59 61 63 68 71 75]\n",
      "--------------------\n",
      "Fold 4, train size: 64, validation size: 16\n",
      "Validation indices: [ 2 10 14 16 17 25 26 32 43 48 50 51 56 73 74 77]\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "\n",
    "# First extract our dedicated test set\n",
    "train_val_df, test_df = train_test_split(df, train_size=0.8)\n",
    "\n",
    "# Create a KFold instance\n",
    "num_folds = 5\n",
    "kf = KFold(n_splits=num_folds, shuffle=True)\n",
    "\n",
    "# Iterate over the respective folds\n",
    "for i, (train_idxs, val_idxs) in enumerate(kf.split(train_val_df)):\n",
    "    print(\n",
    "        f'Fold {i}, train size: {len(train_idxs)}, validation size: {len(val_idxs)}'\n",
    "    )\n",
    "    print(f'Validation indices: {val_idxs}')\n",
    "    print('-' * 20)\n",
    "\n",
    "    train_df = train_val_df.iloc[train_idxs]\n",
    "    val_df = train_val_df.iloc[val_idxs]\n",
    "\n",
    "    # --> FIT AND EVALUATE MODEL <--"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.863223687Z",
     "start_time": "2023-05-17T12:58:48.763232217Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Note that the above workflow does not directly split the dataframe in the for-loop iteration, but returns **indices**.\n",
    "\n",
    "In the following we will do a small practical example that puts the previously proposed strategies to good use!\n",
    "\n",
    "## Practical Example: Cross-validation and Regression\n",
    "\n",
    "For our practical example, we would like to approximate a function.\n",
    "More precisely, we showcase how you could use the cross validation utility not only to find the best\n",
    "hyperparameters, but to use (or abuse) it as a simple resampling strategy to do model ensembling.\n",
    "We decide to go for an arbitrary polynomial function, which we define in the following."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [],
   "source": [
    "def func(x: np.ndarray) -> np.ndarray:\n",
    "    return 1 - 0.8 * x + 0.8 * x ** 2 + 0.3 * x ** 3 - 0.4 * x ** 4"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:48.864018342Z",
     "start_time": "2023-05-17T12:58:48.805170961Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Our target function can be plotted using `matplotib` in combination with the `linspace` function.\n",
    "Here, `linspace` creates a vector with 100 evenly spaced numbers between -2 and 2."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.linspace(-2, 2, 100)\n",
    "plt.plot(x, func(x), c='g')\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.086226457Z",
     "start_time": "2023-05-17T12:58:48.805491203Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We are not done with creating our dummy dataset yet.\n",
    "The dataset itself is sampled by randomly selecting inputs for our function (`x` axis)\n",
    "and subsequently putting some noise on the observed true response `y`."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_samples = 50\n",
    "noise_variance = 1\n",
    "\n",
    "# Set global seed for reproducibility.\n",
    "np.random.seed(1337)\n",
    "\n",
    "# Sample random x values and create a noised response.\n",
    "x = np.random.uniform(-2, 2, size=(num_samples, 1))\n",
    "y = func(x) + noise_variance * np.random.normal(size=(num_samples, 1))\n",
    "plt.scatter(x, y, c='b')\n",
    "\n",
    "# Plot the function with the function including the noised samples.\n",
    "x_true = np.linspace(-2, 2, 100)\n",
    "plt.plot(x_true, func(x_true), c='g')\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.324179131Z",
     "start_time": "2023-05-17T12:58:49.110887915Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "As it can be seen in the graph, it gets increasingly difficult to estimate the base function from the few samples\n",
    "the more noise is added.\n",
    "\n",
    "Nevertheless, let's reserve a few (noised) data points as test set."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [],
   "source": [
    "train_val_x, test_x, train_val_y, test_y = train_test_split(\n",
    "    x, y, train_size=0.8, random_state=1337\n",
    ")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.324507738Z",
     "start_time": "2023-05-17T12:58:49.315521747Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "For our model, we make a bold assumption: We already observed from the training data that\n",
    "the true function must be a polynomial of degree four!\n",
    "\n",
    "Thus, the model of choice is a polynomial regression.\n",
    "In scikit-learn this is realized by transforming the input features with `PolynomialFeatures`\n",
    "and then utilizing `LinearRegression`.\n",
    "For example with a degree of `4` and the option `include_bias=True` our univariate input $x$ would be\n",
    "transformed into a vector that contains \\[1 $x$ $x^2$ $x^3$ $x^4$ \\].\n",
    "\n",
    "In the following, we fit the polynomial regression model on all data but the test data."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "data": {
      "text/plain": "LinearRegression()",
      "text/html": "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LinearRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearRegression</label><div class=\"sk-toggleable__content\"><pre>LinearRegression()</pre></div></div></div></div></div>"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "# Choose the degree of the polynomial.\n",
    "degrees = 4\n",
    "# Transform into polynomial features.\n",
    "poly = PolynomialFeatures(degree=degrees, include_bias=True)\n",
    "x_poly = poly.fit_transform(train_val_x)\n",
    "\n",
    "# Fit linear regression on polynomial features.\n",
    "lr = LinearRegression()\n",
    "lr.fit(x_poly, train_val_y)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.331631470Z",
     "start_time": "2023-05-17T12:58:49.315773730Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "As usual the estimated coefficients can be checked."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "COEFFICIENTS: [ 0.         -0.94456601  0.36214103  0.26918903 -0.30352206]\n"
     ]
    }
   ],
   "source": [
    "print('COEFFICIENTS:', lr.coef_[0])"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.346374528Z",
     "start_time": "2023-05-17T12:58:49.331179377Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Next, the mean squared error for our reserved test set and for the actual true function is computed."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TEST MSE: 0.8246164617230851\n",
      "TRUE MSE: 0.10454374821283999\n"
     ]
    }
   ],
   "source": [
    "test_x_poly = poly.fit_transform(test_x.reshape(-1, 1))\n",
    "print('TEST MSE:', mean_squared_error(test_y, lr.predict(test_x_poly)))\n",
    "\n",
    "x_true_poly = poly.fit_transform(x_true.reshape(-1, 1))\n",
    "print('TRUE MSE:', mean_squared_error(func(x_true), lr.predict(x_true_poly)))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.440076643Z",
     "start_time": "2023-05-17T12:58:49.346108377Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Not that bad! Additionally the approximated function is plotted (red):"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_true, lr.predict(x_true_poly), c='r')\n",
    "plt.plot(x_true, func(x_true), c='g')\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.568638102Z",
     "start_time": "2023-05-17T12:58:49.378826912Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "That is not too far off, but can we do better?\n",
    "\n",
    "In the next approach, the training dataset is splitted using cross-validation.\n",
    "From each fold, one `LinearRegression` object is obtained, which was fitted on a\n",
    "subset of the full training data."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold 0\n",
      "COEFFICIENTS: [ 0.         -0.88473208  0.37507706  0.29932773 -0.26564637]\n",
      "TEST MSE: 0.7474878470427194\n",
      "TRUE MSE: 0.04483478636205592\n",
      "--------------------\n",
      "Fold 1\n",
      "COEFFICIENTS: [ 0.         -0.71267352  0.41650921  0.2097751  -0.33446362]\n",
      "TEST MSE: 1.0483710763805327\n",
      "TRUE MSE: 0.0873304298547162\n",
      "--------------------\n",
      "Fold 2\n",
      "COEFFICIENTS: [ 0.         -1.27840031  0.65079621  0.37699189 -0.39252634]\n",
      "TEST MSE: 0.9284295612258451\n",
      "TRUE MSE: 0.14747381533776652\n",
      "--------------------\n",
      "Fold 3\n",
      "COEFFICIENTS: [ 0.         -1.12556264  0.11276866  0.31470042 -0.24424964]\n",
      "TEST MSE: 0.7453230866438626\n",
      "TRUE MSE: 0.24353934262509647\n",
      "--------------------\n",
      "Fold 4\n",
      "COEFFICIENTS: [ 0.         -0.8369903   0.27945664  0.23663674 -0.28017851]\n",
      "TEST MSE: 0.8228037018088775\n",
      "TRUE MSE: 0.10782273176383166\n",
      "--------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "degrees = 4\n",
    "num_folds = 5\n",
    "\n",
    "lrs = []\n",
    "\n",
    "kf = KFold(n_splits=num_folds)\n",
    "kf_idxs = kf.split(train_val_x, train_val_y)\n",
    "for i, (train_idxs, val_idxs) in enumerate(kf_idxs):\n",
    "    # Partition train and validation data\n",
    "    train_x = train_val_x[train_idxs]\n",
    "    train_y = train_val_y[train_idxs]\n",
    "    val_x = train_val_x[val_idxs]\n",
    "    val_y = train_val_y[val_idxs]\n",
    "\n",
    "    # Fit LR on fold\n",
    "    poly = PolynomialFeatures(degree=degrees, include_bias=True)\n",
    "    x_poly = poly.fit_transform(train_x)\n",
    "    lr = LinearRegression()\n",
    "    lr.fit(x_poly, train_y)\n",
    "\n",
    "    # Save fitted model for later\n",
    "    lrs.append(lr)\n",
    "\n",
    "    # Print coefficients and performance on test set\n",
    "    print('Fold', i)\n",
    "    print('COEFFICIENTS:', lr.coef_[0])\n",
    "    print('TEST MSE:', mean_squared_error(test_y, lr.predict(test_x_poly)))\n",
    "    print('TRUE MSE:', mean_squared_error(func(x_true), lr.predict(x_true_poly)))\n",
    "    print('-' * 20)\n",
    "\n",
    "    # Add plot of predicted function\n",
    "    plt.plot(x_true, lr.predict(x_true_poly), c='r', alpha=0.3)\n",
    "\n",
    "plt.plot(x_true, func(x_true), c='g')\n",
    "ax = plt.gca()\n",
    "ax.set_ylim([-5, 5])\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.718401818Z",
     "start_time": "2023-05-17T12:58:49.565443757Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "The above plot shows the base function in green as usual but also contains the approximated function\n",
    "from each fold. Changing the input data slightly, as we did over the folds -- especially in a low data and high noise regime -- results in variable outputs.\n",
    "\n",
    "We can abuse the fact that each fold estimates a different optimal model and combine all estimators\n",
    "in a single on. In our case we make a prediction with every model and average them.\n",
    "That's called **ensembling**. A variety of strategies exist on how to combine ensemble members,\n",
    "but doing a simple mean is probably the most adopted one.\n",
    "\n",
    "A function is added, which takes an input array plus a list of `LinearRegression` objects and\n",
    "returns the averaged prediction across the ensemble members."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "outputs": [],
   "source": [
    "from typing import List\n",
    "\n",
    "\n",
    "def predict_ensemble(\n",
    "        x: np.ndarray, degrees: int, lrs: List[LinearRegression]\n",
    ") -> np.ndarray:\n",
    "    poly = PolynomialFeatures(degree=degrees, include_bias=True)\n",
    "    x_poly = poly.fit_transform(x.reshape(-1, 1))\n",
    "\n",
    "    preds = [lr.predict(x_poly) for lr in lrs]\n",
    "    return np.mean(np.concatenate(preds, axis=1), axis=1)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.767173228Z",
     "start_time": "2023-05-17T12:58:49.723425224Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Finally, let's check whether we good closer to the true function using our small ensemble method:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TEST MSE: 0.07379802224158301\n",
      "TRUE MSE: 0.08731119426878277\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Predict with ensemble on test data.\n",
    "y_ens = predict_ensemble(test_x, degrees=4, lrs=lrs)\n",
    "y_true_approx = predict_ensemble(x_true, degrees=4, lrs=lrs)\n",
    "\n",
    "print('TEST MSE:', mean_squared_error(func(test_x), y_ens))\n",
    "print('TRUE MSE:', mean_squared_error(func(x_true), y_true_approx))\n",
    "\n",
    "plt.plot(x_true, y_true_approx, c='r')\n",
    "plt.plot(x_true, func(x_true), c='g')\n",
    "ax = plt.gca()\n",
    "ax.set_ylim([-5, 5])\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-05-17T12:58:49.949072861Z",
     "start_time": "2023-05-17T12:58:49.765504088Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Indeed! Our final MSE is lower than in the single split strategy and the plotted function seems\n",
    "to be closer to the original."
   ],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}