tumor prediction

SkinTumor_prediction_LiR_model.ipynb

+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "d4f44a2e",
+      "metadata": {
+        "id": "d4f44a2e"
+      },
+      "source": [
+        "## Title - **Melanoma Tumor Size Prediction**\n",
+        "## Used Algorithm - **Liner Regression**\n",
+        "\n",
+        "\n",
+        "## Accuracy\n",
+        "* Accuracy on Isolation Forest :  90%\n",
+        "* Accuracy on Random Forest :  93%"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "e555e9d8",
+      "metadata": {
+        "id": "e555e9d8"
+      },
+      "source": [
+        "### Importing the dependancies"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Lr8KJqCxamQm",
+        "outputId": "3610dc7a-6a5b-489a-af1e-2f9af9f9afbc"
+      },
+      "id": "Lr8KJqCxamQm",
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import files\n",
+        "files.upload()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 90
+        },
+        "id": "x73tDO5fanhd",
+        "outputId": "20d2a8fa-66ff-4df5-990d-de9d4c1418cf"
+      },
+      "id": "x73tDO5fanhd",
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-0551e200-59b6-43e1-9f54-d379d1013939\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-0551e200-59b6-43e1-9f54-d379d1013939\">\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 kaggle.json to kaggle (1).json\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "{'kaggle.json': b'{\"username\":\"mishaneperera\",\"key\":\"fb1e9a2fcad19f92a1d3ebd6e8c8165f\"}'}"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 13
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!mkdir -p ~/.kaggle\n",
+        "!cp kaggle.json ~/.kaggle/"
+      ],
+      "metadata": {
+        "id": "g-QxxXqKap_8"
+      },
+      "id": "g-QxxXqKap_8",
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!chmod 600 ~/.kaggle/kaggle.json"
+      ],
+      "metadata": {
+        "id": "HSge_gifar5N"
+      },
+      "id": "HSge_gifar5N",
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "\n",
+        "!unzip '/content/drive/MyDrive/Skin tumor/machine-hack-melanoma-tumor-size-prediction.zip'"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "u1IPVt6ZavPc",
+        "outputId": "64d364dd-ce34-47dc-c74c-778cadcff92a"
+      },
+      "id": "u1IPVt6ZavPc",
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Archive:  /content/drive/MyDrive/Skin tumor/machine-hack-melanoma-tumor-size-prediction.zip\n",
+            "replace sample_submission.csv? [y]es, [n]o, [A]ll, [N]one, [r]ename: y\n",
+            "  inflating: sample_submission.csv   \n",
+            "replace test.csv? [y]es, [n]o, [A]ll, [N]one, [r]ename: y\n",
+            "  inflating: test.csv                \n",
+            "replace train.csv? [y]es, [n]o, [A]ll, [N]one, [r]ename: y\n",
+            "  inflating: train.csv               \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "1123a658",
+      "metadata": {
+        "id": "1123a658"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "4e1ec49f",
+      "metadata": {
+        "id": "4e1ec49f"
+      },
+      "source": [
+        "### Data collecting process"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "111d33c0",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "111d33c0",
+        "outputId": "a8a28ca2-0714-4c35-b92d-26ff08273e7e"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "   mass_npea  size_npear  malign_ratio  damage_size  exposed_area  \\\n",
+              "0    6930.90     2919.02       0.42116      51.8298  9.888294e+05   \n",
+              "1   15635.70     4879.36       0.31206     223.5500  2.058426e+06   \n",
+              "2   10376.20     2613.88       0.25191     127.3370  1.434676e+06   \n",
+              "3   13093.80     4510.06       0.34444     155.4400  1.812195e+06   \n",
+              "4    7545.21     2882.36       0.38201      85.1237  1.043918e+06   \n",
+              "\n",
+              "   std_dev_malign  err_malign  malign_penalty  damage_ratio  tumor_size  \n",
+              "0         109.487     2758.76              72       39.3620      14.103  \n",
+              "1         248.881     5952.53             240       22.0253       2.648  \n",
+              "2         160.093     4635.26              73       29.9963       1.688  \n",
+              "3         173.015     5273.87              32       28.1354       3.796  \n",
+              "4         124.414     3263.35              57       35.0200      18.023  "
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-e80b92a4-4456-4112-bb21-72dcd092350c\">\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>size_npear</th>\n",
+              "      <th>malign_ratio</th>\n",
+              "      <th>damage_size</th>\n",
+              "      <th>exposed_area</th>\n",
+              "      <th>std_dev_malign</th>\n",
+              "      <th>err_malign</th>\n",
+              "      <th>malign_penalty</th>\n",
+              "      <th>damage_ratio</th>\n",
+              "      <th>tumor_size</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>6930.90</td>\n",
+              "      <td>2919.02</td>\n",
+              "      <td>0.42116</td>\n",
+              "      <td>51.8298</td>\n",
+              "      <td>9.888294e+05</td>\n",
+              "      <td>109.487</td>\n",
+              "      <td>2758.76</td>\n",
+              "      <td>72</td>\n",
+              "      <td>39.3620</td>\n",
+              "      <td>14.103</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>15635.70</td>\n",
+              "      <td>4879.36</td>\n",
+              "      <td>0.31206</td>\n",
+              "      <td>223.5500</td>\n",
+              "      <td>2.058426e+06</td>\n",
+              "      <td>248.881</td>\n",
+              "      <td>5952.53</td>\n",
+              "      <td>240</td>\n",
+              "      <td>22.0253</td>\n",
+              "      <td>2.648</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>10376.20</td>\n",
+              "      <td>2613.88</td>\n",
+              "      <td>0.25191</td>\n",
+              "      <td>127.3370</td>\n",
+              "      <td>1.434676e+06</td>\n",
+              "      <td>160.093</td>\n",
+              "      <td>4635.26</td>\n",
+              "      <td>73</td>\n",
+              "      <td>29.9963</td>\n",
+              "      <td>1.688</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>13093.80</td>\n",
+              "      <td>4510.06</td>\n",
+              "      <td>0.34444</td>\n",
+              "      <td>155.4400</td>\n",
+              "      <td>1.812195e+06</td>\n",
+              "      <td>173.015</td>\n",
+              "      <td>5273.87</td>\n",
+              "      <td>32</td>\n",
+              "      <td>28.1354</td>\n",
+              "      <td>3.796</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>7545.21</td>\n",
+              "      <td>2882.36</td>\n",
+              "      <td>0.38201</td>\n",
+              "      <td>85.1237</td>\n",
+              "      <td>1.043918e+06</td>\n",
+              "      <td>124.414</td>\n",
+              "      <td>3263.35</td>\n",
+              "      <td>57</td>\n",
+              "      <td>35.0200</td>\n",
+              "      <td>18.023</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e80b92a4-4456-4112-bb21-72dcd092350c')\"\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-e80b92a4-4456-4112-bb21-72dcd092350c 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-e80b92a4-4456-4112-bb21-72dcd092350c');\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": 50
+        }
+      ],
+      "source": [
+        "dataset = pd.read_csv('/content/train.csv')\n",
+        "dataset.head()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5da5cf75",
+      "metadata": {
+        "id": "5da5cf75"
+      },
+      "source": [
+        "### Explore the dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "740f14ff",
+      "metadata": {
+        "id": "740f14ff"
+      },
+      "outputs": [],
+      "source": [
+        "X = dataset.iloc[:,:-1].values  #independent variable array\n",
+        "y = dataset.iloc[:,1].values  #dependent variable vector"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "7c8d2381",
+      "metadata": {
+        "id": "7c8d2381"
+      },
+      "outputs": [],
+      "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=1/3,random_state=0)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e535ee6f",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 75
+        },
+        "id": "e535ee6f",
+        "outputId": "8b64e058-1606-4284-82dd-de77f9a70f70"
+      },
+      "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": 54
+        }
+      ],
+      "source": [
+        "from sklearn.linear_model import LinearRegression\n",
+        "regressor = LinearRegression()\n",
+        "regressor.fit(X_train,y_train) #actually produces the linear eqn for the data\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "accuracy=regressor.score(X_train,y_train)\n",
+        "print(accuracy)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5BGEhbFxpjxB",
+        "outputId": "47340ca9-a7ad-484a-9dc7-61cace4b5c4b"
+      },
+      "id": "5BGEhbFxpjxB",
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "1.0\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "d21cf5f8",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d21cf5f8",
+        "outputId": "19c58cf8-d471-46fa-8380-6827494e6042"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "array([3564.2 , 2081.8 , 3567.24, ..., 2344.44, 4253.25, 2881.7 ])"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 55
+        }
+      ],
+      "source": [
+        "y_pred = regressor.predict(X_test) \n",
+        "y_pred"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "f0e0e01a",
+      "metadata": {
+        "id": "f0e0e01a"
+      },
+      "source": [
+        "### Checking the distribution of target variable\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "cf5c2e23",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 853
+        },
+        "id": "cf5c2e23",
+        "outputId": "21f84128-1406-40a8-cec7-31ad93d9474b"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x900 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "import seaborn as sns\n",
+        "# Correlation matrix\n",
+        "corrmat = dataset.corr()\n",
+        "fig = plt.figure(figsize = (12, 9))\n",
+        "\n",
+        "sns.heatmap(corrmat, vmax = .8, square = True)\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "38ffa726",
+      "metadata": {
+        "id": "38ffa726"
+      },
+      "source": [
+        "### Splitting the features and target"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5df8ea16",
+      "metadata": {
+        "id": "5df8ea16"
+      },
+      "source": [
+        "### Saving the model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "02faf4e6",
+      "metadata": {
+        "id": "02faf4e6"
+      },
+      "outputs": [],
+      "source": [
+        "import pickle\n",
+        "filename = 'finalized_model_skinT_prediction_RF.sav'\n",
+        "pickle.dump(regressor, open(filename, 'wb'))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "896159c4",
+      "metadata": {
+        "id": "896159c4"
+      },
+      "outputs": [],
+      "source": [
+        "with open('finalized_model_skinT_prediction_RF.sav', 'rb') as f:\n",
+        "        model = pickle.load(f)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "03d78684",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "03d78684",
+        "outputId": "39dc528d-b12e-4716-e42b-40879e4f7698"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[4510.06]\n"
+          ]
+        }
+      ],
+      "source": [
+        "import warnings\n",
+        "warnings.filterwarnings(\"ignore\")\n",
+        "\n",
+        "#input_data1 = (70,1.02,0,0,1,44,1.2,145,5,14.8,8406,4.71,0) #0\n",
+        "input_data2 = (13093.8,4510.06,0.34444,155.44,1812195.1833,173.015,5273.87,32,28.1354) #1\n",
+        "\n",
+        "#change input data to numpy array\n",
+        "input_data_as_numpy_array = np.asarray(input_data2)\n",
+        "\n",
+        "#reshape the numpy array as we are predicting for only on instance\n",
+        "\n",
+        "input_data_reshaped = input_data_as_numpy_array.reshape(1,-1)\n",
+        "\n",
+        "prediction = model.predict(input_data_reshaped)\n",
+        "print(prediction)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "41a76901",
+      "metadata": {
+        "id": "41a76901"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.8.8"
+    },
+    "vscode": {
+      "interpreter": {
+        "hash": "d9a6414fa631c028c434667d182c0b79dc634ffcd06f52fc304061a2c0b9ef26"
+      }
+    },
+    "colab": {
+      "provenance": [],
+      "collapsed_sections": [
+        "e8dd7a8f",
+        "5821ec3c"
+      ]
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
\ No newline at end of file