Linear_Regression.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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"
    },
    "colab": {
      "name": "Domańska - Linear_Regression.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zoaXREEhyxJm"
      },
      "source": [
        "<center>\n",
        "<h1>Linear regression introduction</h1>\n",
        "<h2>\n",
        "Deep learning classes<br>\n",
        "</h2>\n",
        "<h3>\n",
        "This is a graded assignment<br>\n",
        "</h3>\n",
        "</center>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sboDOplPyxJn"
      },
      "source": [
        "### Basic information\n",
        "<ul>\n",
        "    <li>This task is build of:\n",
        "    <ul>\n",
        "        <li>Descriptions (in the Markdown cells)\n",
        "        <li>Already prepared fragments of code\n",
        "        <li>The placeholders for your code\n",
        "    </ul>\n",
        "    <li>Your code should be entered in the `Code` cells. The places are marked by <b># ENTER YOUR CODE HERE</b> note.\n",
        "    <li>Usually you should enter only a few lines of code. But if you think you need it, you may use as many lines and add as many new code cells as you wish.\n",
        "    <li>You should solve the assignment in the defined order. It is often impossible to solve the next task, if you did not sove the previous one.\n",
        "    <li>This assignment is graded. \n",
        "    <li>During the grading you may expect some questions. <b>Sending the code to the teacher is not sufficient for passing.</b>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fqeu2VqMyxJn"
      },
      "source": [
        "Here we import all the necessary libraries, and set some initial parameters."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S_t2Nh3kyxJo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 202
        },
        "outputId": "a66105d9-f0ef-45d1-88cc-25322b938178"
      },
      "source": [
        "# The line below downloads the helper from github repository. \n",
        "# Uncomment it, if you are opening the notebook in Google Colab directly from the GitHub\n",
        " \n",
        "!wget https://raw.githubusercontent.com/PrzemekSekula/DeepLearningClasses1/master/LinearRegression/helper_linear_regression.py"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-10-21 09:13:50--  https://raw.githubusercontent.com/PrzemekSekula/DeepLearningClasses1/master/LinearRegression/helper_linear_regression.py\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.0.133, 151.101.64.133, 151.101.128.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.0.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 3936 (3.8K) [text/plain]\n",
            "Saving to: ‘helper_linear_regression.py.1’\n",
            "\n",
            "\r          helper_li   0%[                    ]       0  --.-KB/s               \rhelper_linear_regre 100%[===================>]   3.84K  --.-KB/s    in 0s      \n",
            "\n",
            "2020-10-21 09:13:50 (47.1 MB/s) - ‘helper_linear_regression.py.1’ saved [3936/3936]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tht8ZgfsyxJs"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import helper_linear_regression as hlp\n",
        " \n",
        "%matplotlib inline"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l8YGmgrcyxJu"
      },
      "source": [
        "The cell below is used for generating the data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-8ejhqJlyxJv",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "5987052b-e04b-4616-e829-2ed4de204a9b"
      },
      "source": [
        "# The line below assures that the random function will return the same values every time\n",
        "np.random.seed(12)\n",
        " \n",
        "coefs = [50, 25, -1.25, 0.01]\n",
        "datalength = 80\n",
        "noise = 0.2\n",
        " \n",
        "x, y = hlp.getXY(coefs, datalength, noise)\n",
        " \n",
        "f = plt.figure()\n",
        "plt.scatter(x, y)\n",
        "plt.title('Your dataset')\n",
        "plt.xlabel('X (inputs)')\n",
        "plt.ylabel('Y (labels / targets)');\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UTPZGMALyxJx"
      },
      "source": [
        "### Task 1\n",
        "Let's assume that your function is linear ($y = \\Theta_0 + \\Theta_1*x$). Try to select the $\\Theta_0$ i  $\\Theta_1$ manually in order to create your model. Use the code below for visualizing results.\n",
        "\n",
        "*Note: This task is not about machine learning. You should just select the parameters manually, in order to get a good intuition. The parateres should be \"quite good\", but they do not have to be perfect.* "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_BLgOEBlyxJy",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "a7de631d-1c0f-4b04-d8a7-af6c68e230ca"
      },
      "source": [
        "my_th0 = 400 # ENTER YOUR CODE HERE (tune this parameter)\n",
        "my_th1 = -20 # ENTER YOUR CODE HERE (tune this parameter)\n",
        " \n",
        "hlp.plot_fitting_lin(x, y, my_th0, my_th1);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlnqnSl3yxJ0"
      },
      "source": [
        "### Task 2  - Hypothesis\n",
        "Prepare the function, which can compute the progosed values $h(x)$ according to the formula:\n",
        "\n",
        "<center>\n",
        "$h(x)  = \\Theta_0 + \\Theta_1 * x$\n",
        "</center>\n",
        "\n",
        "Function arguments:\n",
        "<li>x - input data (vector)\n",
        "<li>th0 - $\\Theta_0$\n",
        "<li>th1 - $\\Theta_1$\n",
        "<br \\>\n",
        "Function returns:\n",
        "<li>h - vector of values computed with the formula above."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BWQSJn43yxJ0"
      },
      "source": [
        "def compute_h(x, th0, th1):\n",
        "    x = np.asarray(x) # It removes problems with older version of libraries\n",
        "    \n",
        "    # ENTER YOUR CODE HERE\n",
        " \n",
        "    h = th0 + th1*x\n",
        "    \n",
        "    # END OF YOUR CODE\n",
        "    return h"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AX_CwzLryxJ3"
      },
      "source": [
        "#### Task 2 - test code\n",
        "You may use the code below, to test your output. The correct results are:<br>\n",
        "[200 185 170 155 140 125 110  95  80  65]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yTti_HmuyxJ3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "15a82ea9-3e20-46d6-ace2-c53cd558a7b5"
      },
      "source": [
        "hlp.testcomputeh(compute_h)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Testing results:  [200 185 170 155 140 125 110  95  80  65]\n",
            "Your code seems to be OK!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uE82rDn7yxJ7"
      },
      "source": [
        "### Task 3 - Cost function\n",
        "Prepare the function, which computes the cost, according to the formula:\n",
        "<br /><br />\n",
        "<center>\n",
        "$J = \\frac{1}{2m}\\sum_{i=1}^{m}{(y_i - h(x_i))}^2$\n",
        "</center>\n",
        "\n",
        "Where:\n",
        "\n",
        "<li>$J$ - cost\n",
        "<li>$y$ - real $y$ values\n",
        "<li>$y_{pred}$ - predicted $y$ values\n",
        "<li>$m$ - length of the $y$ vector (number of observations)\n",
        "\n",
        "Arguments:\n",
        "\n",
        "<li>y - vector with real y values\n",
        "<li>h - vector with predicted y values ($h(x)$)\n",
        "\n",
        "Function returns:\n",
        "\n",
        "<li> c - cost computed with the given formula.\n",
        "    \n",
        "    \n",
        "*Note: You may compute the mean value of the vector by using: np.mean() function.\n",
        "Example:*\n",
        "<code>\n",
        "X = [1, 2, 3]\n",
        "print (np.mean(X))\n",
        "2\n",
        "</code>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7L-hSBEZyxJ8"
      },
      "source": [
        "def cost(y, ypred):\n",
        "    y = np.asarray(y) # It removes problems with older version of libraries\n",
        "    ypred = np.asarray(ypred) # It removes problems with older version of libraries\n",
        "    \n",
        "    #ENTER YOUR CODE HERE\n",
        "    \n",
        "    c = np.mean((y-ypred)**2) / 2\n",
        "    \n",
        "    # END OF YOUR CODE\n",
        "    return c"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CwQCtEWIyxJ-"
      },
      "source": [
        "#### Task 4 - test code\n",
        "You may test your `cost` function with the code below. If everything is OK, the output will be:<br>\n",
        "**Your code seems to be OK!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YeLiftNZyxJ_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f93ba81b-dcf7-4db8-dfca-78062a8ebb1d"
      },
      "source": [
        "hlp.testcost(cost)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Your code seems to be OK!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7sCtyC3oyxKB"
      },
      "source": [
        "### Task 4 - Computing cost\n",
        "Using the parameters $\\Theta_0$ i $\\Theta_1$ selected in the task 1 compute and display the hypothesis and the cost value.\n",
        "\n",
        "*Note 1: Your parameters are stored in `my_th0` and `my_th1` variables.*<br>\n",
        "*Note 1: You may use your `compute_h` function for computing hypothesis, and `cost` function for computing cost*<br>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "olUvOH8QyxKB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4bc546cb-05e4-41cb-d4d7-076fefec9ad5"
      },
      "source": [
        "h = compute_h(x,my_th0,my_th1) # ENTER YOUR CODE HERE\n",
        "mycost = cost(y,h)  # ENTER YOUR CODE HERE\n",
        "print (mycost)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "17702.428395833304\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hvHsWBM4yxKD"
      },
      "source": [
        "### Task 5 - partial derivatives\n",
        "Prepare the function `compute_derivatives`, which returns the partial derivatives $\\frac{\\delta}{\\delta\\Theta_0}J(\\Theta_0, \\Theta_1)$ and $\\frac{\\delta}{\\delta\\Theta_0}J(\\Theta_0, \\Theta_1)$ where:\n",
        "<center>\n",
        "<br \\><br \\>\n",
        "$J(\\Theta_0, \\Theta_1) = \\frac{1}{2m}\\sum_{i=1}^{m}{(y_i - h_\\Theta(x_i))}^2= \\frac{1}{2m}\\sum_{i=1}^{m}{(y_i - (\\Theta_0 + \\Theta_1x_i))}$\n",
        "<br \\><br \\>\n",
        "$\\frac{\\delta}{\\delta\\Theta_0}J(\\Theta_0, \\Theta_1) = - \\frac{1}{m}\\sum_{i=1}^{m}{(y_i - h_\\Theta(x_i))}$\n",
        "<br \\><br \\>\n",
        "$\\frac{\\delta}{\\delta\\Theta_1}J(\\Theta_0, \\Theta_1) = - \\frac{1}{m}\\sum_{i=1}^{m}{(y_i - h_\\Theta(x_i))x_i}$\n",
        "<br \\><br \\>\n",
        "</center>\n",
        "\n",
        "Arguments:\n",
        "<li>x - input data vector\n",
        "<li>y - output data (labels) vector\n",
        "<li>th0 - $\\Theta_0$ parameter\n",
        "<li>th1 - $\\Theta_1$ parameter\n",
        "<br \\>\n",
        "\n",
        "Function returns:\n",
        "<li>dTh0 - partial derivative $\\frac{\\delta}{\\delta\\Theta_0}J(\\Theta_0, \\Theta_1)$\n",
        "<li>dTh1 - partial derivative $\\frac{\\delta}{\\delta\\Theta_1}J(\\Theta_0, \\Theta_1)$\n",
        "<br \\><br \\>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n4l1uXEByxKE"
      },
      "source": [
        "def compute_derivatives(x, y, th0, th1):\n",
        "    x = np.asarray(x) # It removes problems with older version of libraries\n",
        "    y = np.asarray(y) # It removes problems with older version of libraries\n",
        "    \n",
        "    # ENTER YOUR CODE HERE\n",
        "    \n",
        "    dTh0 = - np.mean(y - compute_h(x,th0,th1))\n",
        "    dTh1 = - np.mean((y - compute_h(x,th0,th1))*x)\n",
        "    \n",
        "    #END OF YOUR CODE\n",
        "    return dTh0, dTh1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6pMeD3VRyxKG"
      },
      "source": [
        "#### Task 4 - test code\n",
        "You may test your `compute_derivative` function with the code below. If everything is OK, the output will be:<br>\n",
        "**dTh0 seems to be OK.**<br>\n",
        "**dTh1 seems to be OK.**<br>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X89p9NFAyxKG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "25345b15-9bc7-44a5-ae8b-823447bdd1e3"
      },
      "source": [
        "hlp.testcomputederivatives(compute_derivatives)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dTh0 seems to be OK.\n",
            "dTh1 seems to be OK.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JfFbvIlayxKO"
      },
      "source": [
        "### Task 6 - updating theta\n",
        "Prepare the `update_theta` function, which updates the values of $\\Theta$ parameters according to the formulas:\n",
        "<center>\n",
        "<br \\><br \\>\n",
        "$\\Theta_0 = \\Theta_0 - \\alpha * \\frac{\\delta}{\\delta\\Theta_0}J(\\Theta_0, \\Theta_1)$\n",
        "<br \\><br \\>\n",
        "$\\Theta_1 = \\Theta_1 - \\alpha * \\frac{\\delta}{\\delta\\Theta_1}J(\\Theta_0, \\Theta_1)$\n",
        "<br \\><br \\>\n",
        "<br \\><br \\>\n",
        "</center>\n",
        "\n",
        "Arguments:\n",
        "<li>th0 - $\\Theta_0$ parameter\n",
        "<li>th1 - $\\Theta_1$ parameter\n",
        "<li>del0 - Partial derivative $\\frac{\\delta}{\\delta\\Theta_0}J(\\Theta_0, \\Theta_1)$\n",
        "<li>del1 - Partial derivative $\\frac{\\delta}{\\delta\\Theta_1}J(\\Theta_0, \\Theta_1)$\n",
        "<li>learning_rate - the learning rate $\\alpha$ parameter\n",
        "<br \\><br \\>\n",
        "Function returns:\n",
        "<li>Updated value of $\\Theta_0$\n",
        "<li>Updated value of $\\Theta_1$\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yauv3NwZyxKP"
      },
      "source": [
        "def update_theta(th0, th1, del0, del1, learning_rate):\n",
        " \n",
        "    # ENTER YOUR CODE HERE\n",
        "    \n",
        "    th0 += -learning_rate * del0\n",
        "    th1 += -learning_rate * del1\n",
        "    \n",
        "    # END OF YOUR CODE\n",
        "    return th0, th1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vwKSn01GyxKW"
      },
      "source": [
        "#### Task 5 - test code\n",
        "You may test your `update_theta` function with the code below. If everything is OK, the output will be:<br>\n",
        "**theta0 seems to be OK.**<br>\n",
        "**theta1 seems to be OK.**<br>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ybk8yUBjyxKW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "42b0c2a6-0b37-4627-ed29-98fa0027065d"
      },
      "source": [
        "hlp.testupdatetheta(update_theta)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "theta0 seems to be OK.\n",
            "theta1 seems to be OK.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zpwq8h7iyxKa"
      },
      "source": [
        "### Task 7 - learning parameters\n",
        "Tune the learning parameters and run the code below. This code will perform entire machine learning, using the functions you prepared in previous tasks.<br>\n",
        "The parameters are as follows:\n",
        "<ul>\n",
        "    <li>learning_rate - $\\alpha$ - learning coefficient. The greater $\\alpha$ the larger change of $\\Theta$ values in each iteration.\n",
        "    <li>epochs - how many times we should repeat the iterations\n",
        "</ul>\n",
        "<br \\>\n",
        "Additional parameter:\n",
        "<ul>\n",
        "<li>display_every - how often should we display the $\\Theta$ and cost values. This parameter does not play any role in learning process, it is only for observations. The value <code> display_every = int(epochs / 20) </code> is reasonable, but you may change it if you wish.\n",
        "</ul>\n",
        "    \n",
        "    \n",
        "*Note: The results for this part may differ because they depend on your parameters. To pass you need to push your cost below 15000. The optimal results are:*<br>\n",
        "<li>$\\Theta_0$ = 352.40171716\n",
        "<li>$\\Theta_1$ = -17.49921637\n",
        "<li>$J(\\Theta_0, \\Theta_1)$ = 14725.144411377056\n",
        "    \n",
        "**WARNING: It is difficult to get the optimal parameters with this algorithm. If your cost $J(\\Theta_0, \\Theta_1)$ is below 14800 it means that you are ok. If your cost is below 14730 you are perfect :)**\n",
        "    \n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lcHBA06CyxKb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 648
        },
        "outputId": "56ec9ab8-7088-43b8-ef9a-9e1a2609bd7a"
      },
      "source": [
        "learning_rate = 0.00095 # ENTER YOUR CODE HERE (Tune this parameter)\n",
        "epochs = 20000 # ENTER YOUR CODE HERE (Tune this parameter)\n",
        " \n",
        "display_every = int(epochs / 20)\n",
        " \n",
        "th0 = 0 #The initial th0 value\n",
        "th1 = 0 #The initial th1 value\n",
        " \n",
        "cost_list = [] # we will use this list to plot the cost function chart\n",
        "iter_list = [] # we will use this list to plot the cost function chart\n",
        " \n",
        "for i in range(epochs):\n",
        "    #Learning process. With your functions the entire learning code is only 2 lines\n",
        "    del0, del1 = compute_derivatives(x, y, th0, th1)\n",
        "    th0, th1 = update_theta(th0, th1, del0, del1, learning_rate)\n",
        "    \n",
        "    #This code is used only for displaying results. You do not need to understand it\n",
        "    if ((i%display_every) == 0) | (i == epochs-1):\n",
        "        curr_cost = cost(y, compute_h(x, th0, th1))\n",
        "        cost_list.append(curr_cost)\n",
        "        iter_list.append(i)\n",
        "        print('Iteration {}, Theta 0: {:.2f}, Theta 1: {:.2f}, Cost: {:.2f}'\n",
        "              .format(i, th0, th1, curr_cost))\n",
        " \n",
        "        \n",
        "#This code is used only for displaying results. You do not need to understand it\n",
        "f = plt.figure()\n",
        "plt.plot(iter_list, cost_list)\n",
        "plt.title(\"Cost function\")\n",
        "plt.xlabel('Iteration')\n",
        "plt.ylabel('Cost');"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Iteration 0, Theta 0: -0.32, Theta 1: -21.58, Cost: 151196.90\n",
            "Iteration 1000, Theta 0: 75.63, Theta 1: -12.28, Cost: 24481.00\n",
            "Iteration 2000, Theta 0: 135.11, Theta 1: -13.40, Cost: 20738.72\n",
            "Iteration 3000, Theta 0: 181.80, Theta 1: -14.28, Cost: 18431.95\n",
            "Iteration 4000, Theta 0: 218.46, Theta 1: -14.97, Cost: 17010.04\n",
            "Iteration 5000, Theta 0: 247.24, Theta 1: -15.51, Cost: 16133.57\n",
            "Iteration 6000, Theta 0: 269.84, Theta 1: -15.94, Cost: 15593.31\n",
            "Iteration 7000, Theta 0: 287.58, Theta 1: -16.28, Cost: 15260.29\n",
            "Iteration 8000, Theta 0: 301.51, Theta 1: -16.54, Cost: 15055.01\n",
            "Iteration 9000, Theta 0: 312.45, Theta 1: -16.75, Cost: 14928.48\n",
            "Iteration 10000, Theta 0: 321.03, Theta 1: -16.91, Cost: 14850.48\n",
            "Iteration 11000, Theta 0: 327.77, Theta 1: -17.03, Cost: 14802.40\n",
            "Iteration 12000, Theta 0: 333.06, Theta 1: -17.13, Cost: 14772.77\n",
            "Iteration 13000, Theta 0: 337.22, Theta 1: -17.21, Cost: 14754.50\n",
            "Iteration 14000, Theta 0: 340.48, Theta 1: -17.27, Cost: 14743.24\n",
            "Iteration 15000, Theta 0: 343.04, Theta 1: -17.32, Cost: 14736.30\n",
            "Iteration 16000, Theta 0: 345.05, Theta 1: -17.36, Cost: 14732.02\n",
            "Iteration 17000, Theta 0: 346.63, Theta 1: -17.39, Cost: 14729.38\n",
            "Iteration 18000, Theta 0: 347.87, Theta 1: -17.41, Cost: 14727.76\n",
            "Iteration 19000, Theta 0: 348.85, Theta 1: -17.43, Cost: 14726.75\n",
            "Iteration 19999, Theta 0: 349.61, Theta 1: -17.45, Cost: 14726.14\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oU4fryGGyxKj"
      },
      "source": [
        "You may use the code below to present your results on the chart"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PT8fR1GyyxKk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 362
        },
        "outputId": "65bdf6f9-2d09-4b4b-f94a-c566b27a11da"
      },
      "source": [
        "print('\\nYour results:')\n",
        "print ('h(x) = {:.2f} + x*{:.2f}'.format(th0, th1))\n",
        "print('Cost = {:.2f}'.format(cost(y, compute_h(x, th0, th1))))\n",
        " \n",
        "hlp.plot_fitting_lin(x, y, th0, th1);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Your results:\n",
            "h(x) = 349.61 + x*-17.45\n",
            "Cost = 14726.14\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4hkBkBM1yxKn"
      },
      "source": [
        "### Question 1\n",
        "Compare the 'manual' results with the 'gradient descent' results using the code below. Which results are better:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "29C7FW0iyxKn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 168
        },
        "outputId": "86314a2f-8279-4ef9-d2b8-9642492f7baf"
      },
      "source": [
        "print('The gradient descent results:')\n",
        "print ('h(x) = {:.2f} + x*{:.2f}'.format(th0, th1))\n",
        "print('Cost = {:.2f}'.format(cost(y, compute_h(x, th0, th1))))\n",
        "\n",
        "print('\\nThe manual results:')\n",
        "print ('h(x) = {:.2f} + x*{:.2f}'.format(my_th0, my_th1))\n",
        "print('Cost = {:.2f}'.format(cost(y, compute_h(x, my_th0, my_th1))))\n",
        "print('\\n')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The gradient descent results:\n",
            "h(x) = 349.61 + x*-17.45\n",
            "Cost = 14726.14\n",
            "\n",
            "The manual results:\n",
            "h(x) = 400.00 + x*-20.00\n",
            "Cost = 17702.43\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "18-GlVoFyxKq"
      },
      "source": [
        "**ENTER YOUR ANSWER HERE:**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PCo-IA-UyxKq"
      },
      "source": [
        "Metoda gradientu sprawdza więcej przypadków i jesli jest dobrze spramateryzowana to zwróci lepszy wynik niż metoda manualna."
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}