EvaluatingRegressionModelUsing_RSquared_&_Adjusted_R_Squared.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyM78R7SyKnwwVnGR5W8ZSCS",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/riyajaiswal25/MLProjects/blob/main/EvaluatingRegressionModelUsing_RSquared_%26_Adjusted_R_Squared.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Evaluating Regression Model Using RSquared & Adjusted R Squared**"
      ],
      "metadata": {
        "id": "uQj5JQ1MbKCh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Imorting Libraries***"
      ],
      "metadata": {
        "id": "xiUYzs91bTPk"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "01Cs0-lqaVsz"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "from sklearn.linear_model import LinearRegression\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Load Dataset from Local Directory***"
      ],
      "metadata": {
        "id": "CcsuXF0MbmKU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "uploaded=files.upload()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "id": "kXrqMimNbq-D",
        "outputId": "f7b97c9b-43e2-4789-a2ce-0864a93f532f"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-2e0d7769-b9af-44e3-940a-d104f6cd1821\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-2e0d7769-b9af-44e3-940a-d104f6cd1821\">\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 area.csv to area.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Load Dataset***"
      ],
      "metadata": {
        "id": "Am0u1Nonc8_q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset = pd.read_csv('area.csv')"
      ],
      "metadata": {
        "id": "CWtJT03kc_f9"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Load Summarize***"
      ],
      "metadata": {
        "id": "-RjoCjdWdD3e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(dataset.shape)\n",
        "print(dataset.head(5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UVv4d0kOdGuj",
        "outputId": "ace46d1a-fe72-431b-bd4f-93055d819cc4"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(10, 2)\n",
            "   area  price\n",
            "0  1000   2245\n",
            "1  2000   4575\n",
            "2  3000   6874\n",
            "3  4000   8878\n",
            "4  5000  10589\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Visualize the Dataset***"
      ],
      "metadata": {
        "id": "tqUCkMh_dSgR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.xlabel('area')\n",
        "plt.ylabel('price')\n",
        "plt.scatter(dataset.area,dataset.price,color='red',marker='*')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        },
        "id": "cJqK3-judVfx",
        "outputId": "a959f3ba-4024-467a-c46b-9620c8378f0a"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.collections.PathCollection at 0x7f740416ab90>"
            ]
          },
          "metadata": {},
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Segregate Dataset into Input X & Output Y***"
      ],
      "metadata": {
        "id": "SwAb06BddpWx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X = dataset.drop('price',axis='columns')\n",
        "X"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 363
        },
        "id": "rXA_djy1dxwj",
        "outputId": "8a6be63c-92b3-4f36-858d-fde75b804e5b"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "    area\n",
              "0   1000\n",
              "1   2000\n",
              "2   3000\n",
              "3   4000\n",
              "4   5000\n",
              "5   6000\n",
              "6   7000\n",
              "7   8000\n",
              "8   9000\n",
              "9  10000"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-d62573ee-8fe6-49c4-a79c-2f8c14a1e36b\">\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>area</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>2000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>3000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>5000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>6000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>7000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>8000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>9000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>10000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-d62573ee-8fe6-49c4-a79c-2f8c14a1e36b')\"\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",
              "  <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-d62573ee-8fe6-49c4-a79c-2f8c14a1e36b 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-d62573ee-8fe6-49c4-a79c-2f8c14a1e36b');\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": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Y = dataset.price\n",
        "Y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qN5aMjXHd4Wj",
        "outputId": "eaa6de73-b5a3-468f-91c5-42f519712cbf"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0     2245\n",
              "1     4575\n",
              "2     6874\n",
              "3     8878\n",
              "4    10589\n",
              "5    12457\n",
              "6    14785\n",
              "7    16785\n",
              "8    18958\n",
              "9    20789\n",
              "Name: price, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " **Splitting Dataset for Testing our Model**"
      ],
      "metadata": {
        "id": "19REIIOBd-L8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "x_train,x_test,y_train,y_test = train_test_split(X,Y,test_size=0.20,random_state=0)"
      ],
      "metadata": {
        "id": "H9G0ZkzTeEgC"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Training Dataset using Linear Regression***"
      ],
      "metadata": {
        "id": "y9W0dZvAeb-q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = LinearRegression()\n",
        "model.fit(x_train,y_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "psg8WVxYeij9",
        "outputId": "5d47aaf0-abea-4246-849c-83e62ee4f2ba"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LinearRegression()"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Visualizing Linear Regression results***"
      ],
      "metadata": {
        "id": "Os2GcvDTerYm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.scatter(X,Y, color=\"red\",marker='*')\n",
        "plt.plot(X, model.predict(X))\n",
        "plt.title(\"Linear Regression\")\n",
        "plt.xlabel(\"Area\")\n",
        "plt.ylabel(\"Price\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "wjnFdNyhexSu",
        "outputId": "4e796133-35eb-41a5-a8ad-287f3c31068f"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***R-Squared Score***"
      ],
      "metadata": {
        "id": "wQZtOqkaf2Jg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rsquared = model.score(x_test, y_test)\n",
        "print(rsquared)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4hPS7nGf7Ps",
        "outputId": "526cb385-58c8-400c-e4e8-56963252fb35"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.9980555305079885\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Adjusted R Squared of the Model***"
      ],
      "metadata": {
        "id": "5Kc_-QkdgMdI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n=len(dataset) #Length of the Total dataset\n",
        "p=len(dataset.columns)-1 #length of Features\n",
        "adjr=1-(1-rsquared)*(n-1)/(n-p-1)\n",
        "print(adjr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zKmI6QhCgQ98",
        "outputId": "041e5c2a-c49a-4c96-c4ab-bffbaf361312"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.997812471821487\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Prediction***"
      ],
      "metadata": {
        "id": "2WPcEsQvgkUv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x=6500\n",
        "LandAreainSqFt=[[x]]\n",
        "PredictedmodelResult = model.predict(LandAreainSqFt)\n",
        "print(PredictedmodelResult)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J9Q2Qly_gmEM",
        "outputId": "5303ef47-31e1-4b13-a616-0c8b887abee6"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[13687.72504892]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/base.py:451: UserWarning: X does not have valid feature names, but LinearRegression was fitted with feature names\n",
            "  \"X does not have valid feature names, but\"\n"
          ]
        }
      ]
    }
  ]
}