ML_task_pclub.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "wtY8VKUe97OQ"
      },
      "outputs": [],
      "source": [
        "from google.colab import files\n",
        "import zipfile\n",
        "import pandas as pd\n",
        "import os\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.linear_model import LinearRegression\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "from sklearn.ensemble import RandomForestRegressor\n",
        "import numpy as np\n",
        "from sklearn.metrics import mean_squared_error\n",
        "import xgboost as xgb\n",
        "from sklearn.svm import SVR"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 128
        },
        "id": "nKhi4r8M_Q_Q",
        "outputId": "8b942762-b83d-4299-b921-ebf5b1d52c93"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-bd73e094-5e02-45f6-b5c9-31789481315f\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-bd73e094-5e02-45f6-b5c9-31789481315f\">\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 subject-info.xlsx to subject-info (1).xlsx\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-641b264e-11cf-484d-9a3f-dd87f81aee3c\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-641b264e-11cf-484d-9a3f-dd87f81aee3c\">\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 proccessed_data.zip to proccessed_data.zip\n"
          ]
        }
      ],
      "source": [
        "subject_info=files.upload()\n",
        "proccessed_data=files.upload()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "58Tjm1wQjFF-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dd748667-6dd0-4c82-c1fe-c5f79842b039"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "\n",
        "# Mount Google Drive\n",
        "drive.mount('/content/drive')\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "def mean_jump(file_path):\n",
        "    # Load data from CSV file\n",
        "    df = pd.read_csv(file_path)\n",
        "\n",
        "    # Extract time and data from DataFrame\n",
        "    time = df[\"Time [s]\"]\n",
        "    data = df[\"V_tidal [L]\"]\n",
        "\n",
        "    # Find local maxima and minima\n",
        "    local_maxima = (np.diff(np.sign(np.diff(data))) < 0).nonzero()[0] + 1\n",
        "    local_minima = (np.diff(np.sign(np.diff(data))) > 0).nonzero()[0] + 1\n",
        "\n",
        "    # Ensure the number of maxima and minima are the same\n",
        "    min_length = min(len(local_maxima), len(local_minima))\n",
        "    local_maxima = local_maxima[:min_length]\n",
        "    local_minima = local_minima[:min_length]\n",
        "\n",
        "    # Calculate differences between consecutive maxima and minima\n",
        "    differences = data.iloc[local_maxima].values - data.iloc[local_minima].values\n",
        "\n",
        "    # Calculate average of differences\n",
        "    average_difference = np.mean(differences)\n",
        "\n",
        "    return average_difference"
      ],
      "metadata": {
        "id": "qCAGn_QdJU7t"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "Hcaas29dCm0p",
        "outputId": "d2af063d-8bac-4736-c355-c996506c09b2"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_f0487863-344c-4201-8121-1b6f3a88deda\", \"final_data_set.xlsx\", 14055)"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "zip_filename = 'proccessed_data.zip'\n",
        "with zipfile.ZipFile(zip_filename, 'r') as zip_ref:\n",
        "    zip_ref.extractall('processed_data')\n",
        "\n",
        "\n",
        "parent_directory_path = 'processed_data'\n",
        "\n",
        "nested_directory_path = os.path.join(parent_directory_path, 'proccessed_data')\n",
        "\n",
        "# Get a list of CSV files sorted by their names\n",
        "csv_files = [file_name for file_name in os.listdir(nested_directory_path)]\n",
        "csv_files.sort()\n",
        "\n",
        "# Iterate through each CSV file, calculate the average, and store the results\n",
        "averages = []\n",
        "for file_name in csv_files:\n",
        "    file_path = os.path.join(nested_directory_path, file_name)\n",
        "    average_v_tidal = mean_jump(file_path)\n",
        "    averages.append({'File': file_name, 'Average_V_tidal': average_v_tidal})\n",
        "\n",
        "average_values = [entry['Average_V_tidal'] for entry in averages]\n",
        "# Create a DataFrame from the averages list\n",
        "data=pd.read_excel(\"subject-info (1).xlsx\")\n",
        "\n",
        "tidal_volume_series = pd.Series(average_values, name='tidal_volume')\n",
        "\n",
        "# Assign the Series to the 'tidal_volume' column\n",
        "data['tidal_volume'] = tidal_volume_series\n",
        "\n",
        "data.to_excel(\"final_data_set.xlsx\", index=False)\n",
        "\n",
        "files.download(\"final_data_set.xlsx\")\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data=files.upload()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "id": "g24lekG2ayB1",
        "outputId": "865c8939-ad7d-480d-8ef0-710ccc573968"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-07037e67-0f73-48b2-8b0b-56cf91dbb2f4\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-07037e67-0f73-48b2-8b0b-56cf91dbb2f4\">\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 final_data_set.xlsx to final_data_set (2).xlsx\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "HhyYeK_PKdxH"
      },
      "outputs": [],
      "source": [
        "\n",
        "data=pd.read_excel(\"final_data_set (2).xlsx\")\n",
        "data['Sex (M/F)']= data['Sex (M/F)'].replace('M',-1)\n",
        "data['Sex (M/F)']= data['Sex (M/F)'].replace('F',1)\n",
        "data['Asthma (Y/N)'] = data['Asthma (Y/N)'].replace('Y',1)\n",
        "data['Asthma (Y/N)'] = data['Asthma (Y/N)'].replace('N',0)\n",
        "data['History of Smoking (Y/N)'] = data['History of Smoking (Y/N)'].replace('N',0)\n",
        "data['History of Smoking (Y/N)'] = data['History of Smoking (Y/N)'].replace('Y',1)\n",
        "data['History of Vaping (Y/N)'] = data['History of Vaping (Y/N)'].replace('N',0)\n",
        "data['History of Vaping (Y/N)'] = data['History of Vaping (Y/N)'].replace('Y',1)\n",
        "data.replace('M ', -1, inplace=True)\n",
        "\n",
        "# Feature selection/engineering\n",
        "X = data[['Age [years]', 'Weight [kg]', 'Height [cm]', 'Chest Depth [mm]', 'Chest Width [mm]',\n",
        "          'Sex (M/F)', 'Asthma (Y/N)', 'History of Smoking (Y/N)', 'History of Vaping (Y/N)']]\n",
        "y = data['tidal_volume']\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dQFZF2gz_VrL",
        "outputId": "1543fa24-2595-435e-c5e5-a801b04c5e92"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Absolute Error: 0.2675275531904294\n"
          ]
        }
      ],
      "source": [
        "# Split data into train and test sets\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,random_state=1)\n",
        "\n",
        "# Model training\n",
        "model = LinearRegression()\n",
        "model.fit(X_train, y_train)\n",
        "\n",
        "# Model evaluation\n",
        "y_pred = model.predict(X_test)\n",
        "mae = mean_absolute_error(y_test, y_pred)\n",
        "print(\"Mean Absolute Error:\", mae)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the number of times to augment the dataset\n",
        "augmentation_factor = 1000\n",
        "\n",
        "# Initialize an empty DataFrame to store augmented data\n",
        "augmented_data = pd.DataFrame(columns=data.columns)\n",
        "\n",
        "\n",
        "# Apply augmentation\n",
        "for _ in range(augmentation_factor):\n",
        "    # Apply augmentation techniques here\n",
        "    # Example: Add random noise to numerical features\n",
        "    augmented_sample = data.copy()\n",
        "    for col in data.columns:\n",
        "        if col == 'Age [years]':  # Check if the column is 'Age'\n",
        "            # Convert 'Age' column to integer\n",
        "            augmented_sample['Age [years]'] = augmented_sample['Age [years]'].astype(int)\n",
        "        elif np.issubdtype(data[col].dtype, np.number):\n",
        "            # Add random noise to numerical features\n",
        "            augmented_sample[col] += np.random.normal(0, 0.1, size=len(data))\n",
        "\n",
        "    # Append augmented sample to augmented data\n",
        "    augmented_data = pd.concat([augmented_data, augmented_sample], ignore_index=True)\n",
        "\n",
        "# Print the size of the final dataset\n",
        "print(\"Original dataset size:\", len(data))\n",
        "print(\"Augmented dataset size:\", len(augmented_data))\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KHQQ80BzbsHj",
        "outputId": "5a391d40-e57b-4658-9359-87b7d0c79b25"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original dataset size: 80\n",
            "Augmented dataset size: 80000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(augmented_data)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9UoDXlSkcmnG",
        "outputId": "f546f7c4-8e90-45c7-85da-93de0dbf75d1"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "       Subject Number  Sex (M/F)  Height [cm]  Weight [kg] Age [years]  \\\n",
            "0            0.888867   0.955215   165.067377    59.239051          22   \n",
            "1            2.094492   1.080644   172.101153    95.889907          23   \n",
            "2            2.778951   1.155467   169.052907    66.107688          24   \n",
            "3            3.909706  -0.975822   186.077960    85.575277          22   \n",
            "4            4.758498  -1.017075   170.982854    61.000931          30   \n",
            "...               ...        ...          ...          ...         ...   \n",
            "79995       75.980778   1.055195   166.812177    56.102213          24   \n",
            "79996       77.037578   1.064124   151.021806    41.776726          28   \n",
            "79997       77.729057  -1.020084   180.816900    86.089210          23   \n",
            "79998       79.084172  -1.147101   186.989899    85.015198          21   \n",
            "79999       79.871799   1.132732   165.061048    54.005746          23   \n",
            "\n",
            "       Asthma (Y/N)         Medication Dosage Frequency  \\\n",
            "0          0.224569                NaN              NaN   \n",
            "1          0.901235            Vannair  3-4 times daily   \n",
            "2          0.157978                NaN              NaN   \n",
            "3          0.030597                NaN              NaN   \n",
            "4         -0.040186                NaN              NaN   \n",
            "...             ...                ...              ...   \n",
            "79995      0.069284                NaN              NaN   \n",
            "79996     -0.203826                NaN              NaN   \n",
            "79997     -0.046097                NaN              NaN   \n",
            "79998      0.000449                NaN              NaN   \n",
            "79999      0.995872  Seretide &Venteze      once daily    \n",
            "\n",
            "       History of Smoking (Y/N) Current Smoker (Y/N)  ... Time as a smoker   \\\n",
            "0                      0.027104                  NaN  ...               NaN   \n",
            "1                     -0.149804                  NaN  ...               NaN   \n",
            "2                     -0.046476                  NaN  ...               NaN   \n",
            "3                     -0.056937                  NaN  ...               NaN   \n",
            "4                      0.924643                    Y  ...          10 years   \n",
            "...                         ...                  ...  ...               ...   \n",
            "79995                  1.012076                    Y  ...          3 years    \n",
            "79996                  1.083636                    Y  ...           7 years   \n",
            "79997                  0.831217                    N  ...           3 years   \n",
            "79998                 -0.078483                  NaN  ...               NaN   \n",
            "79999                 -0.054818                  NaN  ...               NaN   \n",
            "\n",
            "      History of Vaping (Y/N) Current Vaper (Y/N)  \\\n",
            "0                   -0.131196                 NaN   \n",
            "1                    1.078897                   Y   \n",
            "2                    0.054669                 NaN   \n",
            "3                    0.097457                 NaN   \n",
            "4                   -0.097059                 NaN   \n",
            "...                       ...                 ...   \n",
            "79995               -0.126005                 NaN   \n",
            "79996               -0.051162                 NaN   \n",
            "79997                1.067608                   Y   \n",
            "79998                0.963369                   Y   \n",
            "79999               -0.019797                 NaN   \n",
            "\n",
            "       How long since you quit vaping Vaping Frequency Time as a vaper  \\\n",
            "0                                 NaN              NaN             NaN   \n",
            "1                                 NaN    4 times daily         2 years   \n",
            "2                                 NaN              NaN             NaN   \n",
            "3                                 NaN              NaN             NaN   \n",
            "4                                 NaN              NaN             NaN   \n",
            "...                               ...              ...             ...   \n",
            "79995                             NaN              NaN             NaN   \n",
            "79996                             NaN              NaN             NaN   \n",
            "79997                             NaN     once hourly          4 years   \n",
            "79998                             NaN   10 times daily        3 years    \n",
            "79999                             NaN              NaN             NaN   \n",
            "\n",
            "      Trial Classification  Chest Depth [mm] Chest Width [mm]  tidal_volume  \n",
            "0             Normal Female        19.926587        27.955575      0.218467  \n",
            "1          Asthmatic Female        25.142132        33.041291      0.307753  \n",
            "2             Normal Female        21.953822        30.048645      0.090625  \n",
            "3               Normal Male        27.099771        37.984585      0.125446  \n",
            "4               Normal Male        23.048514        29.929614      0.245723  \n",
            "...                     ...              ...              ...           ...  \n",
            "79995         Smoker Female        20.986031        30.010106     -0.033858  \n",
            "79996         Smoker Female        20.069779        25.204757      0.061942  \n",
            "79997            Vaper Male        24.788668        33.877252      0.676537  \n",
            "79998            Vaper Male        25.505537        36.016411      0.174661  \n",
            "79999      Asthmatic Female        22.927808        26.990494      0.338955  \n",
            "\n",
            "[80000 rows x 22 columns]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We did augmentation here in order to increase our dataset thereby increasing our accuracy"
      ],
      "metadata": {
        "id": "7PLDoXL95210"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Feature selection/engineering\n",
        "augmented_data[\"Age [years]\"] = augmented_data['Age [years]'].astype(int)\n",
        "X_augmented = augmented_data[['Age [years]', 'Weight [kg]', 'Height [cm]', 'Chest Depth [mm]', 'Chest Width [mm]',\n",
        "          'Sex (M/F)', 'Asthma (Y/N)', 'History of Smoking (Y/N)', 'History of Vaping (Y/N)']]\n",
        "y_augmented= augmented_data['tidal_volume']\n"
      ],
      "metadata": {
        "id": "PLmqF6ZmcbrM"
      },
      "execution_count": 74,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X_augmented, y_augmented, test_size=0.2, random_state=1)\n",
        "\n",
        "# Define a list of values for n_estimators to experiment with\n",
        "n_estimators_values = [50, 100, 150, 200, 250,350,450,550,650,750,850,950,1000]\n",
        "\n",
        "# Iterate over each value of n_estimators\n",
        "for n_estimators in n_estimators_values:\n",
        "    # Instantiate the Random Forest Regressor model with the current value of n_estimators\n",
        "    model = RandomForestRegressor(n_estimators=n_estimators, random_state=42)\n",
        "\n",
        "    # Train the model\n",
        "    model.fit(X_train, y_train)\n",
        "\n",
        "    # Make predictions on the test set\n",
        "    y_pred = model.predict(X_test)\n",
        "\n",
        "    # Calculate Mean Absolute Error (MAE)\n",
        "    mae = mean_absolute_error(y_test, y_pred)\n",
        "\n",
        "    # Print the MAE for the current value of n_estimators\n",
        "    print(f\"n_estimators = {n_estimators}, Mean Absolute Error: {mae}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vvy0Cqld4Hfu",
        "outputId": "0b8b9207-7540-42ff-fb91-ce2e74ab3e22"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_estimators = 50, Mean Absolute Error: 0.08305533410717278\n",
            "n_estimators = 100, Mean Absolute Error: 0.08266682918370115\n",
            "n_estimators = 150, Mean Absolute Error: 0.0824750813811108\n",
            "n_estimators = 200, Mean Absolute Error: 0.08236409762442887\n",
            "n_estimators = 250, Mean Absolute Error: 0.08233542614027277\n",
            "n_estimators = 350, Mean Absolute Error: 0.08228541755895728\n",
            "n_estimators = 450, Mean Absolute Error: 0.08223107675110898\n",
            "n_estimators = 550, Mean Absolute Error: 0.08223550402875503\n",
            "n_estimators = 650, Mean Absolute Error: 0.08221470993210422\n",
            "n_estimators = 750, Mean Absolute Error: 0.0821863426046198\n",
            "n_estimators = 850, Mean Absolute Error: 0.08217939117429128\n",
            "n_estimators = 950, Mean Absolute Error: 0.08216155016348622\n",
            "n_estimators = 1000, Mean Absolute Error: 0.08215998756137491\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model = SVR(kernel='rbf')  # You can choose different kernels like 'linear', 'poly', 'rbf', etc.\n",
        "\n",
        "# Train the model\n",
        "model.fit(X_train, y_train)\n",
        "\n",
        "# Make predictions on the test set\n",
        "y_pred = model.predict(X_test)\n",
        "\n",
        "# Calculate Mean Squared Error (MSE)\n",
        "mse = mean_squared_error(y_test, y_pred)\n",
        "print(\"Mean Squared Error:\", mse)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GkVDtdOz8xJg",
        "outputId": "e3ef2eac-6d58-4d80-9824-6347f75288f9"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Squared Error: 0.24995713806142078\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}