FMML-22-CLF1(Project).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "language": "python",
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "version": "3.6.4",
      "file_extension": ".py",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "name": "python",
      "mimetype": "text/x-python"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/lakshmilikithabonthu/Fmml/blob/main/FMML-22-CLF1(Project).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
        "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
        "trusted": true,
        "id": "unG213zJhFsx"
      },
      "source": [
        "# **FOUNDATIONS OF MODERN MACHINE LEARNING, IIIT Hyderabad**\n",
        "# Project : Data Visualization, Choosing K-value and Appreciating Feature Scaling and Standardization\n",
        "## Module Coordinator: Tanvi Kamble\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
        "collapsed": true,
        "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
        "trusted": false,
        "id": "1YbIjlgrhFsz"
      },
      "source": [
        "## Binary Classification Task: Diabetes Dataset\n",
        "\n",
        "We’ll be using ML techniques learnt uptil now to predict whether a Pima Indian Woman has diabetes or not, based on information about the patient such as blood pressure, body mass index (BMI), age, etc. \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BcQGSOFchFs0"
      },
      "source": [
        "# Introduction\n",
        "\n",
        "Scientists carried out a study to investigate the significance of health-related predictors of diabetes in **Pima Indian Women**. The study population was females (21 years and above) of Pima Indian heritage.\n",
        "\n",
        "The purpose of the study was to find out the factors that are associated with the presence of diabetes in Pima Indians.\n",
        "\n",
        "To find out the reason behind this, we have to first analyze the relationship between different features, such as the number of times a woman was pregnant, their BMI, prevalence of diabetes, etc."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OQIjzjdvhFs1"
      },
      "source": [
        "## Exploratory Data Analysis (EDA) and Statistical Analysis"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RBuD7M7yhFs1"
      },
      "source": [
        "## Import Libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "-61IRwW9hFs2"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "%matplotlib inline\n",
        "\n",
        "sns.set_style('whitegrid')\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5PsuSvHBhFs2"
      },
      "source": [
        "## Importing the dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "su9YeUtjx7Vt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 38
        },
        "outputId": "830efe12-3784-4535-d9a4-779f9d2a6985"
      },
      "source": [
        "# Upload the preprocessed diabetes data CSV file that has been shared with you.\n",
        "# Run this cell, click on the 'Choose files' button and upload the file.\n",
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-f6b049bd-675c-4cac-a0f1-1b23f9929e06\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-f6b049bd-675c-4cac-a0f1-1b23f9929e06\">\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": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "jD3AJ4bMhFs2"
      },
      "source": [
        "diabetes_data = pd.read_csv('/content/preprocessed_diabetes_data (7).csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "QHXBgngihFs3"
      },
      "source": [
        "# View top 10 rows of the Diabetes dataset\n",
        "diabetes_data.head(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sp-JWCiPhFs3"
      },
      "source": [
        "## Identification of variables and data types"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "Dxb4gUfwhFs3"
      },
      "source": [
        "diabetes_data.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5arc6ZbOhFs3"
      },
      "source": [
        "Dataset comprises of 768 observations and 9 fields.\n",
        "\n",
        "The following features have been provided to help us predict whether a person is diabetic or not:\n",
        "\n",
        "* **Pregnancies:** Number of times pregnant\n",
        "* **Glucose:** Plasma glucose concentration over 2 hours in an oral glucose tolerance test. Less than 140 mg/dL is considered normal level of glucose.\n",
        "* **BloodPressure:** Diastolic blood pressure (mm Hg). 120/80 is normal BP level for females above 18 years old.\n",
        "* **SkinThickness:** Triceps skin fold thickness (mm)\n",
        "* **Insulin:** 2-Hour serum insulin (mu U/ml). 16-166 mIU/L is considered the normal level of insulin.\n",
        "* **BMI:** Body mass index (weight in kg/((height in m$)^2$))\n",
        "* **DiabetesPedigreeFunction:** Diabetes pedigree function (a function which scores likelihood of diabetes based on family history)\n",
        "* **Age:** Age (in years)\n",
        "* **Outcome:** Class variable (0 if non-diabetic, 1 if diabetic)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "kKH8cPIBhFs4"
      },
      "source": [
        "# Get the details of each column\n",
        "diabetes_data.describe().T"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6v_JcMPYhFs6"
      },
      "source": [
        "Let us see distribution and also boxplot for outliers of feature \"Pregnancies\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "jh9KHJcEhFs6"
      },
      "source": [
        "fig,axes = plt.subplots(nrows=1,ncols=2,figsize = (8,6))\n",
        "\n",
        "plot00=sns.distplot(diabetes_data['Pregnancies'],ax=axes[0],color='b')\n",
        "axes[0].set_title('Distribution of Pregnancy',fontdict={'fontsize':8})\n",
        "axes[0].set_xlabel('No of Pregnancies')\n",
        "axes[0].set_ylabel('Frequency')\n",
        "plt.tight_layout()\n",
        "\n",
        "\n",
        "plot01=sns.boxplot('Pregnancies',data=diabetes_data,ax=axes[1],orient = 'v', color='r')\n",
        "plt.tight_layout()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UZISBYEz7jwv"
      },
      "source": [
        "## TASK-1 : \n",
        "## Find out the \"Correlation\" between the different attributes present in the data.\n",
        "## Also plot a heatmap (refer Seaborn documentation) for the correlation values obtained."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "diabetes_data.corr()"
      ],
      "metadata": {
        "id": "deFQgd6ZZxdd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PnRYznyBhFs8"
      },
      "source": [
        "<p style=\"font-weight: bold;color:#FF4500\"><b>Observations</b></p>  \n",
        "\n",
        "* From the correlation map you just obtained above, it seems that Insulin is highly correlated with Glucose, BMI and Age. It means that as the values of glucose, BMI and Age increase, the insulin is also increasing. It seems logical also that overweight and elderly people might have a higher level of insulin in their bodies.  \n",
        "\n",
        "* In the same way SkinThickness is highly correlated with BMI."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#TASK 1"
      ],
      "metadata": {
        "id": "T221A6vcy0el"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "os.system(\"wget https://raw.githubusercontent.com/SP9144/FMML_Data/main/Automobile_data.csv\")"
      ],
      "metadata": {
        "id": "p7Y46DnLw7X0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "mzYIJ8YaxLm0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data = pd.read_csv(\"/content/preprocessed_diabetes_data (7).csv\")\n",
        "print(\"Number of data points =\", len(data))\n",
        "data.head()"
      ],
      "metadata": {
        "id": "9aSWob6vxQt8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "data.replace(\"?\", np.nan, inplace = True)\n",
        "data = data.dropna()\n",
        "print(len(data))"
      ],
      "metadata": {
        "id": "LR6bur0_xaiG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "X = data.drop(\"Outcome\", axis = 1)\n",
        "y = pd.to_numeric(data[\"Outcome\"])"
      ],
      "metadata": {
        "id": "gNc6EarrxeB0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns\n",
        "\n",
        "sns.jointplot(x=pd.to_numeric(X[\"Pregnancies\"]), y = y, kind=\"reg\", color = 'green')"
      ],
      "metadata": {
        "id": "ruVklnEtxp52"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lis=[\"Glucose\",\t\"BloodPressure\",\t\"SkinThickness\",\t\"Insulin\",\t\"BMI\"\t,\"DiabetesPedigreeFunction\",\t\"Age\"]\n",
        "for i in lis:\n",
        "  sns.jointplot(x=pd.to_numeric(X[i]), y = y, kind=\"reg\", color = 'cyan')"
      ],
      "metadata": {
        "id": "ZGKg7CrDx_hE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sns.set(rc={'figure.figsize':(10,7)})\n",
        "sns.scatterplot(x=pd.to_numeric(X[\"Glucose\"]), y = y, color = \"red\")"
      ],
      "metadata": {
        "id": "b2-XVdBM0VJl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sns.scatterplot(x=pd.to_numeric(X[\"Pregnancies\"]), y = y, color = \"red\")"
      ],
      "metadata": {
        "id": "hACR2NpB04vD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sns.scatterplot(x=pd.to_numeric(X[\"BloodPressure\"]), y = y, color = \"red\")"
      ],
      "metadata": {
        "id": "IgfMuG2d06qE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sns.scatterplot(x=pd.to_numeric(X[\"SkinThickness\"]), y = y, color = \"red\")"
      ],
      "metadata": {
        "id": "UnIR6W_F1Mfz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sns.scatterplot(x=pd.to_numeric(X[\"Insulin\"]), y = y, color = \"red\")"
      ],
      "metadata": {
        "id": "KW_IMcyY1jqE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sns.scatterplot(x=pd.to_numeric(X[\"BMI\"]), y = y, color = \"red\")"
      ],
      "metadata": {
        "id": "Z9ZVQg_R1rkX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sns.scatterplot(x=pd.to_numeric(X[\"DiabetesPedigreeFunction\"]), y = y, color = \"red\")"
      ],
      "metadata": {
        "id": "ClYhik4Z1yjT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ibQhQ3qihFs-"
      },
      "source": [
        "## Checking  if the data is balanced or imbalanced\n",
        "\n",
        "We can produce a seaborn count plot to check if the output is dominated by one of the classes or not."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "5Vo4IoVfhFs-"
      },
      "source": [
        "plt.figure(figsize=(12,6))\n",
        "sns.countplot(x='Outcome',data=diabetes_data, palette='bright')\n",
        "plt.title(\"Output class distribution\")\n",
        "\n",
        "print(diabetes_data['Outcome'].value_counts())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jsO1fRfGhFs_"
      },
      "source": [
        "<p style=\"font-weight: bold;color:#FF4500\"><b>Observations</b></p>  \n",
        "\n",
        "A total of 768 women were registered in the database. 268 women had diabetes, while 500 women did not have diabetes. \n",
        "\n",
        "The above graph shows that the dataset is biased towards non-diabetic people. The number of non-diabetic people is almost twice the number of diabetic patients."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZLZVGWpUhFs_"
      },
      "source": [
        "## Scatter matrix of data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KqCv0o359ydE"
      },
      "source": [
        "A pair-plot builds on two basic figures, the histogram and the scatter plot. The histogram on the diagonal allows us to see the distribution of a single variable while the scatter plots on the upper and lower triangles show the relationship (or lack thereof) between two variables."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "LXD7RCUjhFs_"
      },
      "source": [
        "## TASK-2: Display a pairplot using Seaborn for the diabetes dataset, with the 'outcome' as the hue. "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#TASK 2"
      ],
      "metadata": {
        "id": "KRw1oMNSBdvb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.pairplot(data=diabetes_data, hue='Outcome')"
      ],
      "metadata": {
        "id": "bEJ2ZiRV1-RD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YyIfVZGz-AVA"
      },
      "source": [
        "## BMI vs Outcome"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "1C9GazEwhFtA"
      },
      "source": [
        "plt.figure(figsize=(12,8))\n",
        "sns.boxplot(x='Outcome', y='BMI',data=diabetes_data, hue='Outcome')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-zeDFUjIhFtA"
      },
      "source": [
        "<p style=\"font-weight: bold;color:#FF4500\"><b>Observations</b></p>\n",
        "\n",
        "It is surprising that the median BMI does not significanty change as the number of pregnancies increases. Those who tested positive for diabetes had higher BMIs than those who did not. However,there is not a very large difference between the medians.\n",
        "\n",
        "BMI might be higher for women who have had more numbers of pregnancies as well as for those who test positive for diabetes and that the relationship between the pedigree function and the test results will show that those who had a higher pedigree function tested positive and those who had a lower pedigree function tested negative."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5TVSVM2qhFtA"
      },
      "source": [
        "## Pedigree function vs Diabetes "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "96GqOonO-bkE"
      },
      "source": [
        "## TASK-3: Display a boxplot between the Pedigree function and Diabetes."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#TASK 3"
      ],
      "metadata": {
        "id": "hziybPzvBa-1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.boxplot(x=X[\"DiabetesPedigreeFunction\"],data=diabetes_data).set_title('boxplot between the Pedigree function and Diabetes')"
      ],
      "metadata": {
        "id": "P6APvNFz3PXf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EnRxDLryhFtB"
      },
      "source": [
        "<p style=\"font-weight: bold;color:#FF4500\"><b>Observations</b></p>\n",
        "This graph more clearly shows the relationship between the pedigree function and the test results that the women got for diabetes. Since those who tested positive have a higher median and more high outliers, it is clear that the pedigree function does in fact, accurately help estimate the test results for diabetes. It shows that diabetes does follow genetics so those whose ancestors suffered from it have a higher risk of getting the disease themselves as well. Both test results show many outliers yet the outliers for those who tested negative seem to have lower pedigree functions than those who tested positive. This indicates that the genetic component is likely to contribute more to the emergence of diabetes in the Pima Indians and their offspring."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Haicc9d0hFtB"
      },
      "source": [
        "## Pregnancy vs Diabetes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u_x36kL5_Iyt"
      },
      "source": [
        "## TASK-4: Display a boxplot between the number of Pregnancies and Diabetes."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#TASK 4"
      ],
      "metadata": {
        "id": "8z5ktCePBYye"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.boxplot(x=X[\"Pregnancies\"],data=diabetes_data).set_title('boxplot between Pregnancies and Diabetes')"
      ],
      "metadata": {
        "id": "6Oe9mndO4v8l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IR5LPr3phFtC"
      },
      "source": [
        "<p style=\"font-weight: bold;color:#FF4500\"><b>Observations</b></p>\n",
        "\n",
        "The average number of pregnancies is higher in diabetic as compared to non-diabetic women."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dmvNQIOFhFtC"
      },
      "source": [
        "## Prevalence of Diabetes vs BMI\n",
        "\n",
        "Let's try to find out the prevalence of diabetes and its relation to their BMI. Please note that the range of normal BMI is 18.5 to 25."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "3kCMTdmGhFtC"
      },
      "source": [
        "normalBMIData = diabetes_data[(diabetes_data['BMI'] >= 18.5) & (diabetes_data['BMI'] <= 25)]\n",
        "normalBMIData['Outcome'].value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "Z--JC25ehFtC"
      },
      "source": [
        "notNormalBMIData = diabetes_data[(diabetes_data['BMI'] < 18.5) | (diabetes_data['BMI'] > 25)]\n",
        "notNormalBMIData['Outcome'].value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "wrdJR1wkhFtD"
      },
      "source": [
        "plt.figure(figsize=(12,8))\n",
        "sns.boxplot(x='Outcome', y='BMI',data=notNormalBMIData)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u8D7KzjphFtD"
      },
      "source": [
        "<p style=\"font-weight: bold;color:#FF4500\"><b>Observations</b></p>\n",
        "\n",
        "The Body Mass Index (BMI) shows a significant association with the occurrence of diabetes.  \n",
        "The interquartile range for the women who tested positive reaches a higher BMI than the IQR for those who tested negative. Therefore, women could have higher BMIs and not be outliers if they tested positive as opposed to negative, showing that more women who tested positive did, in fact, have higher BMIs than those who tested negative. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f1_nVeb8hFtD"
      },
      "source": [
        "## Age vs Diabetes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-s-5gavNAf0m"
      },
      "source": [
        "## TASK-5: Display a boxplot between Age and Diabetes."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#TASK 5"
      ],
      "metadata": {
        "id": "0SvBUKRDBV4U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sns.boxplot(x=X[\"Age\"],data=diabetes_data).set_title('boxplot between the Pedigree function and Diabetes')"
      ],
      "metadata": {
        "id": "cmrTwgOP5lX1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "skK67P9mhFtE"
      },
      "source": [
        "<p style=\"font-weight: bold;color:#FF4500\"><b>Observations</b></p>  \n",
        "\n",
        "A significant relation can be seen between the age distribution and occurrence of diabetes. Women at age group > 31 years were at higher risk of getting diabetes in comparison to the younger age group."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MKo2iJYbhFtE"
      },
      "source": [
        "# The Importance of Standardizing Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "DfNzaXgJhFtF"
      },
      "source": [
        "unchanged_data = diabetes_data.drop('Outcome',axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "69yA8N2xp8w-"
      },
      "source": [
        "unchanged_data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "j78tjiVkhFtG"
      },
      "source": [
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e_lGuVYyI0wj"
      },
      "source": [
        "from sklearn.metrics import classification_report,confusion_matrix\n",
        "from sklearn.neighbors import KNeighborsClassifier"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j0AsnKb-hFtI"
      },
      "source": [
        "# Choosing a K Value\n",
        "Let's go ahead and use the elbow method to pick a good K Value!\n",
        "\n",
        "*Create a for loop that trains various KNN models with different k values, then keep track of the error_rate for each of these models with a list.*"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#TASK 6"
      ],
      "metadata": {
        "id": "zeuSeMh2BPxL"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WBciXF40Jzoh"
      },
      "source": [
        "##########################\n",
        "##########################\n",
        "\n",
        "## TASK-6 : Complete the lines of code wherever marked as [REQUIRED] in this cell.\n",
        "\n",
        "##########################\n",
        "##########################\n",
        "\n",
        "\n",
        "def plot_KNN_error_rate(xdata,ydata):\n",
        "  error_rate = []\n",
        "  test_scores = []\n",
        "  train_scores = []\n",
        "\n",
        "  X_train, X_test, y_train, y_test = train_test_split(xdata, ydata, test_size=0.33, random_state=95)\n",
        "  \n",
        "  for i in range(1,40):\n",
        "      knn = KNeighborsClassifier(n_neighbors=i)\n",
        "      knn.fit(X_train, y_train)\n",
        "      pred_i = knn.predict(X_test)\n",
        "      \n",
        "      error_rate.append(np.mean(pred_i != y_test))\n",
        "      train_scores.append(knn.score(X_train,y_train))\n",
        "      test_scores.append(knn.score(X_test,y_test))\n",
        "\n",
        "  plt.figure(figsize=(12,8))\n",
        "  plt.plot(range(1,40),error_rate,color='blue', linestyle='dashed', marker='o',\n",
        "          markerfacecolor='red', markersize=10)\n",
        "  plt.title('Error Rate vs. K Value')\n",
        "  plt.xlabel('K')\n",
        "  plt.ylabel('Error Rate')\n",
        "  print()\n",
        "  ## score that comes from testing on the same datapoints that were used for training\n",
        "  max_train_score = max(train_scores)\n",
        "  train_scores_ind = [i for i, v in enumerate(train_scores) if v == max_train_score]\n",
        "  print('Max train score {} % and k = {}'.format(max_train_score*100,list(map(lambda x: x+1, train_scores_ind))))\n",
        "  print()\n",
        "  ## score that comes from testing on the datapoints that were split in the beginning to be used for testing solely\n",
        "  max_test_score = max(test_scores)\n",
        "  test_scores_ind = [i for i, v in enumerate(test_scores) if v == max_test_score]\n",
        "  print('Max test score {} % and k = {}'.format(max_test_score*100,list(map(lambda x: x+1, test_scores_ind))))\n",
        "\n",
        "  return test_scores"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xm8uwN1ZC7hp"
      },
      "source": [
        "#@title Answer to Task-6. Refer to and run this only if you are unable to complete the task in the previous cell.\n",
        "def plot_KNN_error_rate(xdata,ydata):\n",
        "  error_rate = []\n",
        "  test_scores = []\n",
        "  train_scores = []\n",
        "\n",
        "  X_train, X_test, y_train, y_test = train_test_split(xdata, ydata, test_size=0.3, random_state=101)\n",
        "  \n",
        "  for i in range(1,40):\n",
        "      knn = KNeighborsClassifier(n_neighbors=i)\n",
        "      knn.fit(X_train, y_train)\n",
        "      pred_i = knn.predict(X_test)\n",
        "      \n",
        "      error_rate.append(np.mean(pred_i != y_test))\n",
        "      train_scores.append(knn.score(X_train,y_train))\n",
        "      test_scores.append(knn.score(X_test,y_test))\n",
        "\n",
        "  plt.figure(figsize=(12,8))\n",
        "  plt.plot(range(1,40),error_rate,color='blue', linestyle='dashed', marker='o',\n",
        "          markerfacecolor='red', markersize=10)\n",
        "  plt.title('Error Rate vs. K Value')\n",
        "  plt.xlabel('K')\n",
        "  plt.ylabel('Error Rate')\n",
        "  print()\n",
        "  ## score that comes from testing on the same datapoints that were used for training\n",
        "  max_train_score = max(train_scores)\n",
        "  train_scores_ind = [i for i, v in enumerate(train_scores) if v == max_train_score]\n",
        "  print('Max train score {} % and k = {}'.format(max_train_score*100,list(map(lambda x: x+1, train_scores_ind))))\n",
        "  print()\n",
        "  ## score that comes from testing on the datapoints that were split in the beginning to be used for testing solely\n",
        "  max_test_score = max(test_scores)\n",
        "  test_scores_ind = [i for i, v in enumerate(test_scores) if v == max_test_score]\n",
        "  print('Max test score {} % and k = {}'.format(max_test_score*100,list(map(lambda x: x+1, test_scores_ind))))\n",
        "\n",
        "  return test_scores"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Rj96qrEOKVw"
      },
      "source": [
        "unchanged_test_scores = plot_KNN_error_rate(unchanged_data,diabetes_data['Outcome'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5OZFsqr1hFtE"
      },
      "source": [
        "## Standardize the Variables\n",
        "Standardization (also called z-score normalization) is the process of putting different variables on the same scale. Standardization transforms your data such that the resulting distribution has a mean of 0 and a standard deviation of 1. \n",
        "\n",
        "$$ Z = {X - \\mu \\over \\sigma}$$ \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "kgZdXekchFtE"
      },
      "source": [
        "from sklearn.preprocessing import StandardScaler\n",
        "scaler = StandardScaler()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "0hyAXJ_vhFtF"
      },
      "source": [
        "scaler.fit(diabetes_data.drop('Outcome',axis=1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y6dMR3MJFFdA"
      },
      "source": [
        "scaled_data = scaler.transform(diabetes_data.drop('Outcome',axis=1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "OFANLGLuhFtF"
      },
      "source": [
        "df_feat = pd.DataFrame(scaled_data,columns=diabetes_data.columns[:-1])\n",
        "df_feat.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fwuhzRarQRRQ"
      },
      "source": [
        "scaled_test_scores = plot_KNN_error_rate(scaled_data,diabetes_data['Outcome'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WoBBRF8FRkrV"
      },
      "source": [
        "## Comparing Accuracy before and after Standardization"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M9uVwaaBQ7RE"
      },
      "source": [
        "plt.figure(figsize=(20,8))\n",
        "plt.title('Accuracy vs. K Value')\n",
        "sns.lineplot(range(1,40),unchanged_test_scores,marker='o',label='Unscaled data test score')\n",
        "sns.lineplot(range(1,40),scaled_test_scores,marker='o',label='Scaled data test Score')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nJeZOI-KFKTU"
      },
      "source": [
        "## TASK-7: Refer to MinMax Scaler provided in scikit-learn.  \n",
        "## Use MinMax scaling on the dataset, and see the performance of KNN on this minmax-scaled dataset."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#TASK 7"
      ],
      "metadata": {
        "id": "sHEQbBkgBAUU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Accuracy=[x*100 for x in unchanged_test_scores]\n",
        "max_acc=max(Accuracy)\n",
        "print(max_acc)\n",
        "print(Accuracy)\n"
      ],
      "metadata": {
        "id": "z0A8_rp67s3G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "neighbors=[]\n",
        "for i in range(1,40):\n",
        "  neighbors.append(i)"
      ],
      "metadata": {
        "id": "OrfW_s9e_83z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QBzds9_dFmgz"
      },
      "source": [
        "## TASK-8: Use K-Fold cross validation on all the above classification experiments and present an analysis of the results you obtain."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#TASK 8"
      ],
      "metadata": {
        "id": "O1ff-0uvBI_L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Accuracy=[x*100 for x in unchanged_test_scores]\n",
        "plt.figure(figsize = (10, 6))\n",
        "plt.plot(neighbors, Accuracy)\n",
        "plt.xlabel('Number of neighbors')\n",
        "plt.ylabel('Mean Cross-validation accuracy in %')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "a57pcWv2-NBM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "max_acc = max(Accuracy)\n",
        "optimal_ks = [neighbors[i] for i, j in enumerate(Accuracy) if j == max_acc]\n",
        "print(optimal_ks)"
      ],
      "metadata": {
        "id": "IpDtUMtTA17F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mj2xeXZthFtM"
      },
      "source": [
        "# Conclusion\n",
        "\n",
        "From the data analysis we carried out, it seems that there is some form of an association between BMI, number of pregnancies, pedigree function, and the test results for diabetes.\n",
        "\n",
        "As for the classification tasks, the standardized data yields much better results than the unscaled data over most of the K-values considered, thus indicating the importance of standardizing data in Machine Learning problems."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aubGhsTSjJLM"
      },
      "source": [
        "# References"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XehDqRkdjN0_"
      },
      "source": [
        "https://www.kaggle.com/dktalaicha/diabetes-prediction-by-knn"
      ]
    }
  ]
}