Linear Regression - Cricket Chirps.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression - Balaji\n",
    "\n",
    "This notebook contains a walkthrough of a simple linear regression. The data, obtained from [college.cengage.com](http://college.cengage.com/mathematics/brase/understandable_statistics/7e/students/datasets/slr/frames/frame.html), relates the rate of cricket chirps to temperature from *The Song of Insects*, by Dr. G. W. Pierce, Harvard College Press.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install packages using pip or conda\n",
    "\n",
    "Because the code in your notebook likely uses some Python packages, you need to make sure the Notebook environment contains those packages. You can do this directly within the notebook in a code block that contains the appropriate pip or conda commands prefixed by `!`:\n",
    "\n",
    "```\n",
    "!pip install <pkg name> \n",
    "\n",
    "!conda install <pkg name> -y\n",
    "```\n",
    "\n",
    "This present notebook requires numpy, matplotlib, pandas, and sklearn. Because these packages are already included in Azure Notebooks, the following commands are commented out but are included to clearly note the dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install numpy\n",
    "# !pip install matplotlib\n",
    "# !pip install pandas\n",
    "# !pip install sklearn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that when you run a code block that contains install commands, and also those with `import` statements, it make take the notebook a little time to complete the task. To the left of the code block you see `In [*]` to indicate that execution is happening. The Notebook's kernel on the upper right also shows a filled-in circle to indicate \"busy.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import libraries and prepare the dataset\n",
    "\n",
    "In this example we're using numpy, pandas, and matplotlib. Data is in the file cricket_chirps.csv. Because this file is in the same project as this present Notebook, we can just load it using a relative pathname."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Chirps/Minute  Temperature\n",
      "0            20.0         88.6\n",
      "1            16.0         71.6\n",
      "2            19.8         93.3\n",
      "3            18.4         84.3\n",
      "4            17.1         80.6\n",
      "5            15.5         75.2\n",
      "6            14.7         69.7\n",
      "7            17.1         82.0\n",
      "8            15.4         69.4\n",
      "9            16.2         83.3\n",
      "10           15.0         79.6\n",
      "11           17.2         82.6\n",
      "12           16.0         80.6\n",
      "13           17.0         83.5\n",
      "14           14.4         76.3\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "dataset = pd.read_csv('cricket_chirps.csv')\n",
    "print(dataset)\n",
    "X = dataset.iloc[:, :-1].values  # Matrix of independent variables -- remove the last column in this data set\n",
    "y = dataset.iloc[:, 1].values    # Matrix of dependent variables -- just the last column (1 == 2nd column)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, split the dataset into a Training set (2/3rds) and Test set (1/3rd). We don't need to do any feature scaling because there is only one column of independent variables, and libraries typically do scaling for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 1/3, random_state = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit the data to the training set\n",
    "\n",
    "\"Fitting\" the data to a training set means making the line that describes the relationship between the independent and the dependent variables. With a simple data set like we're using here, you can visualize the line on a simple x-y plot: the x-axis is the independent variable (chirp count in this example), and the y-axis is the independent variable (temperature). Fitting the data means plotting all the points in the training set, then drawing the best-fit line through that data.\n",
    "\n",
    "With two independent variables you can imagine a three-dimensional plot with a line fitted to the data. At three or more independent variables, however, it's no longer easy to visualize the fit, but you get the idea. In the end, it's all just mathematics, which a computer can handle easily without having to form a mental picture!\n",
    "\n",
    "The regressor's `fit` method here creates the line, which algebraically is of the form `y = x*b1 + b0`, where b1 is the coefficient or slope of the line (which you can get to through `regressor.coef_`), and b0 is the intercept of the line at x=0 (which you can get to through `regressor.intercept`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "regressor = LinearRegression()    # This object is the regressor, that does the regression\n",
    "regressor.fit(X_train, y_train)   # Provide training data so the machine can learn to predict using a learned model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predict the results\n",
    "\n",
    "With the regressor in hand, we can predict the test set results using its `predict` method. That method takes a vector of independent variables for which you want predictions.\n",
    "\n",
    "Because the regressor is fit to the data by virtue of `coef_` and `intercept_` and `coef_`, a prediction is the result of `coef_ * x + intercept_`. (Indeed, `predict(0)` returns `intercept_` and `predict(1)` returns `intercept_ + coef_`.)\n",
    "\n",
    "In the code, the `y_test` matrix (from when we split the set) contains the real observations. `y_pred` assigned here contains the predictions for the same `X_test` inputs. It's not expected that the test or training points exactly fit the regression; the regression is trying to find the model that we can use to make predictions with new observations of the independent variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[79.49588055 75.98873911 77.87719989 80.03544077 75.17939878]\n"
     ]
    }
   ],
   "source": [
    "y_pred = regressor.predict(X_test)\n",
    "print(y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's interesting to think that all the \"predictions\" we use in daily life, like weather forecasts, are just regression models of some sort working with various data sets. Those models are much more complicated than what's shown here, but the idea is the same.\n",
    "\n",
    "Knowing how predictions work help us understand that the actual observations we would collect in the moment will always be somewhat off from the predictions: the predictions fit exactly to the model, whereas the observations typically won't.\n",
    "\n",
    "Of course, such systems feed new observations back into the dataset to continually improve the model, meaning that predictions should get more accurate over time.\n",
    "\n",
    "The challenge is determining what data to actually use. For example, with weather, how far back in time do you go? How have weather patterns been changing decade by decade? In any case, something like weather predictions will be doing things hour by hour, day by day, for things like temperature, precipitation, winds, cloud cover, etc. Radar and other observations are of course fed into the model and the predictions are reduced to mathematics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the results\n",
    "\n",
    "The following code generates a plot: green dots are training data, red dots are test data, blue dots are predictions. Gray line is the regression itself. You see that all the blue dots are exactly on the line, as they should be, because the predictions exactly fit the model (the line)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzt3Xl8VPW5x/HPw25YlUVBTVK97uWKGlu1ai3gVquoVwsaW9ErcW1FRWsbtdfWuF21uPTWckHQ2ygiKtYF1OJ+7xWBugAXN4REFIGKIBqQAM/945zIJDOTTJaZk5n5vl+vvGbmd7bnTJJ55vx+5zzH3B0REclfHaIOQEREoqVEICKS55QIRETynBKBiEieUyIQEclzSgQiInlOiUDyhpkdZ2YfRhzD3ma2OeIYpprZNUmmdTWzr8xsUKbjkugoEbRz4T9l3c9WM9sQ87o06vhaw8w+M7PDo45DtnH3b9y9h7t/GnUsLdUekm226RR1ANI4d+9R99zMlgHnufvfoosoNWbWyd3T+s+YiW1IfWbW0d23RB2HtC0dEWQ5M+toZtea2Udm9g8zqzSzPuG0vc1ss5n9q5l9Ymafm9m5ZnaomS00s7VmdkfMui4wsxfM7M9m9qWZ/Z+ZHRkzfQczeyD8Jv+xmf3WzDo0WPaPZvYFcHW4/ZfMbI2ZrTaz+82sZzj/I8AA4Lnw6OaXibpuYo8azOxmM3vQzB42s/XAqMb2v5H37Powpo/M7PSY9lPM7O1w36vM7Dcx07qHXSprwvdtjpltn8L70snM7gzf+w+Bo5uIbbCZvRpu4x0zOz5m2lQzG29mz5rZejP7bzMramRdR5nZ62a2zsyqzezMmMn9Eq3HzLqZmZvZLjHbvMvMnjOzr4FDw7a7zezFcPnZZrZzc+MI37cHw7+NpWZ2lZlZOO1mM5sYs4563/LD9f02fPzSzJ6p+30ArwAdbduR8wGNvecCuLt+suQHWAYMb9B2NfAqMAjoBkwBJofT9gYcuBPoCpwEfA08CvQFCoEvgO+H818AbAYuAjoDPwfWAL3C6TOBu4ECYCDwJnB2g2XHAB2B7cLtDwW6ADsBrwM3x8T+GXB4zOvjgA8b7N+38wA3A98APyb4ErNdY/uf4P07LozxpjCm4UAN8J1w+jBgv3DdB4b7flw47VJgerjNTsDBQPcU3pexwIIwvv7Aa8DmJPF1A6qAK8L3/1jgq5j4pgKrwtg6h/FMSbKufwqX/Zcw3v7A/k2tJ4zBgV1i5l0DfD98X7qGbWuBQ8P57wX+1oI4pgGPAD3C+ZYCpTG/64kx69k79n0L/5beA3YHugP/A/xbonn1k8JnS9QB6KcZv6zEiWAp8IOY198JP9yMbYmgb8z0r4ERMa+fBi4In18ALG2w/neA04GicNnOMdPOAWbGLPt+E/GPAv435nVLEsFzqe5/gu0fB2wEusW0/RW4Mkm89wI3hc8vAl4Gvttgnqbel/8BRsdMOynZhxTB0UJVbOzA48DV4fOpwD0x004F3kqyruuBh5JMS7oeEieCCQmWnxLzeodwmf6pxkGQULYAu8W0XQrMivldN5UIxsW8vhyYkWhe/TT9ozGCLBYeRu8KPGNmsdUDOxB84wfY4u6fx0zbAKxs8LpHzOvlDTZTRfBttojgQ2J1ePRet53YrpyPG8Q3iOBo5DCgZzj/ilT2rRHfbiOF/f9HguVXu/vGmNd1+4eZ/QC4EdiX4IihK/Bf4XyTCI5qpptZD+AB4Fqafl8GUf99qWpk3wYB1R5+msXMH9vt8lnM8xrq/+5i7QosaWRbqa4HGvxeG7a5+xoz+4og/tUpxrETwftUHdPWcF+b0px9kEZojCCLhR8YnwBD3b1PzE83d0/0IZiKXRq8LgQ+JfjH/wrYPmY7vdz9wNiQGiz77wTflr/r7r2A8wiOVJLN/zVB9woAZtaZ4NtmrG+XaeH+9zOzbgn2D4KuioeBXd29N0E3k4Xb+sbdr3P3vYEjCY6SRqXwvqwg+DCM3V4ynyaYXhjuY3N9TNBt0hYSlSj+dp/MbAeCD+FEST5ZHJ8BW6m/v7H7Wu9vgSBxtCZeaYQSQfa7F7jZzHYFMLMBZnZiK9a3qwUDv53M7CyCf87n3H0pweH4rWbW08w6mNke1vjpnz0JPiS/NLNCgsP3WCuB3WJeLwZ2MLNhYRK4nqb/Rpu7/52Ba82si5kNJeiOeTQ8uugBfO7uG83sMIIPe8L1DjezfcNB4C8Jxhq2pPC+TAMuM7OBZtYPuKqR2F4FOpjZ2PD9Pxo4hqAfvbkeAH4SDoB3NLP+ZvbPLVhPMiPM7Ptm1hW4AXjR3VelGoe7f0PQ7XWjBQPxuxN0Df0lXO4t4EdmtnM4CPyrZsS2imCwuLGkKzGUCLLfrcDfgBcsOJPmfwgGAVvqFeAAggHCcuAUd18XTjsD6AO8G05/GNixkXVdBxwOrCP4p3+0wfQKoCI8Q+aS8Fv8pUAlQRfVZyTu3onV3P1fRvAh/hlwH3COu38UHl1cANwWrucq6n8A7ww8AawHFgLPEHzIQ+Pvyz0EH/CLgDkxy8QJu6x+ApwGfA7cAYx098a6eJKtawkwAvgNwQkB8wgGwtvKXwj68f8B7AOc3YI4zg8fq4AXgIkEv3sIxq6eAv6PINHOSDUwd/+C4O9ifvi3NSTlvcpTVr87UvKZmV0AnObuw6OORdovM5sKLHT3G6KORdqGjghERPKcEoGISJ5T15CISJ7TEYGISJ7LigvK+vXr58XFxVGHISKSVebPn/8Pd+/f1HxZkQiKi4uZN29e1GGIiGQVM2vsSvZvqWtIRCTPKRGIiOQ5JQIRkTynRCAikueUCERE8pwSgYhIBlQuqKR4fDEdru9A8fhiKhdUNr1QhmTF6aMiItmsckElZU+WUVNbA0DVuirKniwDoHRwaZShAToiEBFJu/LZ5d8mgTo1tTWUzy6PKKL6lAhERNKsel11s9ozTYlARCTNCnsnvllasvZMUyIQEUmzimEVFHQuqNdW0LmAimEVEUVUnxKBiEialQ4uZcKJEyjqXYRhFPUuYsKJE9rFQDFkyf0ISkpKXEXnRESax8zmu3tJU/PpiEBEJM8pEYiI5DklAhGRPKdEICKS55QIRETynBKBiEieUyIQEclzSgQiInlOiUBEJM8pEYiI5DklAhGRPKdEICKS55QIRETynBKBiEieUyIQEclzSgQiInlOiUBEJM8pEYiI5DklAhGRPJfWRGBml5rZQjNbZGZjw7YdzOx5M/sgfNw+nTGIiGSb+fPnc/311zN37tyMbK9TulZsZt8FxgDfAzYBs8zs6bBttrvfbGZXA1cDv0pXHCIi2aCmpoZp06ZRVVX1bdvq1aszsu20JQJgH+B1d68BMLOXgVOAEcBR4Tz3Ay+hRCAieeq9995j6tSp9dr69u3Lz372M3r37p2RGNKZCBYCFWbWF9gA/BiYB+zo7isA3H2FmQ1ItLCZlQFlAIWFhWkMU0Qks2pra/nrX//KwoUL67UfddRRHHnkkZhZRuNJWyJw98VmdgvwPPAV8DawuRnLTwAmAJSUlHhaghQRyaDXX3+dZ599tl5bly5dOPfcc9lxxx0jiiq9RwS4+yRgEoCZ3QgsB1aa2cDwaGAgsCqdMYiIRGnLli3ccMMNce0HHXQQxx9/PB07dowgqvrSmgjMbIC7rzKzQuBU4FDgO8DZwM3h4xPpjEFEJAqJ+v4h6P754Q9/GEFEyaU1EQCPhmMEtcDF7v6Fmd0MTDOzfwWqgdPTHIOISEa4O3/4wx9Yv3593LTLL7+cnj17RhBV09LdNXREgrbPgWHp3K6ISCZ99tln/PnPf45r33vvvRk5cmQEETVPuo8IRERy1tSpU3nvvffi2s8//3x22mmnCCJqGSUCEZFmWL9+PXfccUdce+/evbn00kszfupnW1AiEBFJwQsvvMCrr74a137GGWew5557RhBR21EiEBFJYtOmTdx0000Jp11zzTVpO/WzckEl5bPLqV5XTWHvQiqGVVA6uDQt2wIlAhGROG+//TYzZsyIaz/22GM55JBD0rrtygWVlD1ZRk1tDQBV66ooe7IMIG3JQIlARATYunUrv//97xNOu+qqq9huu+0yEkf57PJvk0CdmtoaymeXKxGIiKRDVVUVU6ZMiWs/6KCD+MlPfpLxeKrXVTervS0oEYhIXpo4cSKffPJJXPsvfvELdthhhwgiChT2LqRqXVXC9nRRIhCRvLFmzRruvvvuuPadd96Z8847L4KI4lUMq6g3RgBQ0LmAimEVadumEoGI5LynnnqK+fPnx7WPHj2aoqKiCCJKrm4cIJNnDZl7+6/wXFJS4vPmzYs6DBHJIhs2bODWW2+NazczrrnmGjp0yP1btpvZfHcvaWo+HRGISE6ZM2cOs2bNims/+eST2X///SOIqP1TIhCRrJes5j/Ar3/9a7p06ZLhiLKLEoGIZK3333+fhx56KK79iCOOYOjQoRFElJ2UCEQkq7g748eP58svv4ybdtlll9GrV68IospuSgQikhWS1fzfa6+9GDVqVAQR5Q4lAhFp1x5++GHefffduPZsq/nfnikRiEi7k6zmf69evRg7dmxW1vxvz5QIRKTdePHFF3nllVfi2keNGsVee+0VQUT5QYlARCIVVc1/2UaJQEQi8c477/D444/HtR9zzDEceuihEUSUv5QIRCRj3J0bbriBrVu3xk278sorKSgoiCAqUSIQkbSrrq5m8uTJce0HHHAAJ510UgQRSSwlAhFJm0mTJrF8+fK49ksuuYS+fftGEJEkokQgIm0qWc3/QYMGMWbMmAgikqYoEYhIm3j66adJVC7+7LPPpri4OPMBScqUCESkxZLV/Ae49tpr86Lmfy5QIhCRZktW83/EiBEMGTIkgoikNZQIRCQlqvmfu5QIRKRRH3zwAQ8++GBc++GHH86wYcMiiEjamhKBiMRxd+666y7Wrl0bN001/3OPEoGIfGvlypXce++9ce177rknZ5xxRgQRSSakNRGY2WXAeYADC4BzgHuBHwLrwtlGu/tb6YxDRBo3bdo0Fi9eHNdeVlbGwIEDI4hIMilticDMdgZ+Cezr7hvMbBpQdxuhK919erq2LSJNS1bzv2fPnlx22WWq+Z9H0t011AnYzsxqgQLg0zRvT0Sa8NJLL/Hyyy/HtY8cOZK99947gogkaiklAjPbBdjD3V80s65AJ3f/urFl3P0TM7sNqAY2AM+5+3NmdiZQYWbXAbOBq939mwTbLAPKAAoLC5u1UyJSX21tLTfeeGPCaeXl5XTqpOHCfGbu3vgMZucClwC93X13M9sT+A93H97EctsDjwIjgbXAI8B0gg//z4AuwARgibv/rrF1lZSUeKJL10WkcQsWLOCxxx6La1fN//xgZvPdvaSp+VL5GvBL4HvAHAB3f9/MBqSw3HBgqbuvDgN6DDjM3f8STv/GzCYD41JYl4ikSDX/pblSSQQb3X1T3cCRmXUEUhlFqgYOMbMCgq6hYcA8Mxvo7issWOHJwMKWhS4isT7++GPuu+++uPYhQ4YwYsSItGyzckEl5bPLqV5XTWHvQiqGVVA6uDQt25L0SSUR/LeZXQV0M7MfARcDTzW1kLvPMbPpwN+BzcCbBF1BM82sP0EyeQu4oKXBiwhMnjyZ6urquPaLL76Yfv36pW27lQsqKXuyjJraGgCq1lVR9mQZgJJBlklljKAjwaDtMQQf3s8Cf3b3+OPONNEYgUh9X3zxBXfddVdc+8CBAykrK8tIDMXji6laVxXXXtS7iGVjl2UkBmlcm4wRhEngPnc/G/hTWwUnIi3zzDPPMHfu3Lj2KGr+V6+LPwpprF3ar0YTgbtvMbOBZtbZ3WszFZSIbLNx40ZuueWWhNOirPlf2Lsw4RFBYW+d7p1tUhkj+Ah41cyeAL69dsDd449LRaTNvPHGG8ycOTOuvb3U/K8YVlFvjACgoHMBFcMqIoxKWiKVRLAaeJ7gymCddyY5L8ozYRqr+X/11VfTtWvXjMSRirr3RGcNZb8mB4vbAw0WS6Y0PBMGgm+5E06ckNYPuGQ1/3/wgx8wfHij126KJNVmF5SZ2fME1UPrcfdjWhib5KPKSigvh+pqKCyEigoobX/fHMtnl9dLAgA1tTWUzy5v80Sgmv/SXqTSNXRNzPNuwL8AcbWBRJKqrISyMqgJP2CrqoLX0O6SQSbOhElW83+PPfbgzDPPbLPtiKSqyUTg7nMaNL1sZvGlC0WSKS/flgTq1NQE7e0sEaTzTJjp06ezaNGiuPYxY8YwaNCgVq9fpKVS6RqKPT7tABwE6E4VkroEV7022h6htj4T5quvvuL222+Pa+/evTtXXHGFav5Lu5BK19AigjECIygVsRQYk86gJMcUFgbdQYna25m2OhPm5Zdf5qWXXoprV81/aY9SSQS7NbyYzMxUvFxSV1FRf4wAoKAgaG+HSgeXtmhgWDX/JVul8pc5BziwQdsbCdpEEqsbB8iCs4aaq3JBJRNnTuSoDUfFTTv66KM57LDDMh+USDMlTQThPQcGEtxqcjDbSk/3QheWSXOVlubEB38dd+f3Fb/HtzhHcVS9ad854Tv8vOTn0QQm0gKNHRGcAJwL7AL8R0z7euDadAYl0l4lq/n/Jm/yBE8AUPRakRKBZJWkicDdJwOTzeyn7j4tgzGJtDszZ87kjTfeiGu/m7v5nM/rtan6pmSbVK4jmGZmxwL7EVxQVteeeFRMJEesX7+eO+64I659xx135IILLqB4fDGfr/s8brqqb0q2SeU6gv8A+gBHApMJrix+Pc1xiURmzpw5zJo1K679iR5P8NZXb1G4sZCeC3qq+qbkjFTuUPaOu/+zmb3t7vubWU/g0UzWGlLROUm3TZs2cdttt1FbW/+2G4WFhXQ+qDPnP3V+wkJ0oOqb0n61WdE5YGPdo5ntBHwOFLciNpF249133+Xhhx+Oaz/zzDPZY489gOCWjMkK0S0bu0wf/JL1UkkEz5hZH+A2gpvNbwHuT2tUImm0detWJk6cyIoVK+q1FxQUMHbsWDp37lyvXbdklFzX1D2LOwAz3X0t8IiZPQVs5+5rMhKdSBv65JNPmDhxYlz7CSecQElJ8qNn3ZJRcl1T9yzeamZ3AoeErzcAGzIRmEhbcHcef/xxFixYEDdt3LhxdO/evcl1aFBYcl0qXUPPm9kId38i7dGItJEvvviCu+6Kv632YYcdxtFHH92sdemWjJLrUjlr6AugN8HNaDYQlJpwd98h/eEFdNaQpCpZ1c+LL76Yfv36ZT4gkQi15VlD+u+Rdm3Dhg3ceuutce177bUXI0eOVM1/kSakcmXxFjMbRVCO+kYz2wXYEZif9uhEGvH2228zY8aMuPbRo0dTVFQUQUQi2SmVK4vvAToTXFl8I1AD3AscnN7QROJt3ryZP/7xj3E3fO/bty8XXnghHTt2jCgykeyVStfQYe5+oJm9CeDua8ysS5rjkixQuaAyYwOoS5cu5YEHHohrP/XUUxk8eHBathkrk/sqkmmpJILa8HoCBzCzvsDWtEYl7V7lgsp6p1RWraui7MkygDb7gHR3KisrWbJkSdy0X/3qV3Tr1i3BUm0vE/sqEqVUzhr6OXAKUALcB/wUuN7dp6Y/vIDOGmp/iscXJ7zIqqh3EcvGLmvVuletWsWf/vSnuPahQ4dyxBFHtGrdLZHOfRVJpzY7a8jdHzCz+cDwsOl0d1/Y2gAlu6Wj7MKsWbOYM2dOXPull15Knz59Wrze1lKJCcl1qd5NuyNQS9A91CF94Ui2aKuyC8lq/g8ZMoQRI0a0OL62pBITkutSOWuoHDgTeJzgYrIHzazS3W9KYdnLgPMIEsgC4ByC+yBPBXYA/g78zN03tXgPJBLNLbtQWVn/3vVXXvkG//jHzLj5xowZw6BBg9IWd0uoxITkulTGCBYDB7l7Tfi6AJjv7vs0sdzOwGvAvu6+wcymAc8APwYec/epZnYv8La7x3cIx9AYQfuU6pk0lZVQVga1tZsYN+52unatn/d33XVXRo8eTYcO7fdgU2cNSTZKdYwglUQwC/ipu38Zvu4FPOTuJzSx3M4EdzLbH/gSmAHcDVQCO7n7ZjM7FPg3dz+2sXUpEWS3I454j+HD488teP75M3jttT0jiEgkP7RliYkaYJGZPUvQxXMM8JqZ3QHg7pcnWsjdPzGz24BqghpFzxFcjbzW3TeHsy0Hdk6yA2VAGQR3icpm+fhtcuvWrUyaNIlPP/2U4cO3tW/Y0I077riM2touqPKDSPuQSiJ4Ovypk9L9is1se2AE8B1gLfAIcHyCWRMekrj7BGACBEcEqWyzPcrlc9Ab9vtXVMBRRyWu+f/00z9m7tz6F6NneX4XyRmpnD46qYXrHg4sdffVAGb2GHAY0MfMOoVHBbsAn7Zw/VmhfHZ50tscZnMiqOv3r6kBcA48cAYffvgOH35Yf74rrriCJ57owaJF9dsLCoLEISLRS+WsoeOA3wNF4fyplqGuBg4JB5c3AMOAecCLwGkEZw6dDeT0fQ5y9Rz08nLo3n0VV10VP85/yCGHcOyx24Z9Sku3LRN79FCavXlQJKek0jV0D8HVxAtoRmkJd59jZtMJThHdDLxJ0NXzNDDVzG4I21p6xJEVcvEc9EcffZRzzom/pvCeey7i88/7szXBX0lpqT74RdqrVBLBcuAtd292fSF3/y3w2wbNHwHfa+66slWunIP+1Vdfcfvtt8e1b9jQjVtuuYrgQBFU/Vkk+6SSCK4CnjSzlwjuUgaAu8ffB1DiZPttDl999VVeeOGFuPaddjqdyy/fNxwjCKjfXyQ7pZIIricoL9EHVR1tkdLBpVnzwQ9QW1vLjTfemHBaeXk5nToFfzY9eqjfXyQXpJIIBrj7QWmPRCK3aNEipk+fHteerOqn+v1FckMqiWC2mQ119/j+Acl67s4tt9zCN998Ezdt3LhxdO/ePYKoRCSTUkkEY4BxZlYDbCL100elHVu+fDmTJsWfsDV48GBOPfXUCCISkaikkgj6pT0KyZgHHniApUuXxrVfeOGFDBgwIIKIRCRqqVxZvMXMRgG7ufuNZrYLsCNB3SDJAmvXruXOO++Ma+/Xrx8XXXQRpqI/InktlSuL7wE6A0cCNxIUobsXOLix5SR6zz77LK+/Hl8a6qyzzmL33XePICIRaY9S6Ro6zN0PNLM3Adx9jZl1SXNckoJERd9GjtzMgw8+mLD759prr23XNf9FJBqpJIJaM+tAWCXUzPqi6wkiV7/oG9TWfsr770+koqJ+odYTTjiBkpImy5GLSB5LmghiKoT+EXgU6G9m1xPUHbo+Q/FJEuXlsGGDM3ToCxx55Gv1pg0ZMoQTTjjh2wu/REQa09gnxRvAge7+gJnNJygrbcDp7h5fcUwyZs2aNZxyygP06bOuXvtf/lLKkiX/lLDom4hIMo0lgm9PJXH3RcCiRuaVNHN35s6dy8yZwQ3f+/QJ2pcs2Y1HHjmNjRu3A1T0TUSar7FE0N/MEt6GEsDd70hDPNLA119/zdSpU1m+fHm99gEDRjBu3BAVfRORVmssEXQEehBzZCCZs3jxYqZNm1avrX///px11ln06tULgF69VPRNRFqvsUSwwt1/l7FIhE2bNjFjxgwWL15cr33o0KEcfvjhcRd+qeibiLSFlMYIJL2qqqqYMmVKvbZu3bpxzjnnqOyDiKRdY4lgWMaiyENbtmzh2WefZe7cufXaDz74YI499lg6duwYUWQikm+SJgJ3X5PJQPLFqlWrmDx5Mhs3bqzXPnr0aIp0yo+IREBXHGXIpk2buOmmm+q17bPPPpx88sl06aKKHSISHSWCDFm7du23z0877TT222+/CKMREdnG3L3puSJWUlLi8+bNa/kKElVn0+k2IpLjzGy+uzdZbCz3jwgaVmerqgpeg5KBiAiQ+zWJy8upd/ktBK/Ly6OJR0Skncn9RFBd3bz2BCorobgYOnQIHisr2yQyEZF2IfcTQWFh89obqOtZqqoC9209S0oGIpIrcj8RVFQE1dhiNaM6m3qWRCTX5X4iKC2FCROC+sxmweOECSkPFLdBz5KISLuW+2cNQauqsxUWBt1BidpFRHJB7h8RtFIre5ZERNq9vEgErTnrp5U9SxlXuaCS4vHFdLi+A8Xji6lcoFFtEWlczl9Z3PB6Mgi+0bfnD/OWqlxQSdmTZdTUbtvZgs4FTDhxAqWDc2xnRaRJqV5ZnLZEYGZ7AQ/HNO0GXAf0AcYAq8P237j7M42tqzWJoLg4cR9/UREsW9aiVbZbxeOLqVoXv7NFvYtYNnZZ5gMSkUhFXmLC3d8DhoTBdAQ+AR4HzgH+4O63pWvbsfLprJ/qdYl3Klm7iAhkboxgGLDE3RN8N0+vVl5PllUKeyfeqWTtIiKQuUQwCngo5vUlZvaOmd1nZtsnWsDMysxsnpnNW716daJZUpJPZ/1UDKugoHP9nS3oXEDFsBzcWRFpM2lPBGbWBTgJeCRs+hOwO0G30Qrg9kTLufsEdy9x95L+/fu3ePvZdtZPa5QOLmXCiRMo6l2EYRT1LtJAsYg0Ke1nDZnZCOBidz8mwbRi4Cl3/25j62j1/QhERPJQqoPFmegaOoOYbiEzGxgz7RRgYQZiEBGRJNJaYsLMCoCjgfNjmm81syGAA8saTBMRkQxLayJw9xqgb4O2n6VzmyIi0jx5UWJCRESSUyIQEclzSgQiInlOiUBEJM8pEYiI5DklAhGRPKdEICKS55QIRETynBKBiEieUyIQEclzSgQiInlOiUBEJM8pEYiI5DklAhGRPKdEICKS55QIRETynBKBiEieUyIQEclzSgQiInlOiUBarrISiouhQ4fgsbIy6ohEpAXSevN6yWGVlVBWBjU1weuqquA1QGlpdHGJSLPpiEBaprx8WxKoU1MTtItIVlEikJaprm5eu4i0W0oE0jKFhc1rF5F2S4lAWqaiAgoK6rcVFATtIpJVlAikZUpLYcIEKCoCs+BxwgQNFItkIZ01JC1XWqoPfpEcoCMCEZE8p0QgIpLnlAhERPKcEoGISJ5TIhARyXNpSwRmtpeZvRXz86WZjTWzHczseTP7IHxbhBflAAAIQklEQVTcPl0xiIhI09KWCNz9PXcf4u5DgIOAGuBx4GpgtrvvAcwOX4uISEQy1TU0DFji7lXACOD+sP1+4OQMxdByKrcsIjksUxeUjQIeCp/v6O4rANx9hZkNSLSAmZUBZQCFUdavUbllEclx5u7p3YBZF+BTYD93X2lma929T8z0L9y90XGCkpISnzdvXlrjTKq4OPjwb6ioCJYty3Q0IiIpM7P57l7S1HyZ6Bo6Hvi7u68MX680s4EA4eOqDMTQcu253LK6rESkDWQiEZzBtm4hgL8CZ4fPzwaeyEAMLddeyy3XdVlVVYH7ti4rJQMRaaa0JgIzKwCOBh6Lab4ZONrMPgin3ZzOGFqtvZZb1h3CRKSNpHWw2N1rgL4N2j4nOIsoO9QNCJeXB91BhYVBEoh6oLg9d1mJSFZRGepUtMdyy4WFiQexo+6yEpGsoxIT2aq9dlmJSNZRIshWukOYiLQRdQ1ls/bYZSUiWUdHBCIieU6JQEQkzykRiIjkOSUCEZE8p0QgIpLnlAhERPKcEoGISJ5L+/0I2oKZrQYS1FPIOv2Af0QdRBpov7JLLu5XLu4TtH6/ity9f1MzZUUiyBVmNi+Vm0RkG+1XdsnF/crFfYLM7Ze6hkRE8pwSgYhInlMiyKwJUQeQJtqv7JKL+5WL+wQZ2i+NEYiI5DkdEYiI5DklAhGRPKdEkCZmdp+ZrTKzhTFt/2Zmn5jZW+HPj6OMsSUS7VfY/gsze8/MFpnZrVHF11JJfl8Px/yulpnZW1HG2FxJ9mmImb0e7tM8M/telDG2RJL92t/M/tfMFpjZk2bWK8oYm8vMdjWzF81scfg/dGnYvoOZPW9mH4SP26dj+0oE6TMFOC5B+x/cfUj480yGY2oLU2iwX2b2I2AE8M/uvh9wWwRxtdYUGuyXu4+s+10BjwKPRRFYK0wh/m/wVuD6cJ+uC19nmynE79dE4Gp3Hww8DlyZ6aBaaTNwhbvvAxwCXGxm+wJXA7PdfQ9gdvi6zSkRpIm7vwKsiTqOtpZkvy4Ebnb3b8J5VmU8sFZq7PdlZgb8FHgoo0G1UpJ9cqDu23Jv4NOMBtUGkuzXXsAr4fPngX/JaFCt5O4r3P3v4fP1wGJgZ4IvWPeHs90PnJyO7SsRZN4lZvZOeHiblsO8COwJHGFmc8zsZTM7OOqA2tgRwEp3/yDqQNrAWODfzexjgiO3X0ccT1tZCJwUPj8d2DXCWFrFzIqBA4A5wI7uvgKCZAEMSMc2lQgy60/A7sAQYAVwe7ThtJlOwPYEh7RXAtPCb9G54gyy7GigERcCl7n7rsBlwKSI42kr5xJ0p8wHegKbIo6nRcysB0E35Fh3/zJT21UiyCB3X+nuW9x9K/CfQNYN1CWxHHjMA28AWwmKZWU9M+sEnAo8HHUsbeRsto11PEKO/A26+7vufoy7H0SQtJdEHVNzmVlngiRQ6e51v6OVZjYwnD4QSEu3qxJBBtX9QkOnEBzO5oIZwFAAM9sT6ELuVIIcDrzr7sujDqSNfAr8MHw+FMiF7i7MbED42AG4Brg32oiaJzyCngQsdvc7Yib9lSB5Ez4+kZbt68ri9DCzh4CjCL4ZrwR+G74eQjBgtww4v67/L1sk2a//Au4j2LdNwDh3fyGqGFsi0X65+yQzmwK87u5Z9cECSX9X7wF3EnTnbQQucvf5UcXYEkn2qwdwcTjLY8CvPYs+3MzscOBVYAHBETXAbwjGCaYBhUA1cLq7t/lJKEoEIiJ5Tl1DIiJ5TolARCTPKRGIiOQ5JQIRkTynRCAikueUCCRrmdlOZjbVzJaY2f+Z2TNmVmZmTyWZf2JYyKuttj/fzLqkOG+Jmd3Vim2NNrNBLV1epDGdog5ApCXCC3AeB+5391Fh2xDgxGTLuPt5SdbV0d23NHP7xcAn7p5SKQN3nwfMa842GhhNcAFi1hWJk/ZPRwSSrX4E1MZe6OXubxFclNPDzKab2btmVllX98jMXjKzkvD5V2b2OzObAxwa3m/gFjN7I/z5p3C+081soZm9bWavxGz/eGBWzLpuCY8Q/mZm3wu39ZGZnRTOc1TdkYoF96W4L2aeX4btxQ1q7I8L5z0NKAEqw/sIbGdmB4UF/uab2bMNrloXaRYlAslW3wWSXRF7AEGVzX2B3YAfJJinO7DQ3b/v7q+FbV+6+/eAe4DxYdt1wLHuvj/bqltCUA9/Vsy6Xgrr3KwHbgCOJigj8rskMe4NHEtQ6+e3YZ2ZhNx9OsHRRGl4H4HNwN3AaeE27wMqki0v0hR1DUkueqOuNpAFdxUrBl5rMM8WggJfsR6KefxD+Py/gSlmNo2wWFs4LrCLu38UzrOJbUlhAfCNu9ea2YJw24k8Hd6/4RszWwXs2Iz924sgET4fHux0JKhmK9IiSgSSrRYBpyWZ9k3M8y0k/jvfmGBcwBs+d/cLzOz7wAnAW+E4xBDqJ5bamLo2W+u27+5bw+qlqca4mfpH6d2SLGvAInc/NMl0kWZR15BkqxeArmY2pq4hvCHOD5Mv0qSRMY//G65zd3ef4+7XEVRU3ZWgW2hmK7aTzEpggJn1NbOuwE9ipq0nqLMPQeG4/mZ2aBhjZzPbLw3xSJ7QEYFkJXd3MzsFGG9mVxNU0lxGUBK7pbqGg8cdCG5GA8HdvPYg+BY+G3ib4F4S17ViOwmF3Um/I6g4uRR4N2byFOBeM9sAHEpwNHSXmfUm+D8eT3CUJNJsqj4qApjZMqDE3Ru9j4KZ7QL8p7sfn5HARDJARwQizRAOQisJSE7REYGISJ7TYLGISJ5TIhARyXNKBCIieU6JQEQkzykRiIjkuf8HLtz8vsDR4Z0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fbe38f74b00>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.scatter(X_train, y_train, color = 'green')\n",
    "plt.scatter(X_test, y_test, color = 'red')   \n",
    "plt.scatter(X_test, y_pred, color = 'blue')  # The predicted temperatures of the same X_test input.\n",
    "plt.plot(X_train, regressor.predict(X_train), color = 'gray')\n",
    "plt.title('Temperature based on chirp count')\n",
    "plt.xlabel('Chirps/minute')\n",
    "plt.ylabel('Temperature')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}