From a1874864f36755703196799088e5317f4ac6eac6 Mon Sep 17 00:00:00 2001
From: ROHIT9991 <142079391+ROHIT9991@users.noreply.github.com>
Date: Sun, 13 Aug 2023 20:04:46 +0530
Subject: [PATCH] Add files via upload

---
 Day-1/Submission/rohit_ninawe.ipynb | 1179 +++++++++++++++++++++++++++
 1 file changed, 1179 insertions(+)
 create mode 100644 Day-1/Submission/rohit_ninawe.ipynb

diff --git a/Day-1/Submission/rohit_ninawe.ipynb b/Day-1/Submission/rohit_ninawe.ipynb
new file mode 100644
index 0000000..67d84db
--- /dev/null
+++ b/Day-1/Submission/rohit_ninawe.ipynb
@@ -0,0 +1,1179 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "_fJLfdEpHP9d",
+        "outputId": "ecad8c63-81c6-4b34-debb-d593812a0dff",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Cloning into 'Machine-Learning-Simplified'...\n",
+            "remote: Enumerating objects: 31, done.\u001b[K\n",
+            "remote: Counting objects: 100% (16/16), done.\u001b[K\n",
+            "remote: Compressing objects: 100% (12/12), done.\u001b[K\n",
+            "remote: Total 31 (delta 1), reused 16 (delta 1), pack-reused 15\u001b[K\n",
+            "Receiving objects: 100% (31/31), 377.63 KiB | 18.88 MiB/s, done.\n",
+            "Resolving deltas: 100% (4/4), done.\n"
+          ]
+        }
+      ],
+      "source": [
+        "!git clone https://github.com/IEEE-CISCodeCraft/Machine-Learning-Simplified.git"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "6DNQ2HHJHjYZ"
+      },
+      "outputs": [],
+      "source": [
+        "!cp \"/content/Machine-Learning-Simplified/Day-1/LRTestCases.py\" \"/content/\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "dG5rIH8KHUOT"
+      },
+      "outputs": [],
+      "source": [
+        "from LRTestCases import *"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "1tOdDoSwZeIE"
+      },
+      "outputs": [],
+      "source": [
+        "def error(yhat, y):\n",
+        "    error = yhat - y      #Subtract y from yhat\n",
+        "    return error"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "D7yM32C_Xz-g",
+        "outputId": "291c237a-89e1-4c5f-964f-c2664cc75c2e",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[92mTest passed!\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "#TEST YOUR IMPLEMENTATION\n",
+        "test_error_function(error)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "Nnoygph2er5y"
+      },
+      "outputs": [],
+      "source": [
+        "def error_square(error):\n",
+        "    square = error **2        #Square the error claculated above\n",
+        "    return square"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "id": "MHGCiEXJX_AR",
+        "outputId": "95e7f0b9-48d9-4d5b-b092-b41066e17d42",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[92mTest passed!\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "#TEST YOUR IMPLEMENTATION\n",
+        "test_error_square_function(error_square)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "id": "wgwOEQK9fMqA"
+      },
+      "outputs": [],
+      "source": [
+        "def total_squared_error(error, num):\n",
+        "    total_squared_error = 0\n",
+        "    for i in range(num):\n",
+        "      total_squared_error = total_squared_error + error     #Add the \"error\" to the \"total_sqared_error\"\n",
+        "    return total_squared_error"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "id": "ilzjasT4YJAh",
+        "outputId": "b0211c51-37bf-4bfc-fe17-b2865938f2d6",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[92mTest passed!\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "#TEST YOUR IMPLEMENTATION\n",
+        "test_total_squared_error_function(total_squared_error)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "oS7bM8mBjJ-u"
+      },
+      "source": [
+        "$\\text{Mean Squared Error}=\\frac{1}{2*m}\\sum\\limits_{i = 0}^{m-1}(y-ŷ)^2$"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "id": "Q6sFN7i2piR8"
+      },
+      "outputs": [],
+      "source": [
+        "def mse(total_squared_error, num):\n",
+        "    denominator = 2*num           #Multipy num with 2\n",
+        "    mse = total_squared_error/denominator   #Divide \"total_sqaured_error\" by \"denominator\"\n",
+        "    return num"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "id": "fZ816KtRYsoj",
+        "outputId": "5c31d8ee-1412-4b64-a611-0f5dd101173e",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[92mTest passed!\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "#TEST YOUR IMPLEMENTATION\n",
+        "test_mse_function(mse)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3Uqj2E0BlU_U"
+      },
+      "source": [
+        "**Finding the predicted value**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "id": "oiwBU-fSjp5C"
+      },
+      "outputs": [],
+      "source": [
+        "def predicted_value(w, x, b):\n",
+        "    yhat = w*x+b    #Multiply 'w' with 'x' and add 'b'\n",
+        "    return yhat"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "id": "MXs2kadnreTF",
+        "outputId": "3f3458c1-4bcf-424b-fb6e-7fa57fbc6aab",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[92mTest passed!\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "#TEST YOUR IMPLEMENTATION\n",
+        "test_predicted_value(predicted_value)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "qW9qAdiUwOrk"
+      },
+      "source": [
+        "## Cost Function\n",
+        "The equation for cost with one variable is:\n",
+        "$$J(w,b) = \\frac{1}{2m} \\sum\\limits_{i = 0}^{m-1} (ŷ - y^{(i)})^2$$"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "id": "RCCqRXf-wNoI"
+      },
+      "outputs": [],
+      "source": [
+        "def compute_cost(x, y, w, b):\n",
+        "    # number of training examples\n",
+        "    m = x.shape[0]\n",
+        "    total_squared_error = 0\n",
+        "    for i in range(m):\n",
+        "        yhat = w * x[i] + b\n",
+        "        error = yhat-y[i]        #Subtract \"y[i]\" from \"yhat\"\n",
+        "        squared_error = error**2   #Square the error\n",
+        "        total_squared_error = error +  total_squared_error #Add the \"error\" to the \"total_sqared_error\"\n",
+        "    denominator = m*2    #Multiply m by 2\n",
+        "    total_cost =total_squared_error / denominator      #Divide total_cost by denominator\n",
+        "    return total_cost"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [],
+      "metadata": {
+        "id": "KG_NFDCSzfS2"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OGswOCVFzR7W"
+      },
+      "source": [
+        "# Gradient Descent\n",
+        "## 1. Compute Gradient\n",
+        "The gradient is defined as:\n",
+        "$$\n",
+        "\\begin{align}\n",
+        "\\frac{\\partial J(w,b)}{\\partial w}  &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (ŷ - y^{(i)})x^{(i)} \\\\\n",
+        "  \\frac{\\partial J(w,b)}{\\partial b}  &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (ŷ - y^{(i)}) \\\\\n",
+        "\\end{align}\n",
+        "$$"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "id": "VMBk0PnA0wK3"
+      },
+      "outputs": [],
+      "source": [
+        "def compute_gradient(x, y, w, b):\n",
+        "    # Number of training examples\n",
+        "    m = x.shape[0]\n",
+        "    dj_dw = 0\n",
+        "    dj_db = 0\n",
+        "\n",
+        "    for i in range(m):\n",
+        "        yhat = w * x[i] + b\n",
+        "        dj_dw_i = (yhat - y[i]) * x[i]\n",
+        "        dj_db_i = yhat - y[i]\n",
+        "        dj_db += dj_db_i\n",
+        "        dj_dw += dj_dw_i\n",
+        "    dj_dw = dj_dw / m\n",
+        "    dj_db = dj_db / m\n",
+        "\n",
+        "    return dj_dw, dj_db"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "id": "3U-qZNSFE1QK",
+        "outputId": "d3f8991d-f381-4fe3-a7cd-628b30dacedb",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[92mTest passed!\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "test_compute_gradient(compute_gradient)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AhWGXBq82p6P"
+      },
+      "source": [
+        "## 2. Update the parameters <code>num_iterations</code> times\n",
+        "$$\\begin{align*} \\text{repeat}&\\text{ until convergence:} \\; \\lbrace \\newline\n",
+        "\\;  w &= w -  \\alpha \\frac{\\partial J(w,b)}{\\partial w}  \\; \\newline\n",
+        " b &= b -  \\alpha \\frac{\\partial J(w,b)}{\\partial b}  \\newline \\rbrace\n",
+        "\\end{align*}$$\n",
+        "where, parameters $w$, $b$ are updated simultaneously."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {
+        "id": "OlNwBvu52cUv"
+      },
+      "outputs": [],
+      "source": [
+        "def gradient_descent(x, y, learning_rate, num_iterations):\n",
+        "    # Initialize weights and bias\n",
+        "    w = 0\n",
+        "    b = 0\n",
+        "    # Number of training examples\n",
+        "    m = x.shape[0]\n",
+        "    for _ in range(num_iterations):\n",
+        "        # Compute gradients using the compute_gradient function\n",
+        "        dj_dw, dj_db = compute_gradient(x, y, w, b)\n",
+        "\n",
+        "        # Update weights and bias\n",
+        "        w = w - learning_rate * dj_dw\n",
+        "        b = b - learning_rate * dj_db\n",
+        "        # Compute the cost for monitoring\n",
+        "        cost = compute_cost(x, y, w, b)\n",
+        "        print(f'Iteration {_+1}/{num_iterations}, Cost: {cost:.6f}')\n",
+        "    return w, b"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "id": "dpmvXbs4lmHO",
+        "outputId": "c98eb63e-378b-48c8-ed80-fc274014c907",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration 1/10, Cost: -1.782000\n",
+            "Iteration 2/10, Cost: -1.589760\n",
+            "Iteration 3/10, Cost: -1.420232\n",
+            "Iteration 4/10, Cost: -1.270730\n",
+            "Iteration 5/10, Cost: -1.138884\n",
+            "Iteration 6/10, Cost: -1.022606\n",
+            "Iteration 7/10, Cost: -0.920053\n",
+            "Iteration 8/10, Cost: -0.829601\n",
+            "Iteration 9/10, Cost: -0.749820\n",
+            "Iteration 10/10, Cost: -0.679447\n",
+            "Final parameters: w = 0.7955, b = 0.2545\n",
+            "Final cost: -0.679447\n",
+            "\u001b[92mTest passed!\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "test_gradient_descent(gradient_descent, compute_cost, compute_gradient)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "id": "NknHm9DGGonf"
+      },
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_Vb4kNxkG_Ml"
+      },
+      "source": [
+        "# **Project:** Melanoma Tumor Size Prediction"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "id": "ibTpczTtGokE"
+      },
+      "outputs": [],
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "from sklearn.linear_model import LinearRegression\n",
+        "from sklearn.metrics import mean_squared_error, mean_absolute_error\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "import seaborn as sns\n",
+        "import matplotlib.pyplot as plt"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 45,
+      "metadata": {
+        "id": "eqAMMJ9lGohp"
+      },
+      "outputs": [],
+      "source": [
+        "#Read the dataset\n",
+        "data = pd.read_csv('/content/Machine-Learning-Simplified/Day-1/melanoma_dataset.csv')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 46,
+      "metadata": {
+        "id": "Q14KncK6GofO",
+        "outputId": "a7e8a080-c297-4e8e-9428-d50b95fa83d5",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 423
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "     mass_npea  tumor_size\n",
+              "0    18.159306    7.490802\n",
+              "1    39.693228   19.014286\n",
+              "2    32.659956   14.639879\n",
+              "3    27.556925   11.973170\n",
+              "4     9.800536    3.120373\n",
+              "..         ...         ...\n",
+              "995   5.343260    1.831641\n",
+              "996  39.080774   18.346272\n",
+              "997   8.435708    2.736373\n",
+              "998  40.580192   19.004747\n",
+              "999  20.147810    8.920115\n",
+              "\n",
+              "[1000 rows x 2 columns]"
+            ],
+            "text/html": [
+              "\n",
+              "\n",
+              "  <div id=\"df-5c41d23b-e102-4624-ab9a-268c5eafd040\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <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>mass_npea</th>\n",
+              "      <th>tumor_size</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>18.159306</td>\n",
+              "      <td>7.490802</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>39.693228</td>\n",
+              "      <td>19.014286</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>32.659956</td>\n",
+              "      <td>14.639879</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>27.556925</td>\n",
+              "      <td>11.973170</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>9.800536</td>\n",
+              "      <td>3.120373</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>...</th>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>995</th>\n",
+              "      <td>5.343260</td>\n",
+              "      <td>1.831641</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>996</th>\n",
+              "      <td>39.080774</td>\n",
+              "      <td>18.346272</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>997</th>\n",
+              "      <td>8.435708</td>\n",
+              "      <td>2.736373</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>998</th>\n",
+              "      <td>40.580192</td>\n",
+              "      <td>19.004747</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>999</th>\n",
+              "      <td>20.147810</td>\n",
+              "      <td>8.920115</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "<p>1000 rows × 2 columns</p>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-5c41d23b-e102-4624-ab9a-268c5eafd040')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "\n",
+              "\n",
+              "\n",
+              "    <div id=\"df-f8d90ba7-2dd6-4112-9d13-0728fcbe55f6\">\n",
+              "      <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-f8d90ba7-2dd6-4112-9d13-0728fcbe55f6')\"\n",
+              "              title=\"Suggest charts.\"\n",
+              "              style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "      </button>\n",
+              "    </div>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: #E8F0FE;\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: #1967D2;\n",
+              "    height: 32px;\n",
+              "    padding: 0 0 0 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: #E2EBFA;\n",
+              "    box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: #174EA6;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "    background-color: #3B4455;\n",
+              "    fill: #D2E3FC;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart:hover {\n",
+              "    background-color: #434B5C;\n",
+              "    box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "    filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "    fill: #FFFFFF;\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "    <script>\n",
+              "      async function quickchart(key) {\n",
+              "        const containerElement = document.querySelector('#' + key);\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      }\n",
+              "    </script>\n",
+              "\n",
+              "      <script>\n",
+              "\n",
+              "function displayQuickchartButton(domScope) {\n",
+              "  let quickchartButtonEl =\n",
+              "    domScope.querySelector('#df-f8d90ba7-2dd6-4112-9d13-0728fcbe55f6 button.colab-df-quickchart');\n",
+              "  quickchartButtonEl.style.display =\n",
+              "    google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "}\n",
+              "\n",
+              "        displayQuickchartButton(document);\n",
+              "      </script>\n",
+              "      <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-5c41d23b-e102-4624-ab9a-268c5eafd040 button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-5c41d23b-e102-4624-ab9a-268c5eafd040');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 46
+        }
+      ],
+      "source": [
+        "#Display the dataset\n",
+        "data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 48,
+      "metadata": {
+        "id": "P9ipnJ_iKF42",
+        "outputId": "08cb6cd9-a305-400c-9adb-9eeccb821089",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 466
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Axes: xlabel='mass_npea', ylabel='tumor_size'>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 48
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "#Gain insights of dataset\n",
+        "sns.scatterplot(x='mass_npea', y='tumor_size', data=data)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 49,
+      "metadata": {
+        "id": "ItVOltUuLE-T",
+        "outputId": "e10683b9-bb38-4384-8af3-b95e8e3b7662",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 300
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "         mass_npea   tumor_size\n",
+              "count  1000.000000  1000.000000\n",
+              "mean     22.709158     9.805131\n",
+              "std      11.682122     5.842747\n",
+              "min       1.575483     0.092640\n",
+              "25%      12.290811     4.719465\n",
+              "50%      22.968280     9.936148\n",
+              "75%      32.664439    14.886392\n",
+              "max      44.255681    19.994353"
+            ],
+            "text/html": [
+              "\n",
+              "\n",
+              "  <div id=\"df-67651541-5878-47ba-84b4-74cb57a5c8a2\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <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>mass_npea</th>\n",
+              "      <th>tumor_size</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>count</th>\n",
+              "      <td>1000.000000</td>\n",
+              "      <td>1000.000000</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>mean</th>\n",
+              "      <td>22.709158</td>\n",
+              "      <td>9.805131</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>std</th>\n",
+              "      <td>11.682122</td>\n",
+              "      <td>5.842747</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>min</th>\n",
+              "      <td>1.575483</td>\n",
+              "      <td>0.092640</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>25%</th>\n",
+              "      <td>12.290811</td>\n",
+              "      <td>4.719465</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>50%</th>\n",
+              "      <td>22.968280</td>\n",
+              "      <td>9.936148</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>75%</th>\n",
+              "      <td>32.664439</td>\n",
+              "      <td>14.886392</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>max</th>\n",
+              "      <td>44.255681</td>\n",
+              "      <td>19.994353</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-67651541-5878-47ba-84b4-74cb57a5c8a2')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "\n",
+              "\n",
+              "\n",
+              "    <div id=\"df-f81a1559-0c7b-4f39-94ee-4341c613d5c4\">\n",
+              "      <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-f81a1559-0c7b-4f39-94ee-4341c613d5c4')\"\n",
+              "              title=\"Suggest charts.\"\n",
+              "              style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "      </button>\n",
+              "    </div>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: #E8F0FE;\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: #1967D2;\n",
+              "    height: 32px;\n",
+              "    padding: 0 0 0 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: #E2EBFA;\n",
+              "    box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: #174EA6;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "    background-color: #3B4455;\n",
+              "    fill: #D2E3FC;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart:hover {\n",
+              "    background-color: #434B5C;\n",
+              "    box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "    filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "    fill: #FFFFFF;\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "    <script>\n",
+              "      async function quickchart(key) {\n",
+              "        const containerElement = document.querySelector('#' + key);\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      }\n",
+              "    </script>\n",
+              "\n",
+              "      <script>\n",
+              "\n",
+              "function displayQuickchartButton(domScope) {\n",
+              "  let quickchartButtonEl =\n",
+              "    domScope.querySelector('#df-f81a1559-0c7b-4f39-94ee-4341c613d5c4 button.colab-df-quickchart');\n",
+              "  quickchartButtonEl.style.display =\n",
+              "    google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "}\n",
+              "\n",
+              "        displayQuickchartButton(document);\n",
+              "      </script>\n",
+              "      <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-67651541-5878-47ba-84b4-74cb57a5c8a2 button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-67651541-5878-47ba-84b4-74cb57a5c8a2');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 49
+        }
+      ],
+      "source": [
+        "#Plot a graph to check linearity\n",
+        "data.describe()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 50,
+      "metadata": {
+        "id": "mQ5YOGJFLE63"
+      },
+      "outputs": [],
+      "source": [
+        "#Extract X and Y from data\n",
+        "X = data[['mass_npea']]\n",
+        "Y = data[['tumor_size']]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 53,
+      "metadata": {
+        "id": "M1Jpn6TCLE4s",
+        "outputId": "b8a0603f-697c-4a30-8436-0dc4a4f6d542",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 74
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "LinearRegression()"
+            ],
+            "text/html": [
+              "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LinearRegression()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearRegression</label><div class=\"sk-toggleable__content\"><pre>LinearRegression()</pre></div></div></div></div></div>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 53
+        }
+      ],
+      "source": [
+        "#Train a Linear Regression Model\n",
+        "model = LinearRegression()\n",
+        "model.fit(X,Y)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 56,
+      "metadata": {
+        "id": "E4sxQ9G4LE2v",
+        "outputId": "9e5ab090-c158-4166-927c-90c0306c175c",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "201.0666055150273"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 56
+        }
+      ],
+      "source": [
+        "#Evaluate the Model\n",
+        "y_pred =model.predict(X)\n",
+        "mse = mean_squared_error(Y , X)\n",
+        "mse\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 60,
+      "metadata": {
+        "id": "F5p0Zr1_LSIP",
+        "outputId": "c3bba01a-a85b-4e67-9e1d-4127714ff5a8",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        }
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "# Plot the data and regression line\n",
+        "plt.scatter(X ,Y ,label = 'Data')\n",
+        "plt.plot(X,y_pred ,color=  'red' )\n",
+        "plt.ylabel('Tumor Size')\n",
+        "plt.xlabel('Mass Npea')\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.10.11"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file