Random_Forest.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import pandas as pd\n",
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()\n",
        "uploaded2 = files.upload()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        },
        "id": "PNJnmyL8hWrs",
        "outputId": "98a24a66-31cc-43b9-9602-787d9009d9f5"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-6f8dc0f5-53e7-4fb9-b9e1-ab58233b12f3\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-6f8dc0f5-53e7-4fb9-b9e1-ab58233b12f3\">\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 hospitalizaciones_train.csv to hospitalizaciones_train.csv\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-91e5ec79-61b8-4a6c-ae79-95613012cf3c\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-91e5ec79-61b8-4a6c-ae79-95613012cf3c\">\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 hospitalizaciones_test.csv to hospitalizaciones_test.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the datasets\n",
        "train = pd.read_csv(io.BytesIO(uploaded['hospitalizaciones_train.csv']))\n",
        "test = pd.read_csv(io.BytesIO(uploaded2['hospitalizaciones_test.csv']))"
      ],
      "metadata": {
        "id": "Y84Ry6Hm0RGc"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# We leave the names of the columns well. No unnecessary ungrammatical capitalization\n",
        "train.columns = ['Rooms_available', 'Department', 'Ward_facility_code', 'Doctor_name', 'Staff_available', 'PatientID', 'Age', 'Gender', 'Type_of_admission', 'Severity_of_illness', 'Health_conditions', 'Visitors_with_patient', 'Insurance', 'Admission_deposit', 'Stay_in_days']\n",
        "test.columns = ['Rooms_available', 'Department', 'Ward_facility_code', 'Doctor_name', 'Staff_available', 'PatientID', 'Age', 'Gender', 'Type_of_admission', 'Severity_of_illness', 'Health_conditions', 'Visitors_with_patient', 'Insurance', 'Admission_deposit']"
      ],
      "metadata": {
        "id": "zmOZD0Voz06r"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train.columns"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NGXzKM1LzNyG",
        "outputId": "282250c5-fae2-4018-c00d-45cfadba3c72"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['Rooms_available', 'Department', 'Ward_facility_code', 'Doctor_name',\n",
              "       'Staff_available', 'PatientID', 'Age', 'Gender', 'Type_of_admission',\n",
              "       'Severity_of_illness', 'Health_conditions', 'Visitors_with_patient',\n",
              "       'Insurance', 'Admission_deposit', 'Stay_in_days'],\n",
              "      dtype='object')"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We added a categorical column distinguishing whether your stay was prolonged or not, in binary\n",
        "stay = []\n",
        "for row in train['Stay_in_days']:\n",
        "    if row <= 8 :    stay.append(0)\n",
        "    else:\n",
        "        stay.append(1)\n",
        "\n",
        "train['prolonged_stay'] = stay"
      ],
      "metadata": {
        "id": "zKg5To6H0wnV"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Encode categorical variables\n",
        "train = pd.get_dummies(train, columns=['Department', 'Gender', 'Type_of_admission', 'Severity_of_illness', 'Health_conditions', 'Age', 'Insurance'])\n",
        "test = pd.get_dummies(test, columns=['Department', 'Gender', 'Type_of_admission', 'Severity_of_illness', 'Health_conditions', 'Age', 'Insurance'])"
      ],
      "metadata": {
        "id": "ppseha5rzHbe"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train.columns"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LBo2CVNT1kfk",
        "outputId": "ca053510-2e21-4bda-8eef-8a933cb6b927"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['Rooms_available', 'Ward_facility_code', 'Doctor_name',\n",
              "       'Staff_available', 'PatientID', 'Visitors_with_patient',\n",
              "       'Admission_deposit', 'Stay_in_days', 'prolonged_stay',\n",
              "       'Department_TB & Chest disease', 'Department_anesthesia',\n",
              "       'Department_gynecology', 'Department_radiotherapy',\n",
              "       'Department_surgery', 'Gender_Female', 'Gender_Male', 'Gender_Other',\n",
              "       'Type_of_admission_Emergency', 'Type_of_admission_Trauma',\n",
              "       'Type_of_admission_Urgent', 'Severity_of_illness_Extreme',\n",
              "       'Severity_of_illness_Minor', 'Severity_of_illness_Moderate',\n",
              "       'Health_conditions_Asthama', 'Health_conditions_Diabetes',\n",
              "       'Health_conditions_Heart disease',\n",
              "       'Health_conditions_High Blood Pressure', 'Health_conditions_None',\n",
              "       'Health_conditions_Other', 'Age_0-10', 'Age_11-20', 'Age_21-30',\n",
              "       'Age_31-40', 'Age_41-50', 'Age_51-60', 'Age_61-70', 'Age_71-80',\n",
              "       'Age_81-90', 'Age_91-100', 'Insurance_No', 'Insurance_Yes'],\n",
              "      dtype='object')"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
        "\n",
        "\n",
        "# Split the data into training and testing sets\n",
        "X_train, X_test, y_train, y_test = train_test_split(train.drop(['Ward_facility_code', 'Doctor_name', 'Stay_in_days', 'prolonged_stay'], axis=1),\n",
        "train['prolonged_stay'], test_size=0.2, random_state=42)"
      ],
      "metadata": {
        "id": "xkg8MjPZzUGA"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "\n",
        "start_time = time.time()\n",
        "\n",
        "# Train the model\n",
        "rf = RandomForestClassifier(n_estimators=2500, max_depth=25, random_state=42)\n",
        "rf.fit(X_train, y_train)\n",
        "\n",
        "end_time = time.time()\n",
        "\n",
        "print(\"Time taken to fit the Random Forest model:\", end_time - start_time, \"seconds\")"
      ],
      "metadata": {
        "id": "Aoa28KHj00vN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3de0b2d1-caba-439f-9a35-7e7091e01d79"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time taken to fit the Random Forest model: 1552.4054703712463 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluate the model\n",
        "y_pred = rf.predict(X_test)\n",
        "accuracy = accuracy_score(y_test, y_pred)\n",
        "precision = precision_score(y_test, y_pred)\n",
        "recall = recall_score(y_test, y_pred)\n",
        "f1 = f1_score(y_test, y_pred)\n",
        "\n",
        "print(\"Accuracy:\", accuracy)\n",
        "print(\"Precision:\", precision)\n",
        "print(\"Recall:\", recall)\n",
        "print(\"F1 score:\", f1)"
      ],
      "metadata": {
        "id": "u1W3LuPv2kc2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8bc0cd1d-4e91-499c-f47c-a924b155720b"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.7600121951219512\n",
            "Precision: 0.7843158621190658\n",
            "Recall: 0.8469669928808174\n",
            "F1 score: 0.814438336272171\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Drop irrelevant columns\n",
        "test.drop(['Ward_facility_code', 'Doctor_name'], axis=1, inplace=True)"
      ],
      "metadata": {
        "id": "Z2_JQp5zAExi"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions using the trained model on a new dataset and new patients\n",
        "predictions_test = rf.predict(test)"
      ],
      "metadata": {
        "id": "yxe_NCvL_Nd5"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Get feature importances and feature names\n",
        "importances = rf.feature_importances_\n",
        "feature_names = X_train.columns\n",
        "\n",
        "# Sort the features by importance\n",
        "indices = np.argsort(importances)[::-1]\n",
        "\n",
        "# Print the feature ranking\n",
        "print(\"Feature ranking:\")\n",
        "for f in range(X_train.shape[1]):\n",
        "    print(f\"{f+1}. {feature_names[indices[f]]}: {importances[indices[f]]}\")\n",
        "\n",
        "# Plot the feature importances\n",
        "plt.bar(range(X_train.shape[1]), importances[indices])\n",
        "plt.xticks(range(X_train.shape[1]), feature_names[indices], rotation=90)\n",
        "plt.title(\"Feature importances\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "n8-A4o1ta3WQ",
        "outputId": "d2be10f8-3849-4e1c-8831-008a4932e721"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Feature ranking:\n",
            "1. Admission_deposit: 0.18347423239377375\n",
            "2. PatientID: 0.12055975595551965\n",
            "3. Age_31-40: 0.07364936524299621\n",
            "4. Rooms_available: 0.07349175325848611\n",
            "5. Department_radiotherapy: 0.061378396407834705\n",
            "6. Staff_available: 0.06101589795581822\n",
            "7. Age_41-50: 0.05596419706659413\n",
            "8. Department_anesthesia: 0.05476845823726365\n",
            "9. Visitors_with_patient: 0.04581748509475244\n",
            "10. Department_gynecology: 0.031472098166926726\n",
            "11. Age_61-70: 0.028545593216138358\n",
            "12. Department_TB & Chest disease: 0.022364127240169836\n",
            "13. Age_51-60: 0.022114322600877697\n",
            "14. Age_21-30: 0.022019987080731884\n",
            "15. Age_71-80: 0.021613677998639527\n",
            "16. Gender_Female: 0.020802195250628295\n",
            "17. Gender_Male: 0.01369307734373755\n",
            "18. Age_81-90: 0.01027063012309381\n",
            "19. Type_of_admission_Trauma: 0.006213934017259223\n",
            "20. Severity_of_illness_Moderate: 0.005835415626190858\n",
            "21. Type_of_admission_Emergency: 0.005595378806750314\n",
            "22. Severity_of_illness_Minor: 0.004886517447201377\n",
            "23. Insurance_Yes: 0.004847102549191564\n",
            "24. Insurance_No: 0.004844302784876463\n",
            "25. Health_conditions_None: 0.004806949655650566\n",
            "26. Department_surgery: 0.004639332207257402\n",
            "27. Health_conditions_Other: 0.004533076408784045\n",
            "28. Health_conditions_Diabetes: 0.004333172893085926\n",
            "29. Health_conditions_High Blood Pressure: 0.0041516876596482686\n",
            "30. Health_conditions_Asthama: 0.004061870660454217\n",
            "31. Type_of_admission_Urgent: 0.0038554009113494106\n",
            "32. Severity_of_illness_Extreme: 0.0036967585151612297\n",
            "33. Age_0-10: 0.003089337073531027\n",
            "34. Health_conditions_Heart disease: 0.002916411688233264\n",
            "35. Age_11-20: 0.0025121049625901237\n",
            "36. Gender_Other: 0.0014201484882982005\n",
            "37. Age_91-100: 0.000745847010503845\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}