diff --git "a/Notebooks/Diabetes Classification.ipynb" "b/Notebooks/Diabetes Classification.ipynb"
new file mode 100644--- /dev/null
+++ "b/Notebooks/Diabetes Classification.ipynb"
@@ -0,0 +1,1611 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Data Installation"
+      ],
+      "metadata": {
+        "id": "CZK0VGVYnM7p"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IZa-s_kXT5N7",
+        "outputId": "002d97b5-67a8-4305-9119-185bddd63262"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting opendatasets\n",
+            "  Downloading opendatasets-0.1.22-py3-none-any.whl (15 kB)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from opendatasets) (4.66.2)\n",
+            "Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (from opendatasets) (1.5.16)\n",
+            "Requirement already satisfied: click in /usr/local/lib/python3.10/dist-packages (from opendatasets) (8.1.7)\n",
+            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle->opendatasets) (1.16.0)\n",
+            "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from kaggle->opendatasets) (2024.2.2)\n",
+            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle->opendatasets) (2.8.2)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle->opendatasets) (2.31.0)\n",
+            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle->opendatasets) (8.0.4)\n",
+            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle->opendatasets) (2.0.7)\n",
+            "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from kaggle->opendatasets) (6.1.0)\n",
+            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->kaggle->opendatasets) (0.5.1)\n",
+            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle->opendatasets) (1.3)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle->opendatasets) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle->opendatasets) (3.6)\n",
+            "Installing collected packages: opendatasets\n",
+            "Successfully installed opendatasets-0.1.22\n"
+          ]
+        }
+      ],
+      "source": [
+        "\"!pip install opendatasets"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import opendatasets as od\n",
+        "od.download('https://www.kaggle.com/datasets/akshaydattatraykhare/diabetes-dataset/download?datasetVersionNumber=1')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "tvr-DX6IUX8J",
+        "outputId": "19746d51-d575-4520-b604-099412f936ac"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading diabetes-dataset.zip to ./diabetes-dataset\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 8.91k/8.91k [00:00<00:00, 9.66MB/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Data Preparation"
+      ],
+      "metadata": {
+        "id": "krk56CApnPfs"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "df = pd.read_csv('/content/diabetes-dataset/diabetes.csv')"
+      ],
+      "metadata": {
+        "id": "TQlFD1yNUcTf"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df.shape"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NkndZ_pWUtBz",
+        "outputId": "82950c5b-1e79-4f92-8f4a-e5bc5dd4bac7"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(768, 9)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 187
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df.head()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "PM9EK3DgUnq1",
+        "outputId": "c18b38a6-d908-410a-cc8c-40039559d666"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "   Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
+              "0            6      148             72             35        0  33.6   \n",
+              "1            1       85             66             29        0  26.6   \n",
+              "2            8      183             64              0        0  23.3   \n",
+              "3            1       89             66             23       94  28.1   \n",
+              "4            0      137             40             35      168  43.1   \n",
+              "\n",
+              "   DiabetesPedigreeFunction  Age  Outcome  \n",
+              "0                     0.627   50        1  \n",
+              "1                     0.351   31        0  \n",
+              "2                     0.672   32        1  \n",
+              "3                     0.167   21        0  \n",
+              "4                     2.288   33        1  "
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-a9980f6b-0a39-4eea-8534-3522515e4ddd\" 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>Pregnancies</th>\n",
+              "      <th>Glucose</th>\n",
+              "      <th>BloodPressure</th>\n",
+              "      <th>SkinThickness</th>\n",
+              "      <th>Insulin</th>\n",
+              "      <th>BMI</th>\n",
+              "      <th>DiabetesPedigreeFunction</th>\n",
+              "      <th>Age</th>\n",
+              "      <th>Outcome</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>6</td>\n",
+              "      <td>148</td>\n",
+              "      <td>72</td>\n",
+              "      <td>35</td>\n",
+              "      <td>0</td>\n",
+              "      <td>33.6</td>\n",
+              "      <td>0.627</td>\n",
+              "      <td>50</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1</td>\n",
+              "      <td>85</td>\n",
+              "      <td>66</td>\n",
+              "      <td>29</td>\n",
+              "      <td>0</td>\n",
+              "      <td>26.6</td>\n",
+              "      <td>0.351</td>\n",
+              "      <td>31</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>8</td>\n",
+              "      <td>183</td>\n",
+              "      <td>64</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>23.3</td>\n",
+              "      <td>0.672</td>\n",
+              "      <td>32</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>1</td>\n",
+              "      <td>89</td>\n",
+              "      <td>66</td>\n",
+              "      <td>23</td>\n",
+              "      <td>94</td>\n",
+              "      <td>28.1</td>\n",
+              "      <td>0.167</td>\n",
+              "      <td>21</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>0</td>\n",
+              "      <td>137</td>\n",
+              "      <td>40</td>\n",
+              "      <td>35</td>\n",
+              "      <td>168</td>\n",
+              "      <td>43.1</td>\n",
+              "      <td>2.288</td>\n",
+              "      <td>33</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-a9980f6b-0a39-4eea-8534-3522515e4ddd')\"\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 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\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",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\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-a9980f6b-0a39-4eea-8534-3522515e4ddd 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-a9980f6b-0a39-4eea-8534-3522515e4ddd');\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",
+              "\n",
+              "\n",
+              "<div id=\"df-d3d4cffd-8c7a-43d7-a836-c47ebb1d1351\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-d3d4cffd-8c7a-43d7-a836-c47ebb1d1351')\"\n",
+              "            title=\"Suggest charts\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-d3d4cffd-8c7a-43d7-a836-c47ebb1d1351 button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "\n",
+              "    </div>\n",
+              "  </div>\n"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "dataframe",
+              "variable_name": "df",
+              "summary": "{\n  \"name\": \"df\",\n  \"rows\": 768,\n  \"fields\": [\n    {\n      \"column\": \"Pregnancies\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 3,\n        \"min\": 0,\n        \"max\": 17,\n        \"num_unique_values\": 17,\n        \"samples\": [\n          6,\n          1,\n          3\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Glucose\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 31,\n        \"min\": 0,\n        \"max\": 199,\n        \"num_unique_values\": 136,\n        \"samples\": [\n          151,\n          101,\n          112\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"BloodPressure\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 19,\n        \"min\": 0,\n        \"max\": 122,\n        \"num_unique_values\": 47,\n        \"samples\": [\n          86,\n          46,\n          85\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"SkinThickness\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 15,\n        \"min\": 0,\n        \"max\": 99,\n        \"num_unique_values\": 51,\n        \"samples\": [\n          7,\n          12,\n          48\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Insulin\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 115,\n        \"min\": 0,\n        \"max\": 846,\n        \"num_unique_values\": 186,\n        \"samples\": [\n          52,\n          41,\n          183\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"BMI\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 7.884160320375446,\n        \"min\": 0.0,\n        \"max\": 67.1,\n        \"num_unique_values\": 248,\n        \"samples\": [\n          19.9,\n          31.0,\n          38.1\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"DiabetesPedigreeFunction\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.3313285950127749,\n        \"min\": 0.078,\n        \"max\": 2.42,\n        \"num_unique_values\": 517,\n        \"samples\": [\n          1.731,\n          0.426,\n          0.138\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Age\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 11,\n        \"min\": 21,\n        \"max\": 81,\n        \"num_unique_values\": 52,\n        \"samples\": [\n          60,\n          47,\n          72\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Outcome\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0,\n        \"min\": 0,\n        \"max\": 1,\n        \"num_unique_values\": 2,\n        \"samples\": [\n          0,\n          1\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
+            }
+          },
+          "metadata": {},
+          "execution_count": 188
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#Relation of feature columns with the target column\n",
+        "df.corr()['Outcome']"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_Y_vcqGeX9HT",
+        "outputId": "a97277ea-ccd6-42e7-9931-636877b38282"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Pregnancies                 0.221898\n",
+              "Glucose                     0.466581\n",
+              "BloodPressure               0.065068\n",
+              "SkinThickness               0.074752\n",
+              "Insulin                     0.130548\n",
+              "BMI                         0.292695\n",
+              "DiabetesPedigreeFunction    0.173844\n",
+              "Age                         0.238356\n",
+              "Outcome                     1.000000\n",
+              "Name: Outcome, dtype: float64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 189
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df = df.drop(columns=['Pregnancies', 'BloodPressure','SkinThickness',\t'Insulin', 'DiabetesPedigreeFunction' ])\n",
+        "df.columns"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "qKkFgLdvUr6T",
+        "outputId": "a6ce6b94-a9c4-48f6-f1eb-99f4a7932ee1"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Index(['Glucose', 'BMI', 'Age', 'Outcome'], dtype='object')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 190
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df.isnull().sum()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "LiscsDZsXRgs",
+        "outputId": "4fd0e722-45f2-459a-e4cb-0816c87db3c4"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Glucose    0\n",
+              "BMI        0\n",
+              "Age        0\n",
+              "Outcome    0\n",
+              "dtype: int64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 191
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "fig, axes = plt.subplots(3, figsize=(5, 5))\n",
+        "\n",
+        "sns.histplot(data=df['Glucose'], kde=True, ax=axes[0], color='blue').set(title='Glucose Histogram')\n",
+        "sns.histplot(data=df['BMI'], kde=True, ax=axes[1], color='grey').set(title='BMI Histogram')\n",
+        "sns.histplot(data=df['Age'], kde=True, ax=axes[2], color='black').set(title='Age Histogram')\n",
+        "\n",
+        "plt.tight_layout()\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 506
+        },
+        "id": "TrQODYoyXVVD",
+        "outputId": "aa032378-fde8-4b46-d571-ba52d3016d03"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 500x500 with 3 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df.Outcome.value_counts()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fFguK77JY_qS",
+        "outputId": "37fd2c4e-5a31-4e18-926c-221d9accf282"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0    500\n",
+              "1    268\n",
+              "Name: Outcome, dtype: int64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 193
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sns.boxplot(data=df[['Glucose', 'BMI', 'Age']])\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 430
+        },
+        "id": "5SLSZyVLafSh",
+        "outputId": "fdd7b7c4-2017-4190-98b3-4c6f9336c4dd"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#outlier seperation\n",
+        "Q1 = df[['Glucose', 'BMI', 'Age']].quantile(0.25)\n",
+        "Q3 = df[['Glucose', 'BMI', 'Age']].quantile(0.75)\n",
+        "IQR = Q3 - Q1\n",
+        "\n",
+        "outliers = ((df[['Glucose', 'BMI', 'Age']] < (Q1 - 1.5 * IQR)) | (df[['Glucose', 'BMI', 'Age']] > (Q3 + 1.5 * IQR))).any(axis=1)\n",
+        "df_outliers = df[outliers]\n",
+        "len(df_outliers)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "rO3I58qsaMNY",
+        "outputId": "de3d196d-0c75-47db-ef1e-86d2f822abca"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "32"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 195
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#removing outliers\n",
+        "df = df[~outliers]\n",
+        "df.shape"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4IjIPweKapjA",
+        "outputId": "56f44605-1e96-46bf-df40-5a8513c62a95"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(736, 4)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 196
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df.Outcome.value_counts()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KLSsA-7lbrmd",
+        "outputId": "e507c22a-722d-4332-8228-cc782c6764c0"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0    480\n",
+              "1    256\n",
+              "Name: Outcome, dtype: int64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 197
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#initializing features and targets\n",
+        "features_neq = df.drop('Outcome', axis=1).values\n",
+        "targets_neq = df['Outcome'].values"
+      ],
+      "metadata": {
+        "id": "gqoM8773dIed"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "features_neq[0], targets_neq[0]"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "BNsXZnlUdog-",
+        "outputId": "1c817b11-c315-4d45-e783-58271a106c32"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(array([148. ,  33.6,  50. ]), 1)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 199
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "len(features_neq), len(targets_neq)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "c8bb5Z56dbEa",
+        "outputId": "d130e7c1-5aae-41cf-8c81-c93a07f7103d"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(736, 736)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 200
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#Handling imbalanced dataset\n",
+        "from collections import Counter\n",
+        "print(\"Count of Target before over sampling: \",Counter(targets_neq))\n",
+        "from imblearn.over_sampling import SMOTE\n",
+        "os = SMOTE(sampling_strategy='minority',random_state=2007)\n",
+        "features_n,targets_n = os.fit_resample(features_neq,targets_neq)\n",
+        "print(\"Count of Target after over sampling: \",Counter(targets_n))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "6958LLRobxYr",
+        "outputId": "55ca1103-f614-4329-f444-4cce71fc2a45"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Count of Target before over sampling:  Counter({0: 480, 1: 256})\n",
+            "Count of Target after over sampling:  Counter({1: 480, 0: 480})\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "features = torch.tensor(features_n, dtype=torch.float32)\n",
+        "targets = torch.tensor(targets_n, dtype=torch.float32)"
+      ],
+      "metadata": {
+        "id": "1FHAfoE_f85M"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.model_selection import train_test_split\n",
+        "\n",
+        "X_train,X_val,y_train,y_val=train_test_split(features,targets,test_size=0.2,random_state=2007)"
+      ],
+      "metadata": {
+        "id": "V05j4Kv5eJ9n"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "len(X_train),len(y_train),len(X_val),len(y_val)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "BzYJv3oQeqFn",
+        "outputId": "26dda21f-f029-488b-e9e1-47757e4091f6"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(768, 768, 192, 192)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 204
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.preprocessing import StandardScaler\n",
+        "\n",
+        "# Normalize the data\n",
+        "scaler = StandardScaler()\n",
+        "X_train_norm = scaler.fit_transform(X_train)\n",
+        "X_val_norm = scaler.transform(X_val)"
+      ],
+      "metadata": {
+        "id": "txahcoSvqrQO"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Machine Learning"
+      ],
+      "metadata": {
+        "id": "z3rW7kq9nWfh"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.linear_model import LogisticRegression\n",
+        "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
+        "\n",
+        "# Instantiate the model\n",
+        "log_model = LogisticRegression()\n",
+        "\n",
+        "# Train the model\n",
+        "log_model.fit(X_train_norm, y_train)\n",
+        "\n",
+        "# Make predictions on the validation set\n",
+        "y_pred = log_model.predict(X_val_norm)\n",
+        "\n",
+        "# Evaluate the model\n",
+        "accuracy = accuracy_score(y_val, y_pred)\n",
+        "conf_matrix = confusion_matrix(y_val, y_pred)\n",
+        "class_report = classification_report(y_val, y_pred)\n",
+        "\n",
+        "print(\"Accuracy:\", accuracy)\n",
+        "print(\"Confusion Matrix:\\n\", conf_matrix)\n",
+        "print(\"Classification Report:\\n\", class_report)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "DXt4lrkwew92",
+        "outputId": "f1cfcaa7-51d3-4da6-ee86-7b2732033768"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Accuracy: 0.78125\n",
+            "Confusion Matrix:\n",
+            " [[83 20]\n",
+            " [22 67]]\n",
+            "Classification Report:\n",
+            "               precision    recall  f1-score   support\n",
+            "\n",
+            "         0.0       0.79      0.81      0.80       103\n",
+            "         1.0       0.77      0.75      0.76        89\n",
+            "\n",
+            "    accuracy                           0.78       192\n",
+            "   macro avg       0.78      0.78      0.78       192\n",
+            "weighted avg       0.78      0.78      0.78       192\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.neighbors import KNeighborsClassifier\n",
+        "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
+        "\n",
+        "# Instantiate the model\n",
+        "knn_model = KNeighborsClassifier()\n",
+        "\n",
+        "# Train the model\n",
+        "knn_model.fit(X_train_norm, y_train)\n",
+        "\n",
+        "# Make predictions on the validation set\n",
+        "y_pred = knn_model.predict(X_val_norm)\n",
+        "\n",
+        "# Evaluate the model\n",
+        "accuracy = accuracy_score(y_val, y_pred)\n",
+        "conf_matrix = confusion_matrix(y_val, y_pred)\n",
+        "class_report = classification_report(y_val, y_pred)\n",
+        "\n",
+        "print(\"Accuracy:\", accuracy)\n",
+        "print(\"Confusion Matrix:\\n\", conf_matrix)\n",
+        "print(\"Classification Report:\\n\", class_report)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "MxwGozrSsK-5",
+        "outputId": "78c0ba7d-7f72-4acc-e1b6-e4bc2fef22b3"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Accuracy: 0.7604166666666666\n",
+            "Confusion Matrix:\n",
+            " [[72 31]\n",
+            " [15 74]]\n",
+            "Classification Report:\n",
+            "               precision    recall  f1-score   support\n",
+            "\n",
+            "         0.0       0.83      0.70      0.76       103\n",
+            "         1.0       0.70      0.83      0.76        89\n",
+            "\n",
+            "    accuracy                           0.76       192\n",
+            "   macro avg       0.77      0.77      0.76       192\n",
+            "weighted avg       0.77      0.76      0.76       192\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.ensemble import RandomForestClassifier\n",
+        "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
+        "\n",
+        "# Instantiate the model\n",
+        "rf_model = RandomForestClassifier(n_estimators=200)\n",
+        "\n",
+        "# Train the model\n",
+        "rf_model.fit(X_train_norm, y_train)\n",
+        "\n",
+        "# Make predictions on the validation set\n",
+        "y_pred = rf_model.predict(X_val_norm)\n",
+        "\n",
+        "# Evaluate the model\n",
+        "accuracy = accuracy_score(y_val, y_pred)\n",
+        "conf_matrix = confusion_matrix(y_val, y_pred)\n",
+        "class_report = classification_report(y_val, y_pred)\n",
+        "\n",
+        "print(\"Accuracy:\", accuracy)\n",
+        "print(\"Confusion Matrix:\\n\", conf_matrix)\n",
+        "print(\"Classification Report:\\n\", class_report)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "bBf_IgWDsvgx",
+        "outputId": "cb5dc7d1-d6b6-40b6-ad60-cdd4a1277e1b"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Accuracy: 0.7864583333333334\n",
+            "Confusion Matrix:\n",
+            " [[80 23]\n",
+            " [18 71]]\n",
+            "Classification Report:\n",
+            "               precision    recall  f1-score   support\n",
+            "\n",
+            "         0.0       0.82      0.78      0.80       103\n",
+            "         1.0       0.76      0.80      0.78        89\n",
+            "\n",
+            "    accuracy                           0.79       192\n",
+            "   macro avg       0.79      0.79      0.79       192\n",
+            "weighted avg       0.79      0.79      0.79       192\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.tree import DecisionTreeClassifier\n",
+        "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
+        "\n",
+        "# Instantiate the model\n",
+        "dec_model = DecisionTreeClassifier()\n",
+        "\n",
+        "# Train the model\n",
+        "dec_model.fit(X_train_norm, y_train)\n",
+        "\n",
+        "# Make predictions on the validation set\n",
+        "y_pred = dec_model.predict(X_val_norm)\n",
+        "\n",
+        "# Evaluate the model\n",
+        "accuracy = accuracy_score(y_val, y_pred)\n",
+        "conf_matrix = confusion_matrix(y_val, y_pred)\n",
+        "class_report = classification_report(y_val, y_pred)\n",
+        "\n",
+        "print(\"Accuracy:\", accuracy)\n",
+        "print(\"Confusion Matrix:\\n\", conf_matrix)\n",
+        "print(\"Classification Report:\\n\", class_report)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "O_uZVzUAtBdD",
+        "outputId": "f57f03e1-ce51-4637-b5eb-907ea0c95eab"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Accuracy: 0.765625\n",
+            "Confusion Matrix:\n",
+            " [[78 25]\n",
+            " [20 69]]\n",
+            "Classification Report:\n",
+            "               precision    recall  f1-score   support\n",
+            "\n",
+            "         0.0       0.80      0.76      0.78       103\n",
+            "         1.0       0.73      0.78      0.75        89\n",
+            "\n",
+            "    accuracy                           0.77       192\n",
+            "   macro avg       0.76      0.77      0.77       192\n",
+            "weighted avg       0.77      0.77      0.77       192\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from tabulate import tabulate\n",
+        "\n",
+        "# Define the data\n",
+        "data = [\n",
+        "    [\"Random Forest Classifier\", \"79.68%\"],\n",
+        "    [\"Logistic Regression\", \"78.12%\"],\n",
+        "    [\"Decision Tree Classifier\", \"76.56%\"],\n",
+        "    [\"K-Nearest Neighbors Classifier\", \"76.04%\"]\n",
+        "]\n",
+        "\n",
+        "# Define the headers\n",
+        "headers = [\"ML Algorithm\", \"Accuracy\"]\n",
+        "\n",
+        "# Print the table\n",
+        "print(tabulate(data, headers=headers, tablefmt=\"grid\"))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "SbyjaOtwtfZv",
+        "outputId": "248d79fd-9dfa-4c48-e636-72436c2bf4f3"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "+--------------------------------+------------+\n",
+            "| ML Algorithm                   | Accuracy   |\n",
+            "+================================+============+\n",
+            "| Random Forest Classifier       | 79.68%     |\n",
+            "+--------------------------------+------------+\n",
+            "| Logistic Regression            | 78.12%     |\n",
+            "+--------------------------------+------------+\n",
+            "| Decision Tree Classifier       | 76.56%     |\n",
+            "+--------------------------------+------------+\n",
+            "| K-Nearest Neighbors Classifier | 76.04%     |\n",
+            "+--------------------------------+------------+\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Deep Learning"
+      ],
+      "metadata": {
+        "id": "uRG4NpAknaAC"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from torch.utils.data import TensorDataset, DataLoader\n",
+        "# Convert the data to PyTorch tensors\n",
+        "X_train_tensor = torch.tensor(X_train_norm, dtype=torch.float32)\n",
+        "X_val_tensor = torch.tensor(X_val_norm, dtype=torch.float32)\n",
+        "y_train_tensor = torch.tensor(y_train, dtype=torch.float32)\n",
+        "y_val_tensor = torch.tensor(y_val, dtype=torch.float32)\n",
+        "\n",
+        "# Create DataLoader objects for train and validation sets\n",
+        "train_dataset = TensorDataset(X_train_tensor, y_train_tensor)\n",
+        "val_dataset = TensorDataset(X_val_tensor, y_val_tensor)\n",
+        "\n",
+        "batch_size = 64\n",
+        "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
+        "val_loader = DataLoader(val_dataset, batch_size=batch_size)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "dUdIiORigiRF",
+        "outputId": "e41a77f9-be0b-4b56-ea37-566c5bb86cf2"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "<ipython-input-209-5266c73c1a7a>:5: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+            "  y_train_tensor = torch.tensor(y_train, dtype=torch.float32)\n",
+            "<ipython-input-209-5266c73c1a7a>:6: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+            "  y_val_tensor = torch.tensor(y_val, dtype=torch.float32)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### Model"
+      ],
+      "metadata": {
+        "id": "7gn56uA3nbyZ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch.nn as nn\n",
+        "class DiabetesModel(nn.Module):\n",
+        "  def __init__(self, input_size):\n",
+        "        super(DiabetesModel, self).__init__()\n",
+        "        self.network = nn.Sequential(\n",
+        "            nn.Linear(input_size, 32),\n",
+        "            nn.ReLU(),\n",
+        "\n",
+        "            nn.Linear(32, 64),\n",
+        "            nn.ReLU(),\n",
+        "\n",
+        "            nn.Linear(64, 128),\n",
+        "            nn.ReLU(),\n",
+        "\n",
+        "            nn.Linear(128, 64),\n",
+        "            nn.ReLU(),\n",
+        "\n",
+        "            nn.Linear(64, 64),\n",
+        "            nn.ReLU(),\n",
+        "\n",
+        "            nn.Linear(64, 32)\n",
+        "        )\n",
+        "        self.classifier = nn.Sequential(\n",
+        "            nn.Linear(32, 1),\n",
+        "            nn.Sigmoid()\n",
+        "        )\n",
+        "  def forward(self, x):\n",
+        "    network = self.network(x)\n",
+        "    classifier = self.classifier(network)\n",
+        "    return classifier"
+      ],
+      "metadata": {
+        "id": "g2FAorfzhKel"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Instantiate the model\n",
+        "input_size = X_train.shape[1]\n",
+        "model = DiabetesModel(input_size)"
+      ],
+      "metadata": {
+        "id": "tP-YeLxghE0g"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jn1yGl99jr2a",
+        "outputId": "5dd86077-a944-4236-b625-eb9ec10ffa80"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DiabetesModel(\n",
+              "  (network): Sequential(\n",
+              "    (0): Linear(in_features=3, out_features=32, bias=True)\n",
+              "    (1): ReLU()\n",
+              "    (2): Linear(in_features=32, out_features=64, bias=True)\n",
+              "    (3): ReLU()\n",
+              "    (4): Linear(in_features=64, out_features=128, bias=True)\n",
+              "    (5): ReLU()\n",
+              "    (6): Linear(in_features=128, out_features=64, bias=True)\n",
+              "    (7): ReLU()\n",
+              "    (8): Linear(in_features=64, out_features=64, bias=True)\n",
+              "    (9): ReLU()\n",
+              "    (10): Linear(in_features=64, out_features=32, bias=True)\n",
+              "  )\n",
+              "  (classifier): Sequential(\n",
+              "    (0): Linear(in_features=32, out_features=1, bias=True)\n",
+              "    (1): Sigmoid()\n",
+              "  )\n",
+              ")"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 213
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def count_parameters(model):\n",
+        "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
+        "\n",
+        "num_params = count_parameters(model)\n",
+        "print(f\"Number of parameters in the model: {num_params}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "V1oaxacsj_sw",
+        "outputId": "df1c56f4-c9f7-4b3c-f51a-63832bf367cb"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Number of parameters in the model: 25089\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### Training"
+      ],
+      "metadata": {
+        "id": "D7vh8I6nnhMA"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "criterion = nn.BCELoss()\n",
+        "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)"
+      ],
+      "metadata": {
+        "id": "Ewy155TQhEtr"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
+        "import numpy as np\n",
+        "\n",
+        "def train(model, train_loader, val_loader, criterion, optimizer, num_epochs, patience=5):\n",
+        "    scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=3, verbose=True)\n",
+        "    best_val_loss = np.Inf\n",
+        "    counter = 0\n",
+        "    for epoch in range(num_epochs):\n",
+        "        model.train()\n",
+        "        train_loss = 0.0\n",
+        "        for inputs, labels in train_loader:\n",
+        "            optimizer.zero_grad()\n",
+        "            outputs = model(inputs)\n",
+        "            loss = criterion(outputs, labels.unsqueeze(1))\n",
+        "            loss.backward()\n",
+        "            optimizer.step()\n",
+        "            train_loss += loss.item() * inputs.size(0)\n",
+        "        train_loss /= len(train_loader.dataset)\n",
+        "\n",
+        "        model.eval()\n",
+        "        val_loss = 0.0\n",
+        "        correct = 0\n",
+        "        total = 0\n",
+        "        with torch.no_grad():\n",
+        "            for inputs, labels in val_loader:\n",
+        "                outputs = model(inputs)\n",
+        "                val_loss += criterion(outputs, labels.unsqueeze(1)).item()\n",
+        "                predicted = (outputs > 0.5).float()\n",
+        "                correct += (predicted == labels.unsqueeze(1)).sum().item()\n",
+        "                total += labels.size(0)\n",
+        "            val_loss /= len(val_loader.dataset)\n",
+        "            val_accuracy = correct / total\n",
+        "\n",
+        "        scheduler.step(val_loss)\n",
+        "          # Early stopping\n",
+        "        if val_loss < best_val_loss:\n",
+        "            best_val_loss = val_loss\n",
+        "            counter = 0\n",
+        "        else:\n",
+        "            counter += 1\n",
+        "            if counter >= patience:\n",
+        "                print(f'Early stopping at epoch {epoch+1}')\n",
+        "                break\n",
+        "\n",
+        "        print(f\"Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}, Val Accuracy: {val_accuracy:.4f}\")\n",
+        "\n",
+        "\n",
+        "    return epoch+1, train_loss, val_loss, val_accuracy"
+      ],
+      "metadata": {
+        "id": "4AqXhaQShCPM"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Assuming model, train_loader, val_loader, criterion, and optimizer are already defined\n",
+        "num_epochs = 500\n",
+        "patience = 50\n",
+        "history = train(model, train_loader, val_loader, criterion, optimizer, num_epochs, patience)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "cPX6OhyDhCMv",
+        "outputId": "b46ffca2-5a31-4622-9148-cb489d7851d3"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1/500, Train Loss: 0.6481, Val Loss: 0.0088, Val Accuracy: 0.7760\n",
+            "Epoch 2/500, Train Loss: 0.5400, Val Loss: 0.0067, Val Accuracy: 0.7760\n",
+            "Epoch 3/500, Train Loss: 0.5418, Val Loss: 0.0078, Val Accuracy: 0.7865\n",
+            "Epoch 4/500, Train Loss: 0.5163, Val Loss: 0.0073, Val Accuracy: 0.8073\n",
+            "Epoch 5/500, Train Loss: 0.5024, Val Loss: 0.0065, Val Accuracy: 0.8073\n",
+            "Epoch 6/500, Train Loss: 0.4811, Val Loss: 0.0064, Val Accuracy: 0.8021\n",
+            "Epoch 7/500, Train Loss: 0.4863, Val Loss: 0.0073, Val Accuracy: 0.7812\n",
+            "Epoch 8/500, Train Loss: 0.4988, Val Loss: 0.0065, Val Accuracy: 0.8021\n",
+            "Epoch 9/500, Train Loss: 0.4713, Val Loss: 0.0064, Val Accuracy: 0.8073\n",
+            "Epoch 10/500, Train Loss: 0.4598, Val Loss: 0.0063, Val Accuracy: 0.8125\n",
+            "Epoch 11/500, Train Loss: 0.4714, Val Loss: 0.0068, Val Accuracy: 0.7865\n",
+            "Epoch 12/500, Train Loss: 0.4591, Val Loss: 0.0065, Val Accuracy: 0.7969\n",
+            "Epoch 13/500, Train Loss: 0.4550, Val Loss: 0.0068, Val Accuracy: 0.7760\n",
+            "Epoch 00014: reducing learning rate of group 0 to 1.0000e-03.\n",
+            "Epoch 14/500, Train Loss: 0.4683, Val Loss: 0.0065, Val Accuracy: 0.8229\n",
+            "Epoch 15/500, Train Loss: 0.4472, Val Loss: 0.0063, Val Accuracy: 0.8021\n",
+            "Epoch 16/500, Train Loss: 0.4403, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 17/500, Train Loss: 0.4375, Val Loss: 0.0064, Val Accuracy: 0.8021\n",
+            "Epoch 00018: reducing learning rate of group 0 to 1.0000e-04.\n",
+            "Epoch 18/500, Train Loss: 0.4367, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 19/500, Train Loss: 0.4346, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 20/500, Train Loss: 0.4344, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 21/500, Train Loss: 0.4343, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 00022: reducing learning rate of group 0 to 1.0000e-05.\n",
+            "Epoch 22/500, Train Loss: 0.4342, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 23/500, Train Loss: 0.4340, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 24/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 25/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 00026: reducing learning rate of group 0 to 1.0000e-06.\n",
+            "Epoch 26/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 27/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 28/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 29/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 00030: reducing learning rate of group 0 to 1.0000e-07.\n",
+            "Epoch 30/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 31/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 32/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 33/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 00034: reducing learning rate of group 0 to 1.0000e-08.\n",
+            "Epoch 34/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 35/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 36/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 37/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 38/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 39/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 40/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 41/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 42/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 43/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 44/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 45/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 46/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 47/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 48/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 49/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 50/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 51/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 52/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 53/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 54/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 55/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 56/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 57/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 58/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Epoch 59/500, Train Loss: 0.4339, Val Loss: 0.0063, Val Accuracy: 0.7969\n",
+            "Early stopping at epoch 60\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Saving"
+      ],
+      "metadata": {
+        "id": "8Lcugw4yubr9"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from joblib import dump, load\n",
+        "# Save the machine learning model with highest stability and accuracy i.e 78%\n",
+        "dump(rf_model, 'random_forest_model.joblib')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fW-wSUjPhCI3",
+        "outputId": "8f739dfe-3689-4ce0-e9a9-0ce4c3a5edd2"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "['random_forest_model.joblib']"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 235
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file