{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression\n",
    "\n",
    "By Jen Selby and Carl Shan\n",
    "\n",
    "This Jupyter Notebook will introduce to you to how to make a Linear Regression model using the Sci-kit Learn (aka `sklearn`) Python library.\n",
    "\n",
    "You can see basic example here:\n",
    "> http://scikit-learn.org/stable/modules/linear_model.html#ordinary-least-squares\n",
    "\n",
    "and full documentation of the sklearn linear_model module here:\n",
    "> http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html\n",
    "\n",
    "# Instructions\n",
    "\n",
    "0. Make sure you've read and learned a bit about the Linear Regression model. [Click here for course notes.](https://jennselby.github.io/MachineLearningCourseNotes/#linear-regression)\n",
    "1. Read through the instructions and code behind the following sections:\n",
    "\n",
    "    * [Setup](#Setup)\n",
    "    * [Fake Data Generation](#Fake-Data-Generation)\n",
    "    * [Training](#Training)\n",
    "    * [Results and Visualization](#Results-and-Visualization)\n",
    "2. Then, pick and complete at least one of the set of exercises (Standard or Advanced) and write code that answers each set of questions.\n",
    "    * [Option 1 - Standard Difficulty](#Exercise-Option-#1---Standard-Difficulty)\n",
    "    * [Option 2 - Standard Difficulty](#Exercise-Option-#2---Standard-Difficulty)\n",
    "    * [Option 3 - Advanced Difficulty](#Exercise-Option-#3---Advanced-Difficulty)\n",
    "    * [Option 4 - Advanced Difficulty](#Exercise-Option-#4---Advanced-Difficulty)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "First, make sure you have installed all of the necessary Python libraries, following [the instructions here](https://jennselby.github.io/MachineLearningCourseNotes/#setting-up-python3).\n",
    "\n",
    "You should have `sklearn`, `numpy`, `matplotlib` and `pandas` installed.\n",
    "\n",
    "If you haven't installed them, use `pip install <library here>` to install them in your Terminal.\n",
    "\n",
    "Next, we want to make sure we can display our graphs in this notebook and import all of the libraries we'll need into the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We're going to be doing some plotting, and we want to be able to see these plots.\n",
    "# To display graphs in this notebook, run this cell.\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We're now going to import some important libraries\n",
    "\n",
    "import numpy.random # for generating a noisy data set\n",
    "from sklearn import linear_model # for training a linear model\n",
    "\n",
    "import matplotlib.pyplot # for plotting in general\n",
    "from mpl_toolkits.mplot3d import Axes3D # for 3D plotting\n",
    "\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fake Data Generation\n",
    "\n",
    "We're going to generate some fake data to test out our ideas about linear regression. These constant variables decide some of the characteristics of our data: the `x` range (which will also be used to set the size of the graph later) and how many inputs we should generate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting the limits and number of our first, X, variable\n",
    "\n",
    "MIN_X = -10\n",
    "MAX_X = 10\n",
    "NUM_INPUTS = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fake Dataset 1 - Single x Variable\n",
    "\n",
    "Our first dataset has just one input feature. We are going to pick out 50 random real numbers between our min and max. Then, we will generate one output for each of these inputs following the function $y = 0.3x + 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.2042874 ]\n",
      " [-6.44558848]\n",
      " [ 6.15347981]\n",
      " [-5.84754016]\n",
      " [ 1.43601348]\n",
      " [-4.31411709]\n",
      " [-9.82494627]\n",
      " [ 8.48626601]\n",
      " [-7.62915955]\n",
      " [-3.29137353]\n",
      " [-9.99398847]\n",
      " [-8.37608792]\n",
      " [ 5.07202459]\n",
      " [ 5.50636949]\n",
      " [ 6.09568009]\n",
      " [-4.30089789]\n",
      " [-8.88273978]\n",
      " [ 9.12468103]\n",
      " [-7.73938696]\n",
      " [-9.33474834]\n",
      " [-3.49694032]\n",
      " [-8.9676608 ]\n",
      " [-2.80176355]\n",
      " [-5.03206763]\n",
      " [-0.68356   ]\n",
      " [ 1.73552019]\n",
      " [ 7.9379289 ]\n",
      " [-7.70543788]\n",
      " [-1.45995305]\n",
      " [ 5.09314035]\n",
      " [ 5.99847056]\n",
      " [ 3.34302821]\n",
      " [-8.10582136]\n",
      " [-2.26602336]\n",
      " [-2.27335965]\n",
      " [-4.09892983]\n",
      " [-8.99217476]\n",
      " [ 8.90280292]\n",
      " [-8.6455045 ]\n",
      " [-4.26283741]\n",
      " [ 0.11768981]\n",
      " [ 5.15041637]\n",
      " [ 8.15758258]\n",
      " [-5.45726117]\n",
      " [-6.92202854]\n",
      " [-9.78166627]\n",
      " [ 5.57196798]\n",
      " [ 4.4655849 ]\n",
      " [ 3.24344148]\n",
      " [ 5.48035288]]\n"
     ]
    }
   ],
   "source": [
    "# randomly pick numbers for x\n",
    "x_one_x = numpy.random.uniform(low=MIN_X, high=MAX_X, size=(NUM_INPUTS, 1))\n",
    "\n",
    "print(x_one_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's store this data into a `pandas` `DataFrame` object and name the column `'x'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>x</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>6.204287</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>-6.445588</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>6.153480</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>-5.847540</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.436013</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          x\n",
       "0  6.204287\n",
       "1 -6.445588\n",
       "2  6.153480\n",
       "3 -5.847540\n",
       "4  1.436013"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_one_x = pd.DataFrame(data=x_one_x, columns=['x'])\n",
    "data_one_x.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool. Now we have some fake `x` data.\n",
    "\n",
    "Let's make the fake `y` data now.\n",
    "\n",
    "Let's try to make data that follows the equation: $y = 0.3x + 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_one_x['y'] = 0.3 * data_one_x['x'] + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1195b1290>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_one_x.plot.scatter(x='x', y='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay. That looks *too* perfect.\n",
    "\n",
    "Most data in the real world look less linear than that.\n",
    "\n",
    "So let's add a little bit of noise. Noise are random pertubations to your data that happens naturally in the real world. We will simulate some noise.\n",
    "\n",
    "Otherwise our linear model will be too easy.\n",
    "\n",
    "**Note:** We can generate some noise by picking numbers in a [normal distribution (also called bell curve)](http://www.statisticshowto.com/probability-and-statistics/normal-distributions/) around zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, let's create some noise to make our data a little bit more spread out.\n",
    "\n",
    "# generate some normally distributed noise\n",
    "noise_one_x = numpy.random.normal(size=NUM_INPUTS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now let's create the 'y' variable\n",
    "# It turns out you can make a new column in pandas just by doing the below.\n",
    "# It's so simple!\n",
    "data_one_x['y'] = data_one_x['y'] + noise_one_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11b6f7450>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_one_x.plot.scatter(x='x', y='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great!\n",
    "\n",
    "This looks more like real data now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "Now that we have our data, we can train our model to find the best fit line. We will use the linear model module from the scikit-learn library to do this.\n",
    "\n",
    "Note: you may get a warning about LAPACK. According to [this discussion on the scikit-learn github page](https://github.com/scipy/scipy/issues/5998), this is safe to ignore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This creates an \"empty\" linear model\n",
    "\n",
    "model_one_x = linear_model.LinearRegression()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we need to reshape our data.\n",
    "\n",
    "Currently, our data looks like the following:\n",
    "\n",
    "```python\n",
    "# data_one_x['x'] looks like\n",
    "[-3.44342026,  9.60082542,  4.99683803,  7.11339915,  9.69287893, ...]\n",
    "\n",
    "```\n",
    "\n",
    "In other words, it's just a list.\n",
    "\n",
    "However, this isn't sufficient.\n",
    "\n",
    "That's because later on, we will use a command called `.fit()` and this command expects our data to look like a list of lists.\n",
    "\n",
    "For example:\n",
    "\n",
    "```python\n",
    "[[-3.44342026],\n",
    "[ 9.60082542],\n",
    "[ 4.99683803],\n",
    "[ 7.11339915],\n",
    "[ 9.69287893],\n",
    "[-5.1383316 ],\n",
    "[ 8.96638209],\n",
    "...\n",
    "[-9.12492363]]\n",
    "```\n",
    "\n",
    "We will use a the command `.reshape()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this code\n",
    "x_one_x = data_one_x['x'].values.reshape(-1, 1)\n",
    "y_one_x = data_one_x['y'].values.reshape(-1, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There we go. Now we can \"fit\" the data.\n",
    "\n",
    "\"Fitting\" the data means to give the \"empty model\" real data and ask it to find the \"best parameters\" that \"best fits\" the data.\n",
    "\n",
    "Using the amazing `sklearn` library, it's as easy as running the `.fit()` command.\n",
    "\n",
    "Note: you may get a warning about LAPACK. According to [this discussion on the scikit-learn github page](https://github.com/scipy/scipy/issues/5998), this is safe to ignore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run this code\n",
    "model_one_x.fit(X=x_one_x, y=y_one_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results and Visualization\n",
    "\n",
    "Now, let's see what our model learned. We can look at the results numerically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_model_fit(model):\n",
    "    # Print out the parameters for the best fit line\n",
    "    print('Intercept: {i}  Coefficients: {c}'.format(i=model.intercept_, c=model.coef_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intercept: [1.11825823]  Coefficients: [[0.32606958]]\n"
     ]
    }
   ],
   "source": [
    "print_model_fit(model_one_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.71719265]\n",
      " [1.33346415]\n",
      " [1.76387599]]\n"
     ]
    }
   ],
   "source": [
    "## How would this model make predictions?\n",
    "\n",
    "# Let's make some new data that have the following values and see how to predict their corresponding 'y' values.\n",
    "\n",
    "# Print out the model's guesses for some values of x\n",
    "new_x_values = [ [-1.23], [0.66], [1.98] ]\n",
    "\n",
    "predictions = model_one_x.predict(new_x_values)\n",
    "\n",
    "print(predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model prediction for -1.23: [0.71719265]\n",
      "Model prediction for 0.66: [1.33346415]\n",
      "Model prediction for 1.98: [1.76387599]\n"
     ]
    }
   ],
   "source": [
    "# Let's print them a little bit nicer\n",
    "for datapoint, prediction in zip(new_x_values, predictions):\n",
    "    print('Model prediction for {}: {}'.format(datapoint[0], prediction))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also look at them graphically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_best_fit_line(model, x, y):\n",
    "    # create the figure\n",
    "    fig = matplotlib.pyplot.figure(1)\n",
    "    fig.suptitle('Data and Best-Fit Line')\n",
    "    matplotlib.pyplot.xlabel('x values')\n",
    "    matplotlib.pyplot.ylabel('y values')\n",
    "\n",
    "    # put the generated dataset points on the graph\n",
    "    matplotlib.pyplot.scatter(x, y)\n",
    "    \n",
    "    # Now we actually want to plot the best-fit line.\n",
    "    # To simulate that, we'll simply generate all the\n",
    "    # inputs on the graph and plot that.\n",
    "    # predict for inputs along the graph to find the best-fit line\n",
    "    X = numpy.linspace(MIN_X, MAX_X) # generates all the possible values of x\n",
    "    Y = model.predict(list(zip(X)))\n",
    "    matplotlib.pyplot.plot(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_best_fit_line(model_one_x, x_one_x, y_one_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise Option #1 - Standard Difficulty\n",
    "\n",
    "Answer the following questions about dataset 1:\n",
    "1. Take a look at the output of the `print_model_fit()` function in the \"Results and Visualization\" section above. What numbers did you expect to see printed if the linear regression code was working, and why?\n",
    "1. What numbers did you expect the model to predict when we gave it our new x values, -1.23, 0.66, and 1.98, and why?\n",
    "1. What did you expect to see on the graph if the linear regression code was working, and why?\n",
    "1. Pick some lines of code that you could change to continue testing that the linear regression worked properly. What lines did you choose and how did you change them? How did the output change, and why does that tell you that the code is working correctly?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fake Dataset 2 - Two x Values\n",
    "\n",
    "Let's look at a dataset has two inputs, like [the tree example in our notes](https://jennselby.github.io/MachineLearningCourseNotes/#linear-regression).\n",
    "\n",
    "**NOTE**: This will make it a littler harder to visualize, particularly because you cannot rotate the graph interactively in the Jupyter notebook. If you are interested in looking more closely at this graph, you can copy the code below in the next several cells into a file and run it through Python normally. This will open a graph window that will allow you to drag to rotate the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate some normally distributed noise\n",
    "noise_two_x = numpy.random.normal(size=NUM_INPUTS)\n",
    "\n",
    "# randomly pick pairs of numbers for x\n",
    "x1_two_x = numpy.random.uniform(low=MIN_X, high=MAX_X, size=NUM_INPUTS)\n",
    "x2_two_x = numpy.random.uniform(low=MIN_X, high=MAX_X, size=NUM_INPUTS)\n",
    "\n",
    "y_two_x = 0.5 * x1_two_x - 2.7 * x2_two_x - 2 + noise_two_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_two_x = pd.DataFrame(data=x1_two_x, columns = ['x1'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_two_x['x2'] = x2_two_x\n",
    "data_two_x['y'] = y_two_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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>x1</th>\n",
       "      <th>x2</th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>2.557584</td>\n",
       "      <td>4.564261</td>\n",
       "      <td>-13.463797</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>-0.881504</td>\n",
       "      <td>3.287239</td>\n",
       "      <td>-12.344193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>-0.231691</td>\n",
       "      <td>9.680882</td>\n",
       "      <td>-27.295643</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>8.284173</td>\n",
       "      <td>1.276975</td>\n",
       "      <td>-2.805065</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>3.542796</td>\n",
       "      <td>2.611530</td>\n",
       "      <td>-7.216126</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         x1        x2          y\n",
       "0  2.557584  4.564261 -13.463797\n",
       "1 -0.881504  3.287239 -12.344193\n",
       "2 -0.231691  9.680882 -27.295643\n",
       "3  8.284173  1.276975  -2.805065\n",
       "4  3.542796  2.611530  -7.216126"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_two_x.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intercept: -2.0817409227903294  Coefficients: [ 0.48804114 -2.72217748]\n"
     ]
    }
   ],
   "source": [
    "# use scikit-learn's linear regression model and fit to our data\n",
    "model_two_x = linear_model.LinearRegression()\n",
    "model_two_x.fit(data_two_x[['x1', 'x2']], data_two_x['y'])\n",
    "\n",
    "# Print out the parameters for the best fit plane\n",
    "print_model_fit(model_two_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Now create a function that can plot in 3D\n",
    "\n",
    "def plot_3d(model, x1, x2, y):\n",
    "    # 3D Plot\n",
    "    # create the figure\n",
    "    fig = matplotlib.pyplot.figure(1)\n",
    "    fig.suptitle('3D Data and Best-Fit Plane')\n",
    "    \n",
    "    # get the current axes, and tell them to do a 3D projection\n",
    "    axes = fig.gca(projection='3d')\n",
    "    axes.set_xlabel('x1')\n",
    "    axes.set_ylabel('x2')\n",
    "    axes.set_zlabel('y')\n",
    "    \n",
    "    \n",
    "    # put the generated points on the graph\n",
    "    axes.scatter(x1, x2, y)\n",
    "\n",
    "    # predict for input points across the graph to find the best-fit plane\n",
    "    # and arrange them into a grid for matplotlib\n",
    "    X1 = X2 = numpy.arange(MIN_X, MAX_X, 0.05)\n",
    "    X1, X2 = numpy.meshgrid(X1, X2)\n",
    "    Y = numpy.array(model.predict(list(zip(X1.flatten(), X2.flatten())))).reshape(X1.shape)\n",
    "\n",
    "    # put the predicted plane on the graph\n",
    "    axes.plot_surface(X1, X2, Y, alpha=0.1)\n",
    "\n",
    "    # show the plots\n",
    "    matplotlib.pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Now let's use the function\n",
    "plot_3d(model_two_x, x1_two_x, x2_two_x, y_two_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise Option #2 - Standard Difficulty\n",
    "\n",
    "Now, answer the following questions about [Fake Dataset 2](#Fake-Dataset-2---Two-x-Values):\n",
    "1. Take a look at the output of the `print_model_fit()` function for this above dataset. What output did you expect to see printed if the linear regression code was working, and why?\n",
    "1. What did you expect to see on the graph if the linear regression code was working, and why?\n",
    "1. Pick some lines of code that you could change to continue testing that the linear regression worked properly. What lines did you choose and how did you change them? How did the output change, and why does that tell you that the code is working correctly?\n",
    "1. Explain any differences you noticed between working with dataset 1 and dataset 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fake Dataset 3 - Quadratic\n",
    "\n",
    "The new equation we'll try to model is $y = 0.7x^2 - 0.4x + 1.5$.\n",
    "\n",
    "\n",
    "This dataset still just has one input, so the code is very similar to our first one. However, now the generating function is quadratic, so this one will be trickier to deal with.\n",
    "\n",
    "Again, we'll go through dataset generation, training, and visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# randomly pick numbers for x\n",
    "x_quadratic = numpy.random.uniform(low=MIN_X, high=MAX_X, size=(NUM_INPUTS, 1))\n",
    "\n",
    "data_quadratic = pd.DataFrame(data=x_quadratic, columns=['x'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create some noise to make our data a little bit more spread out.\n",
    "# generate some normally distributed noise\n",
    "noise_quadratic = numpy.random.normal(size=NUM_INPUTS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's generate the y values\n",
    "# Our equation:\n",
    "# y = 0.7x^2 - 0.4x + 1.5\n",
    "data_quadratic['y'] = 0.7 * data_quadratic['x'] * data_quadratic['x'] - 0.4 * data_quadratic['x'] + 1.5 + noise_quadratic\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intercept: [26.1204316]  Coefficients: [[-0.22266468]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get a 1D array of the input data\n",
    "x_quadratic = data_quadratic['x'].values.reshape(-1, 1)\n",
    "y_quadratic = data_quadratic['y'].values.reshape(-1, 1)\n",
    "\n",
    "# Let's try use scikit-learn's linear regression model and fit to our data\n",
    "model_quadratic = linear_model.LinearRegression()\n",
    "model_quadratic.fit(x_quadratic, y_quadratic)\n",
    "\n",
    "# show results\n",
    "print_model_fit(model_quadratic)\n",
    "plot_best_fit_line(model_quadratic, x_quadratic, y_quadratic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise Option #3 - Advanced Difficulty\n",
    "\n",
    "First, look over and understand the data for [Fake Dataset 3](#Fake-Dataset-3---Quadratic).\n",
    "\n",
    "There are some issues here. Clearly the linear model that we have isn't working great.\n",
    "\n",
    "Your challenge is to write some new code that will better fit a linear model to this data. There are a couple different ways to do this, but all of them will involve some new code. If you have ideas but just aren't sure how to translate them into code, please ask for help!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Your code here\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise Option #4 - Advanced Difficulty\n",
    "\n",
    "Try adding some [regularization](https://jennselby.github.io/MachineLearningCourseNotes/#regularization-ridge-lasso-and-elastic-net) to your linear regression model. This will get you some practice in using the sci-kit learn documentation to find new functions and figure out how to use them.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Your code here\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}