{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "57299794-80df-4b68-a840-5117ef4883b5",
      "metadata": {
        "id": "57299794-80df-4b68-a840-5117ef4883b5"
      },
      "source": [
        "## Computational - 30 points\n",
        "\n",
        "These problems have a coding solution. Code your solutions in Python in the space provided.\n",
        "\n",
        "Use of LLM's such as Chat GPT are n|ot allowed for this computational task, please try not to use such applications as we do check for the same during grading."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "83c4475c-1707-478e-9b2c-488d18c15e40",
      "metadata": {
        "id": "83c4475c-1707-478e-9b2c-488d18c15e40"
      },
      "source": [
        "### Data Reading and Gradient Descent"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ba917e81-594d-46b6-bb69-c377caa52192",
      "metadata": {
        "id": "ba917e81-594d-46b6-bb69-c377caa52192"
      },
      "outputs": [],
      "source": [
        "#importing the following libraries\n",
        "#pandas as its common alias\n",
        "#numpy as its common alias\n",
        "#matplotlib.pyplot as plt\n",
        "#seaborn as sns\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 74
        },
        "id": "RdziREXEJZR5",
        "outputId": "8b74c918-ae9d-40b1-a561-e3989a3e1780"
      },
      "id": "RdziREXEJZR5",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-4d3538b2-3455-44d9-a259-042482002ed8\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-4d3538b2-3455-44d9-a259-042482002ed8\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving hw_10_data.csv to hw_10_data.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1ba0a510-bfc7-4d28-aef2-2222b1a13bed",
      "metadata": {
        "id": "1ba0a510-bfc7-4d28-aef2-2222b1a13bed"
      },
      "outputs": [],
      "source": [
        "#setting the path of data.csv in your drive\n",
        "#path = #Enter path for data.csv here\n",
        "data = pd.read_csv(\"hw_10_data.csv\") #Read csv from the path\n",
        "#note - it will be different for you"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f58fe539-0391-4a19-afc9-ceb39adacade",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 753
        },
        "id": "f58fe539-0391-4a19-afc9-ceb39adacade",
        "outputId": "488d108a-4d22-4e14-ab61-8ae2c2ae377b"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x900 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "#DO NOT CHANGE THIS CODE\n",
        "plt.rcParams['figure.figsize'] = (12.0, 9.0)\n",
        "X = data.iloc[:, 0]\n",
        "Y = data.iloc[:, 1]\n",
        "plt.scatter(X, Y)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "33fa358b-129e-4ea1-adc4-552304d43698",
      "metadata": {
        "id": "33fa358b-129e-4ea1-adc4-552304d43698"
      },
      "source": [
        "Now, you have a visualization of your data. Your next step should be to build a model for linear regression. Recall that it is given by:\n",
        "\n",
        "$$y = mx + c$$\n",
        "\n",
        "We will initialize m and c with 0."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "efef79d9-ed9f-4d58-98b4-beaf8c6ba29c",
      "metadata": {
        "id": "efef79d9-ed9f-4d58-98b4-beaf8c6ba29c"
      },
      "outputs": [],
      "source": [
        "# Building the model\n",
        "m = 0 #Initialize the value for m\n",
        "c = 0 #Initialize the value for c\n",
        "L = 0.0001  # The learning Rate\n",
        "epochs = 1000  # The number of iterations to perform gradient descent\n",
        "n = float(len(X)) # Number of elements in X"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0ec19379-d45c-423b-8592-f711c157f4f7",
      "metadata": {
        "id": "0ec19379-d45c-423b-8592-f711c157f4f7"
      },
      "source": [
        "**[1] [10 points] Complete the code below to perform gradient descent.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "67277e6e-3a01-4e2e-94a4-787d49f14bd6",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "67277e6e-3a01-4e2e-94a4-787d49f14bd6",
        "outputId": "350a78f6-45b6-4f26-cddd-2e7848d1e54c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.4796491688889395 0.10148121494753734\n"
          ]
        }
      ],
      "source": [
        "# Performing Gradient Descent\n",
        "for i in range(epochs):\n",
        "    y_hat = m * X + c  # Enter the current predicted value of Y based on the equation for linear regression\n",
        "    D_m = (-2/n) * sum(X * (Y - y_hat))  # Complete the formula to find Derivative wrt m\n",
        "    D_c = (-2/n) * sum(Y - y_hat)  # Complete the formula to find Derivative wrt c\n",
        "    m = m - L * D_m  # Update m\n",
        "    c = c - L * D_c  # Update c\n",
        "\n",
        "print(m, c)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "37299ebb-94e7-45c9-8b26-d7384d826f09",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 753
        },
        "id": "37299ebb-94e7-45c9-8b26-d7384d826f09",
        "outputId": "99055573-bd03-49a9-f919-83c125fb23ef"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x900 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "#DO NOT change this code\n",
        "# Making predictions\n",
        "Y_pred = m*X + c\n",
        "\n",
        "plt.scatter(X, Y)\n",
        "plt.plot([min(X), max(X)], [min(Y_pred), max(Y_pred)], color='red')  # regression line\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "79451580-45f0-4f43-8587-941a3c1644b8",
      "metadata": {
        "id": "79451580-45f0-4f43-8587-941a3c1644b8"
      },
      "source": [
        "**[2] [10 points] Complete the code below to perform gradient descent with different learning rates**"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def run_gradient_descent(X, Y, L, epochs):\n",
        "    m, c = 0, 0 # Intialize the value of m and c with 0\n",
        "    n = float(len(X)) # Intialize n with batch size\n",
        "    for i in range(epochs):\n",
        "        y_hat = m * X + c # Complete formula for y_hat\n",
        "        D_m = (-2/n) * sum(X * (Y - y_hat)) # Complete formula to find derivative wrt m\n",
        "        D_c = (-2/n) * sum(Y - y_hat) # Complete formula to find derivative wrt c\n",
        "        m = m - L * D_m # Enter updated value for m\n",
        "        c = c - L * D_c # Enter updated value for c\n",
        "    return m, c\n",
        "\n",
        "# Trying different learning rates\n",
        "learning_rates = [0.0001, 0.0005, 0.001, 0.01] # Enter learning rates you feel would work well for the data, output will vary do not worry about that, make sure to use atleast 4 different learning rates\n",
        "for lr in learning_rates:\n",
        "    m, c = run_gradient_descent(X, Y, lr, epochs)\n",
        "    print(f\"Learning Rate: {lr} => m: {m}, c: {c}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9TM000OUihWt",
        "outputId": "ede57ca9-5966-4af6-dfc5-92804bb20661"
      },
      "id": "9TM000OUihWt",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Learning Rate: 0.0001 => m: 1.4796491688889395, c: 0.10148121494753734\n",
            "Learning Rate: 0.0005 => m: -1.3036876994343447e+178, c: -2.5561869918933525e+176\n",
            "Learning Rate: 0.001 => m: nan, c: nan\n",
            "Learning Rate: 0.01 => m: nan, c: nan\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3a44fecb-618f-4101-8375-ed42fd26425a",
      "metadata": {
        "id": "3a44fecb-618f-4101-8375-ed42fd26425a"
      },
      "source": [
        "**[3] [10 points] Complete the code below to perform stochaistic gradient descent, the same way we did regular gradient descent**"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def run_stochastic_gradient_descent(X, Y, L, epochs):\n",
        "    m, c = 0,0 # Intialize the value of m and c with 0\n",
        "    n = float(len(X)) # Intialize n with batch size\n",
        "    for i in range(epochs):\n",
        "        for x, y in zip(X, Y):\n",
        "            y_hat = m * x + c\n",
        "            D_m = -2 * x * (y - y_hat) # Complete formula to find derivative wrt m\n",
        "            D_c = -2 * (y - y_hat) # Complete formula to find derivative wrt c\n",
        "            m = m - L * D_m # Enter updated value for m\n",
        "            c = c - L * D_c # Enter updated value for c\n",
        "    return m, c\n",
        "\n",
        "# Running stochastic gradient descent\n",
        "m_sgd, c_sgd = run_stochastic_gradient_descent(X, Y, 0.0001, epochs)\n",
        "print(f\"SGD => m: {m_sgd}, c: {c_sgd}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5ljh6isnkXuS",
        "outputId": "f38c4894-d930-4683-9553-48afe8d5d98c"
      },
      "id": "5ljh6isnkXuS",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SGD => m: 1.4460460213290953, c: 5.841802927567102\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "04ee39c1-ec1e-42d1-b813-14833bb9fb37",
      "metadata": {
        "id": "04ee39c1-ec1e-42d1-b813-14833bb9fb37"
      },
      "source": [
        "**[4] [5 points] Are the values for Stochaistic Gradient Descent same as Regular Gradient descent? Comment on your observations as well as your understanding as to why they may be the same or different**"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Answer:**\n",
        "\n",
        "From our calculations, the values obtained from Stochastic Gradient Descent (SGD) are different from those obtained through Regular Gradient Descent.\n",
        "\n",
        "I think this is due to the fact that Regular Gradient Descent updates parameters (m and c) after calculating the gradient over the entire dataset, which usually leads to a smoother and more stable convergence but can be slow for very large datasets. While on the other hand, SGD updates parameters after each training example, which introduces a lot more variability in the parameter updates.\n",
        "\n",
        "In more details:\n",
        "\n",
        "Regular Gradient Descent:\n",
        "\n",
        "- Regular Gradient Descent computes the gradient of the loss function using the entire dataset, which means that it takes into account all examples in the dataset to perform a single update of the parameters.\n",
        "- It is deterministic, like it produce the same results given the same initial conditions and dataset.\n",
        "\n",
        "In contrast with the SGD\n",
        "\n",
        "Stochastic Gradient Descent:\n",
        "- SGD updates the parameters using only one or a few training examples at a time. It computes the gradient of the loss function for each example or small batch of examples, and updates the parameters accordingly.\n",
        "- It introduces randomness due to the selection of examples, which means it can produce different results even with the same initial conditions."
      ],
      "metadata": {
        "id": "mG5Q9yQ_n2FO"
      },
      "id": "mG5Q9yQ_n2FO"
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "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.9.13"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}