{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Where does error come from?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In lecture, we discussed how the source of error comes from one of three places\n", "* **Irreducible Error:** The noise from the dataset. In our model, `y_i = f(x_i) + epsilon_i`, and it is hopeless to learn the `epsilon_i` since its random and does not depend on the input\n", "* **Bias:** How much our expected learned model (expectation is over all possible training sets) differs from the underlying model.\n", "* **Variance:** How dependent the learned model is on the particular dataset it was learned on. If slightly changing the dataset leads to a huge change in learned model, then variance is high.\n", "\n", "There is a fundamental tradeoff between bias and variance that depends on how complex your model is. Very simple models (constant functions) have high bias since your true function is usually not constant, but have low variance since they generally don't have the complexity to fit the noise of the specific dataset you got. Very complex models (high degree polynomials) have low bias since you can get a descent approximation of the true function **in expectation**, but have high variance since they have the capabilities of fitting the noise in the data.\n", "\n", "This notebook has some code examples to demonstrate how this bias variance tradeoff occurs with different model complexities using synthetic data." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Are our datasets fixed?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We first start by defining functions to generate synthetic data from some true function `f`. Remember that as machine learning experts, our goal is to learn the parameters for the function `f` (the weights for the polynomial) when we don't have access to the true function. All we get access to is one random training set drawn from the distribution of inputs (some house square footages are more likely than others) with associated values that are from the true function `f` with some added noise." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import math\n", "import random \n", "\n", "import turicreate as tc\n", "\n", "# You don't need to know how to use these libraries, they just make code easier to write\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First we define functions to help us generate our data and to generate our features from the inputs. The `generate_data` function will generate `x` values uniformly at random in [0, 1] and then assign the values using the function `f` and Gaussian noise with mean 0 and variance 0.1. " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def f(x):\n", " \"\"\"\n", " True function f(x) (unknown to us)\n", " \"\"\"\n", " return 2 * x - 1.4 * x ** 2\n", "\n", "\n", "def generate_data(n):\n", " \"\"\"\n", " Creates and returns a SFrame with n randomly drawn examples\n", " \"\"\"\n", " xs = [random.uniform(0, 1) for _ in range(n)] # generate n numbers uniform at random from [0, 1]\n", " ys = [f(x) + random.gauss(0, 0.1) for x in xs] # evaluate f at each x and add Gaussian noise (mean=0, variance=.1)\n", " return tc.SFrame({'x': xs, 'y': ys})\n", "\n", "\n", "def polynomial_features(data, col, deg):\n", " \"\"\"\n", " Given a dataset, creates a polynomial expansion of the input with \n", " the given name to the given degree.\n", " \n", " Returns the dataset and the list of column names\n", " \"\"\"\n", " data_copy = data.copy()\n", " if deg == 0:\n", " data_copy[col + '0'] = 0\n", " columns = [col + '0']\n", " else:\n", " columns = []\n", " for i in range(1, deg + 1): # +1 to include deg\n", " col_name = col + str(i)\n", " data_copy[col_name] = data_copy[col] ** i\n", " columns.append(col_name)\n", " \n", " return data_copy, columns" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Below is an example dataset we might obvserve. " ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['x1', 'x2', 'x3']\n" ] }, { "data": { "text/html": [ "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
xyx1x2x3
0.9654561864960.6731849622470.9654561864960.9321056480420.89990716437
0.339251713360.5867991511960.339251713360.1150917250180.0390450649059
0.6422493284490.5914064363460.6422493284490.4124841998940.264917700378
0.5505510281760.7931432655820.5505510281760.3031064346250.16687555923
0.9640804852650.6138666747850.9640804852650.9294511820690.89606574664
0.4529105545950.6080353928430.4529105545950.2051279704640.0929046228658
0.4400528529270.7322389482390.4400528529270.1936465133690.0852147006672
0.9797981625560.7904976325040.9797981625560.9600044393480.940610585719
0.023278071278-0.08790682023590.0232780712780.0005418686024241.26136559505e-05
0.3771108741020.4307995382810.3771108741020.1422126113660.0536299221805
\n", "[15 rows x 5 columns]
Note: Only the head of the SFrame is printed.
You can use print_rows(num_rows=m, num_columns=n) to print more rows and columns.\n", "
" ], "text/plain": [ "Columns:\n", "\tx\tfloat\n", "\ty\tfloat\n", "\tx1\tfloat\n", "\tx2\tfloat\n", "\tx3\tfloat\n", "\n", "Rows: 15\n", "\n", "Data:\n", "+----------------+------------------+----------------+-------------------+\n", "| x | y | x1 | x2 |\n", "+----------------+------------------+----------------+-------------------+\n", "| 0.965456186496 | 0.673184962247 | 0.965456186496 | 0.932105648042 |\n", "| 0.33925171336 | 0.586799151196 | 0.33925171336 | 0.115091725018 |\n", "| 0.642249328449 | 0.591406436346 | 0.642249328449 | 0.412484199894 |\n", "| 0.550551028176 | 0.793143265582 | 0.550551028176 | 0.303106434625 |\n", "| 0.964080485265 | 0.613866674785 | 0.964080485265 | 0.929451182069 |\n", "| 0.452910554595 | 0.608035392843 | 0.452910554595 | 0.205127970464 |\n", "| 0.440052852927 | 0.732238948239 | 0.440052852927 | 0.193646513369 |\n", "| 0.979798162556 | 0.790497632504 | 0.979798162556 | 0.960004439348 |\n", "| 0.023278071278 | -0.0879068202359 | 0.023278071278 | 0.000541868602424 |\n", "| 0.377110874102 | 0.430799538281 | 0.377110874102 | 0.142212611366 |\n", "+----------------+------------------+----------------+-------------------+\n", "+-------------------+\n", "| x3 |\n", "+-------------------+\n", "| 0.89990716437 |\n", "| 0.0390450649059 |\n", "| 0.264917700378 |\n", "| 0.16687555923 |\n", "| 0.89606574664 |\n", "| 0.0929046228658 |\n", "| 0.0852147006672 |\n", "| 0.940610585719 |\n", "| 1.26136559505e-05 |\n", "| 0.0536299221805 |\n", "+-------------------+\n", "[15 rows x 5 columns]\n", "Note: Only the head of the SFrame is printed.\n", "You can use print_rows(num_rows=m, num_columns=n) to print more rows and columns." ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data = generate_data(15)\n", "data, columns = polynomial_features(data, 'x', 3)\n", "print columns\n", "data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you run it multiple times, you would most likely get different values. \n", "\n", "This doesn't seem to happen in real life since we just give you a dataset of houses that never changes, but this idea that the training set is random is important. We want to make sure we are thinking about how our model generalizes to future, probably unseen data so we should keep in mind we could have gotten a different dataset if conditions were slightly different.\n", "\n", "The following function will learn some given number of models using random samples from our training set. This is technique of approximating getting new datasets from the underlying distribution with only our one dataset known as bootstrapping. We will use each random sample of our training set to train a model, use the model to predict a range of input values, and look at the range of outputs for each particular input." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def learn_models(data, features, num_models):\n", " \"\"\"\n", " Trains num_models models on random subsets of the given data. \n", " Returns the list of learned models.\n", " \"\"\"\n", " models = []\n", " for i in range(num_models):\n", " # get a random sample of the datat\n", " train_data, _ = data.random_split(.5) \n", " model = tc.linear_regression.create(train_data, target='y', features=features, verbose=False)\n", " models.append(model)\n", " return models\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def find_predictions_range(models, model_degree, num_eval_points):\n", " \"\"\"\n", " Compares the predictions of the given models at num_eval_points between 0 and 1.\n", " \n", " This gives a description of how spread the predictions are at a particular point x. \n", " If the predictions are all over the place, then the range of predictions will be high.\n", " \n", " Returns:\n", " * A list of points evaluated (of length num_eval_points)\n", " * A list of tuples containing information about the predictions at each eval point. \n", " Each tuple contains the minimum prediction, mean prediction, and max prediction for that input\n", " \n", " \"\"\"\n", " new_xs = np.linspace(0, 1, num_eval_points) # just like range, but allows for fractional steps\n", " new_data = tc.SFrame({'x': new_xs})\n", " new_data, _ = polynomial_features(new_data, 'x', model_degree)\n", "\n", " all_predictions = [model.predict(new_data) for model in models]\n", " intervals = []\n", " for i in range(len(new_xs)): \n", " # get predictions from each model for this input i\n", " preds_i = [preds[i] for preds in all_predictions]\n", " # find the mean, min, and max\n", " intervals.append((min(preds_i), np.mean(preds_i), max(preds_i)))\n", " \n", " return new_xs, intervals" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def plot(data, new_xs, intervals):\n", " \"\"\"\n", " Plots the data and range of predictions to demonstrate the bias and variance of the model\n", " \"\"\"\n", " # magic to separate list of [(low, mean, high)] to list of lows, list of means, list of highs\n", " lows, means, highs = zip(*intervals) \n", " \n", " # plot the range bands for predictions\n", " plt.fill_between(new_xs, lows, highs, facecolor='#E8F8F8', edgecolor='#c3e2e2',\n", " label='Range of predictions')\n", " # plot the average predictions (won't perfectly match f because it's an approximation of E_train[hat{f}]\n", " plt.plot(new_xs, means, color=\"r\", label='Average hat{f}')\n", " # plot the true f\n", " plt.plot(new_xs, [f(x) for x in new_xs], color='g', label='True f')\n", " # plot the datapoints\n", " plt.scatter(data['x'], data['y'], c='black', s=10, label='Data')\n", "\n", " # modify axis to make it look nice and add label\n", " axes = plt.gca()\n", " axes.set_xlim([0, 1])\n", " axes.set_ylim([data['y'].min() - 0.5, data['y'].max() + 0.5])\n", " plt.legend(loc='upper left', bbox_to_anchor=(1, 1))\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is the main function to run our experiments. See the cell aftewards how to call it. " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def bias_variance(num_data, num_models, degree_expansions, num_eval_points=200):\n", " \"\"\"\n", " Demonstrates the bias-variance tradeoff for each degree in degree_expansions using \n", " one randomly generated dataset of num_dat samples with value some true f(x) + noise.\n", " \n", " For each degree, trains num_models models using features up to that degree. It then uses\n", " those models to make predictions for the num_eval_points between 0 and 1. It records \n", " these predictions and visually plots the range of predictions for each x.\n", " \"\"\"\n", " print 'Generating data'\n", " data = generate_data(num_data)\n", " for degree_expansion in degree_expansions:\n", " print 'Evaluating model with degree ' + str(degree_expansion)\n", " # generate data with \n", " data, columns = polynomial_features(data, 'x', degree_expansion)\n", " models = learn_models(data, columns, num_models)\n", " new_xs, intervals = find_predictions_range(models, degree_expansion, num_eval_points)\n", " plot(data, new_xs, intervals)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Generating data\n", "Evaluating model with degree 0\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Evaluating model with degree 1\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Evaluating model with degree 2\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Evaluating model with degree 5\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Evaluating model with degree 10\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# 15 datapoints\n", "# 100 models\n", "# try degrees [0, 1,2,5,10]\n", "# 50 points used to evaluate the range of predictions\n", "bias_variance(15, 100, [0, 1, 2, 5, 10], 50)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The way to read each of the graphs is:\n", "* The black dots are the datapoints from our one dataset (which was drawn from the underlying distribution)\n", "* The green line is the true function `f`\n", "* The red line is the average prediction at each value x from all of the bootstrapped models. This is an approximation of the expected learned model, but is not perfect since it does not have access to the true distribution of the inputs.\n", "* The blue region is the range of prediction values over all the learned models for that particular input\n", "\n", "\n", "Notice that with the degree 0 polynomial (constant functions), the range of predictions is relatively small; this means the degree 0 polynomial has low variance. Also notice that it never does a really good job approximating the true function `f` which means it has high bias. \n", "\n", "On the other side of the spectrum, the degree 10 polynomial has very wide ranges of predictions over all the models; this means the high degree model has high variance. Notice that it seems like the average model for this degree polynomial seems to not match the true function like we would expect since it has low bias. This is an artifact of the fact that our original dataset is a small sample from the distribution of inputs so we don't get enough data to make the noise cancel out on different bootstrapped versions of the dataset. If we were using more data and more models estimate the average, we would expect it to go towards the true model in expectation but still maintain its high variance." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "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.14" } }, "nbformat": 4, "nbformat_minor": 2 }