kidney disease prediction notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dd7d08a2-8891-4fd6-9222-e86a51173bfe",
   "metadata": {},
   "source": [
    "## COMPLETE PROCESS USED FOR PREDICTION IN THIS MODEL \n",
    "\n",
    "### Imports -> Load Dataset -> Data Cleaning -> Fill Missing Values -> Encoding -> Scaling -> Data Balancing -> Train-Test Split -> Train & Evaluate Multiple Classifiers -> Select Best Model -> Save Model & Scaler -> Inference (Prediction on New Data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e532818-7d74-4aec-84be-f4d15e7b8dd3",
   "metadata": {},
   "source": [
    "# Importing the Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ec08b03a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# preprocessing tools\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
    "from sklearn.utils import resample\n",
    "\n",
    "# Classification Models\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "\n",
    "# For model evaluation\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39494aa3-4c5d-479b-a6c7-7dd11c501168",
   "metadata": {},
   "source": [
    "# Loading the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "323690c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>id</th>\n",
       "      <th>age</th>\n",
       "      <th>bp</th>\n",
       "      <th>sg</th>\n",
       "      <th>al</th>\n",
       "      <th>su</th>\n",
       "      <th>rbc</th>\n",
       "      <th>pc</th>\n",
       "      <th>pcc</th>\n",
       "      <th>ba</th>\n",
       "      <th>...</th>\n",
       "      <th>pcv</th>\n",
       "      <th>wc</th>\n",
       "      <th>rc</th>\n",
       "      <th>htn</th>\n",
       "      <th>dm</th>\n",
       "      <th>cad</th>\n",
       "      <th>appet</th>\n",
       "      <th>pe</th>\n",
       "      <th>ane</th>\n",
       "      <th>classification</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>48.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>normal</td>\n",
       "      <td>notpresent</td>\n",
       "      <td>notpresent</td>\n",
       "      <td>...</td>\n",
       "      <td>44</td>\n",
       "      <td>7800</td>\n",
       "      <td>5.2</td>\n",
       "      <td>yes</td>\n",
       "      <td>yes</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>normal</td>\n",
       "      <td>notpresent</td>\n",
       "      <td>notpresent</td>\n",
       "      <td>...</td>\n",
       "      <td>38</td>\n",
       "      <td>6000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>62.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.010</td>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>normal</td>\n",
       "      <td>normal</td>\n",
       "      <td>notpresent</td>\n",
       "      <td>notpresent</td>\n",
       "      <td>...</td>\n",
       "      <td>31</td>\n",
       "      <td>7500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>no</td>\n",
       "      <td>yes</td>\n",
       "      <td>no</td>\n",
       "      <td>poor</td>\n",
       "      <td>no</td>\n",
       "      <td>yes</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>48.0</td>\n",
       "      <td>70.0</td>\n",
       "      <td>1.005</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>normal</td>\n",
       "      <td>abnormal</td>\n",
       "      <td>present</td>\n",
       "      <td>notpresent</td>\n",
       "      <td>...</td>\n",
       "      <td>32</td>\n",
       "      <td>6700</td>\n",
       "      <td>3.9</td>\n",
       "      <td>yes</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>poor</td>\n",
       "      <td>yes</td>\n",
       "      <td>yes</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>51.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.010</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>normal</td>\n",
       "      <td>normal</td>\n",
       "      <td>notpresent</td>\n",
       "      <td>notpresent</td>\n",
       "      <td>...</td>\n",
       "      <td>35</td>\n",
       "      <td>7300</td>\n",
       "      <td>4.6</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 26 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   id   age    bp     sg   al   su     rbc        pc         pcc          ba  \\\n",
       "0   0  48.0  80.0  1.020  1.0  0.0     NaN    normal  notpresent  notpresent   \n",
       "1   1   7.0  50.0  1.020  4.0  0.0     NaN    normal  notpresent  notpresent   \n",
       "2   2  62.0  80.0  1.010  2.0  3.0  normal    normal  notpresent  notpresent   \n",
       "3   3  48.0  70.0  1.005  4.0  0.0  normal  abnormal     present  notpresent   \n",
       "4   4  51.0  80.0  1.010  2.0  0.0  normal    normal  notpresent  notpresent   \n",
       "\n",
       "   ...  pcv    wc   rc  htn   dm  cad appet   pe  ane classification  \n",
       "0  ...   44  7800  5.2  yes  yes   no  good   no   no            ckd  \n",
       "1  ...   38  6000  NaN   no   no   no  good   no   no            ckd  \n",
       "2  ...   31  7500  NaN   no  yes   no  poor   no  yes            ckd  \n",
       "3  ...   32  6700  3.9  yes   no   no  poor  yes  yes            ckd  \n",
       "4  ...   35  7300  4.6   no   no   no  good   no   no            ckd  \n",
       "\n",
       "[5 rows x 26 columns]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(\"kidney_disease.csv\")\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b784a0ea",
   "metadata": {},
   "source": [
    "# Short definitions for each important feature\n",
    "\n",
    "    'age': 'Patient age (years)',\n",
    "    \n",
    "    'bp': 'Blood pressure (mm/Hg)',\n",
    "    \n",
    "    'sg': 'Urine specific gravity',\n",
    "    \n",
    "    'al': 'Albumin in urine (0–5)',\n",
    "    \n",
    "    'hemo': 'Hemoglobin level (g/dL)',\n",
    "    \n",
    "    'sc': 'Serum creatinine (mg/dL)',\n",
    "    \n",
    "    'htn': 'Hypertension (yes/no)',\n",
    "    \n",
    "    'dm': 'Diabetes mellitus (yes/no)',\n",
    "    \n",
    "    'cad': 'Coronary artery disease (yes/no)',\n",
    "    \n",
    "    'appet': 'Appetite status (good/poor)',\n",
    "    \n",
    "    'pc': 'Pus cell status (normal/abnormal)',\n",
    "    \n",
    "    'classification': 'CKD diagnosis (ckd/notckd)'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9b372659",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>age</th>\n",
       "      <th>bp</th>\n",
       "      <th>sg</th>\n",
       "      <th>al</th>\n",
       "      <th>hemo</th>\n",
       "      <th>sc</th>\n",
       "      <th>htn</th>\n",
       "      <th>dm</th>\n",
       "      <th>cad</th>\n",
       "      <th>appet</th>\n",
       "      <th>pc</th>\n",
       "      <th>classification</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>1.0</td>\n",
       "      <td>15.4</td>\n",
       "      <td>1.2</td>\n",
       "      <td>yes</td>\n",
       "      <td>yes</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>normal</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11.3</td>\n",
       "      <td>0.8</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>normal</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>62.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.010</td>\n",
       "      <td>2.0</td>\n",
       "      <td>9.6</td>\n",
       "      <td>1.8</td>\n",
       "      <td>no</td>\n",
       "      <td>yes</td>\n",
       "      <td>no</td>\n",
       "      <td>poor</td>\n",
       "      <td>normal</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>48.0</td>\n",
       "      <td>70.0</td>\n",
       "      <td>1.005</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11.2</td>\n",
       "      <td>3.8</td>\n",
       "      <td>yes</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>poor</td>\n",
       "      <td>abnormal</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>51.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.010</td>\n",
       "      <td>2.0</td>\n",
       "      <td>11.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>normal</td>\n",
       "      <td>ckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>395</th>\n",
       "      <td>55.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.7</td>\n",
       "      <td>0.5</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>normal</td>\n",
       "      <td>notckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>396</th>\n",
       "      <td>42.0</td>\n",
       "      <td>70.0</td>\n",
       "      <td>1.025</td>\n",
       "      <td>0.0</td>\n",
       "      <td>16.5</td>\n",
       "      <td>1.2</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>normal</td>\n",
       "      <td>notckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>397</th>\n",
       "      <td>12.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.8</td>\n",
       "      <td>0.6</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>normal</td>\n",
       "      <td>notckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>398</th>\n",
       "      <td>17.0</td>\n",
       "      <td>60.0</td>\n",
       "      <td>1.025</td>\n",
       "      <td>0.0</td>\n",
       "      <td>14.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>normal</td>\n",
       "      <td>notckd</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>399</th>\n",
       "      <td>58.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.025</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.8</td>\n",
       "      <td>1.1</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>no</td>\n",
       "      <td>good</td>\n",
       "      <td>normal</td>\n",
       "      <td>notckd</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>400 rows × 12 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      age    bp     sg   al  hemo   sc  htn   dm cad appet        pc  \\\n",
       "0    48.0  80.0  1.020  1.0  15.4  1.2  yes  yes  no  good    normal   \n",
       "1     7.0  50.0  1.020  4.0  11.3  0.8   no   no  no  good    normal   \n",
       "2    62.0  80.0  1.010  2.0   9.6  1.8   no  yes  no  poor    normal   \n",
       "3    48.0  70.0  1.005  4.0  11.2  3.8  yes   no  no  poor  abnormal   \n",
       "4    51.0  80.0  1.010  2.0  11.6  1.4   no   no  no  good    normal   \n",
       "..    ...   ...    ...  ...   ...  ...  ...  ...  ..   ...       ...   \n",
       "395  55.0  80.0  1.020  0.0  15.7  0.5   no   no  no  good    normal   \n",
       "396  42.0  70.0  1.025  0.0  16.5  1.2   no   no  no  good    normal   \n",
       "397  12.0  80.0  1.020  0.0  15.8  0.6   no   no  no  good    normal   \n",
       "398  17.0  60.0  1.025  0.0  14.2  1.0   no   no  no  good    normal   \n",
       "399  58.0  80.0  1.025  0.0  15.8  1.1   no   no  no  good    normal   \n",
       "\n",
       "    classification  \n",
       "0              ckd  \n",
       "1              ckd  \n",
       "2              ckd  \n",
       "3              ckd  \n",
       "4              ckd  \n",
       "..             ...  \n",
       "395         notckd  \n",
       "396         notckd  \n",
       "397         notckd  \n",
       "398         notckd  \n",
       "399         notckd  \n",
       "\n",
       "[400 rows x 12 columns]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "important_columns = ['age', 'bp', 'sg', 'al', 'hemo', 'sc','htn','dm','cad','appet','pc','classification']\n",
    "df = df[important_columns]\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "479caeea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cad\n",
      "no     364\n",
      "yes     34\n",
      "Name: count, dtype: int64\n",
      "dm\n",
      "no     261\n",
      "yes    137\n",
      "Name: count, dtype: int64\n",
      "classification\n",
      "ckd       250\n",
      "notckd    150\n",
      "Name: count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Clean the dataset\n",
    "for col in df.select_dtypes(include='object').columns:\n",
    "    df[col] = df[col].str.strip().str.replace('\\t', '', regex=True)  # Remove leading and trailing whitespace, and replace any tab characters with an empty string in the column\n",
    "\n",
    "print(df['cad'].value_counts()) # Print the counts of unique values in the 'cad' column\n",
    "print(df['dm'].value_counts()) # Print the counts of unique values in the 'dm' column\n",
    "print(df['classification'].value_counts()) # Print the counts of unique values in the 'classification' column"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fae4c7b8",
   "metadata": {},
   "source": [
    "# Data Cleaning and Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "875c42b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "age                9\n",
       "bp                12\n",
       "sg                47\n",
       "al                46\n",
       "hemo              52\n",
       "sc                17\n",
       "htn                2\n",
       "dm                 2\n",
       "cad                2\n",
       "appet              1\n",
       "pc                65\n",
       "classification     0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.isnull().sum() # Check for missing values in the DataFrame and count the number of null entries for each column"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "393923d5",
   "metadata": {},
   "source": [
    "# Filling Missing Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "36fa73a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:2: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['age'].fillna(df['age'].median(), inplace=True)         # Numerical → median\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:3: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['bp'].fillna(df['bp'].median(), inplace=True)           # Numerical → median\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:4: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['sg'].fillna(df['sg'].mode()[0], inplace=True)          # Categorical (discrete numeric) → mode\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:5: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['al'].fillna(df['al'].mode()[0], inplace=True)          # Categorical (discrete numeric) → mode\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:6: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['hemo'].fillna(df['hemo'].median(), inplace=True)       # Numerical → median\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:7: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['sc'].fillna(df['sc'].median(), inplace=True)           # Numerical → median\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:8: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['htn'].fillna(df['htn'].mode()[0], inplace=True)        # Categorical (yes/no) → mode\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:9: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['dm'].fillna(df['dm'].mode()[0], inplace=True)          # Categorical (yes/no) → mode\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:10: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['cad'].fillna(df['cad'].mode()[0], inplace=True)        # Categorical (yes/no) → mode\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:11: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['appet'].fillna(df['appet'].mode()[0], inplace=True)    # Categorical → mode\n",
      "C:\\Users\\Jigyasa\\AppData\\Local\\Temp\\ipykernel_14372\\955012896.py:12: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  df['pc'].fillna(df['pc'].mode()[0], inplace=True)          # Categorical → mode\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "age               0\n",
       "bp                0\n",
       "sg                0\n",
       "al                0\n",
       "hemo              0\n",
       "sc                0\n",
       "htn               0\n",
       "dm                0\n",
       "cad               0\n",
       "appet             0\n",
       "pc                0\n",
       "classification    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fill missing values with appropriate methods\n",
    "df['age'].fillna(df['age'].median(), inplace=True)         # Numerical → median\n",
    "df['bp'].fillna(df['bp'].median(), inplace=True)           # Numerical → median\n",
    "df['sg'].fillna(df['sg'].mode()[0], inplace=True)          # Categorical (discrete numeric) → mode\n",
    "df['al'].fillna(df['al'].mode()[0], inplace=True)          # Categorical (discrete numeric) → mode\n",
    "df['hemo'].fillna(df['hemo'].median(), inplace=True)       # Numerical → median\n",
    "df['sc'].fillna(df['sc'].median(), inplace=True)           # Numerical → median\n",
    "df['htn'].fillna(df['htn'].mode()[0], inplace=True)        # Categorical (yes/no) → mode\n",
    "df['dm'].fillna(df['dm'].mode()[0], inplace=True)          # Categorical (yes/no) → mode\n",
    "df['cad'].fillna(df['cad'].mode()[0], inplace=True)        # Categorical (yes/no) → mode\n",
    "df['appet'].fillna(df['appet'].mode()[0], inplace=True)    # Categorical → mode\n",
    "df['pc'].fillna(df['pc'].mode()[0], inplace=True)          # Categorical → mode\n",
    "\n",
    "df.isnull().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d49da72",
   "metadata": {},
   "source": [
    "# Encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fb083ff-e88b-4ed2-b325-ca91dca4f3e6",
   "metadata": {},
   "source": [
    "### Encoding is the process of transforming categorical variables (which contain non-numeric data) into a numerical format that can be effectively utilized by machine learning algorithms. This is necessary because many algorithms require numerical input. Common techniques include:\n",
    "\n",
    "### Label Encoding: Assigns a unique integer to each category.\n",
    "### One-Hot Encoding: Creates binary columns for each category, indicating the presence (1) or absence (0) of each category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1765338d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pc\n",
       "normal      324\n",
       "abnormal     76\n",
       "Name: count, dtype: int64"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['pc'].value_counts() # Count and display the number of unique occurrences for each value in the 'pc' column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "a59bea1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>age</th>\n",
       "      <th>bp</th>\n",
       "      <th>sg</th>\n",
       "      <th>al</th>\n",
       "      <th>hemo</th>\n",
       "      <th>sc</th>\n",
       "      <th>htn</th>\n",
       "      <th>dm</th>\n",
       "      <th>cad</th>\n",
       "      <th>appet</th>\n",
       "      <th>pc</th>\n",
       "      <th>classification</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>48.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>1.0</td>\n",
       "      <td>15.4</td>\n",
       "      <td>1.2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11.3</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>62.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.010</td>\n",
       "      <td>2.0</td>\n",
       "      <td>9.6</td>\n",
       "      <td>1.8</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>48.0</td>\n",
       "      <td>70.0</td>\n",
       "      <td>1.005</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11.2</td>\n",
       "      <td>3.8</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>51.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.010</td>\n",
       "      <td>2.0</td>\n",
       "      <td>11.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>395</th>\n",
       "      <td>55.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.7</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>396</th>\n",
       "      <td>42.0</td>\n",
       "      <td>70.0</td>\n",
       "      <td>1.025</td>\n",
       "      <td>0.0</td>\n",
       "      <td>16.5</td>\n",
       "      <td>1.2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>397</th>\n",
       "      <td>12.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.020</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.8</td>\n",
       "      <td>0.6</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>398</th>\n",
       "      <td>17.0</td>\n",
       "      <td>60.0</td>\n",
       "      <td>1.025</td>\n",
       "      <td>0.0</td>\n",
       "      <td>14.2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>399</th>\n",
       "      <td>58.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>1.025</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.8</td>\n",
       "      <td>1.1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>400 rows × 12 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      age    bp     sg   al  hemo   sc  htn  dm  cad  appet  pc  \\\n",
       "0    48.0  80.0  1.020  1.0  15.4  1.2    1   1    0      1   1   \n",
       "1     7.0  50.0  1.020  4.0  11.3  0.8    0   0    0      1   1   \n",
       "2    62.0  80.0  1.010  2.0   9.6  1.8    0   1    0      0   1   \n",
       "3    48.0  70.0  1.005  4.0  11.2  3.8    1   0    0      0   0   \n",
       "4    51.0  80.0  1.010  2.0  11.6  1.4    0   0    0      1   1   \n",
       "..    ...   ...    ...  ...   ...  ...  ...  ..  ...    ...  ..   \n",
       "395  55.0  80.0  1.020  0.0  15.7  0.5    0   0    0      1   1   \n",
       "396  42.0  70.0  1.025  0.0  16.5  1.2    0   0    0      1   1   \n",
       "397  12.0  80.0  1.020  0.0  15.8  0.6    0   0    0      1   1   \n",
       "398  17.0  60.0  1.025  0.0  14.2  1.0    0   0    0      1   1   \n",
       "399  58.0  80.0  1.025  0.0  15.8  1.1    0   0    0      1   1   \n",
       "\n",
       "     classification  \n",
       "0                 1  \n",
       "1                 1  \n",
       "2                 1  \n",
       "3                 1  \n",
       "4                 1  \n",
       "..              ...  \n",
       "395               0  \n",
       "396               0  \n",
       "397               0  \n",
       "398               0  \n",
       "399               0  \n",
       "\n",
       "[400 rows x 12 columns]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert 'htn' column values from 'yes'/'no' to 1/0\n",
    "df['htn'] = df['htn'].map({'yes': 1, \"no\": 0})\n",
    "\n",
    "# Convert 'dm' column values from 'yes'/'no' to 1/0\n",
    "df['dm'] = df['dm'].map({'yes': 1, \"no\": 0})\n",
    "\n",
    "# Convert 'cad' column values from 'yes'/'no' to 1/0\n",
    "df['cad'] = df['cad'].map({'yes': 1, \"no\": 0})\n",
    "\n",
    "# Convert 'appet' column values from 'good'/'poor' to 1/0\n",
    "df['appet'] = df['appet'].map({'good': 1, \"poor\": 0})\n",
    "\n",
    "# Convert 'pc' column values from 'normal'/'abnormal' to 1/0\n",
    "df['pc'] = df['pc'].map({'normal': 1, \"abnormal\": 0})\n",
    "\n",
    "# Convert 'classification' column values from 'ckd'/'notckd' to 1/0\n",
    "df['classification'] = df['classification'].map({'ckd': 1, \"notckd\": 0})\n",
    "\n",
    "# Display the updated DataFrame with the mapped values\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa543eac",
   "metadata": {},
   "source": [
    "# Scaling: Normalization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f65060ed-ed8b-4f00-8311-0f279ad7bc51",
   "metadata": {},
   "source": [
    "### Scaling refers to the process of normalizing or standardizing numerical features to ensure they are on a similar scale. \n",
    "### This helps improve the performance and convergence of machine learning algorithms, especially those sensitive to the scale of input data. \n",
    "### Common scaling techniques include:\n",
    "\n",
    "### Min-Max Scaling: Rescales features to a fixed range, typically 0 to 1.\n",
    "###    scaled_value= (x−min)/(max−min)\n",
    "\n",
    "### Standardization (Z-score normalization): Transforms features to have a mean of 0 and a standard deviation of 1.\n",
    "###    standardized_value= (x−mean)/standard deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "bcdf087a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>age</th>\n",
       "      <th>bp</th>\n",
       "      <th>sg</th>\n",
       "      <th>al</th>\n",
       "      <th>hemo</th>\n",
       "      <th>sc</th>\n",
       "      <th>htn</th>\n",
       "      <th>dm</th>\n",
       "      <th>cad</th>\n",
       "      <th>appet</th>\n",
       "      <th>pc</th>\n",
       "      <th>classification</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.522727</td>\n",
       "      <td>0.230769</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.836735</td>\n",
       "      <td>0.010582</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.056818</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.557823</td>\n",
       "      <td>0.005291</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.681818</td>\n",
       "      <td>0.230769</td>\n",
       "      <td>0.25</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.442177</td>\n",
       "      <td>0.018519</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.522727</td>\n",
       "      <td>0.153846</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.551020</td>\n",
       "      <td>0.044974</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.556818</td>\n",
       "      <td>0.230769</td>\n",
       "      <td>0.25</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.578231</td>\n",
       "      <td>0.013228</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        age        bp    sg   al      hemo        sc  htn  dm  cad  appet  pc  \\\n",
       "0  0.522727  0.230769  0.75  0.2  0.836735  0.010582    1   1    0      1   1   \n",
       "1  0.056818  0.000000  0.75  0.8  0.557823  0.005291    0   0    0      1   1   \n",
       "2  0.681818  0.230769  0.25  0.4  0.442177  0.018519    0   1    0      0   1   \n",
       "3  0.522727  0.153846  0.00  0.8  0.551020  0.044974    1   0    0      0   0   \n",
       "4  0.556818  0.230769  0.25  0.4  0.578231  0.013228    0   0    0      1   1   \n",
       "\n",
       "   classification  \n",
       "0               1  \n",
       "1               1  \n",
       "2               1  \n",
       "3               1  \n",
       "4               1  "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# Select numeric columns to normalize; these columns will be scaled to a range of [0, 1]\n",
    "numeric_cols = ['age', 'bp', 'sg', 'al', 'hemo', 'sc']\n",
    "\n",
    "# Initialize the MinMaxScaler, which scales data to a specified range\n",
    "scaler = MinMaxScaler()\n",
    "\n",
    "# Fit the scaler to the numeric columns and transform their values,\n",
    "# thus replacing the original values with their scaled versions\n",
    "df[numeric_cols] = scaler.fit_transform(df[numeric_cols])\n",
    "\n",
    "# Display the first few rows of the updated DataFrame with normalized numeric values\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0a21cf2",
   "metadata": {},
   "source": [
    "# Data Balancing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cba40a8-8c9f-4488-aba3-d9cdfe8c27cf",
   "metadata": {},
   "source": [
    "### Data balancing refers to techniques used to address class imbalance in datasets, where one class is significantly underrepresented compared to others. \n",
    "### Imbalanced datasets can lead to biased model predictions. \n",
    "\n",
    "### In this example, the `SMOTE` (Synthetic Minority Over-sampling Technique) class from the `imblearn` library is utilized to create synthetic samples for the minority class, effectively balancing the distribution between classes. \n",
    "### After applying SMOTE, `X_balanced` and `y_balanced` contain the resampled datasets, ensuring that both classes have a more equitable number of samples for better model training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ec621f1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "# Separate the features (X) from the target variable (y)\n",
    "# Drop the 'classification' column from the DataFrame to create the feature set\n",
    "X = df.drop('classification', axis=1)\n",
    "\n",
    "# Assign the 'classification' column as the target variable\n",
    "y = df['classification']\n",
    "\n",
    "# Initialize the SMOTE (Synthetic Minority Over-sampling Technique) class,\n",
    "# with a specified random_state for reproducibility of results\n",
    "smote = SMOTE(random_state=42)\n",
    "\n",
    "# Apply SMOTE to the feature set (X) and target (y) to create a balanced dataset\n",
    "# SMOTE generates synthetic samples for the minority class to balance class distribution\n",
    "X_balanced, y_balanced = smote.fit_resample(X, y)\n",
    "\n",
    "# Now, X_balanced and y_balanced contain the resampled (balanced) datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d607b59c",
   "metadata": {},
   "source": [
    "# Train Test Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "97770eb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train shape: (400, 11)\n",
      "Test shape: (100, 11)\n"
     ]
    }
   ],
   "source": [
    "# Split into train and test sets (80% train, 20% test)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_balanced, y_balanced, test_size=0.2, random_state=42)\n",
    "\n",
    "# Check the shape\n",
    "print(\"Train shape:\", X_train.shape)\n",
    "print(\"Test shape:\", X_test.shape)\n",
    "\n",
    "# Initialize the MinMaxScaler\n",
    "scaler = MinMaxScaler()\n",
    "\n",
    "# FIT the scaler ONLY on the TRAINING data's numeric columns\n",
    "scaler.fit(X_train[numeric_cols])\n",
    "\n",
    "# Transform the TRAINING data using the fitted scaler\n",
    "X_train[numeric_cols] = scaler.transform(X_train[numeric_cols])\n",
    "\n",
    "# Transform the TESTING data using the FITTED scaler\n",
    "X_test[numeric_cols] = scaler.transform(X_test[numeric_cols])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9048775",
   "metadata": {},
   "source": [
    "# Training, Testing Multiple Classifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "4b6bb99c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================================================\n",
      "Model: Logistic Regression\n",
      "Accuracy: 0.96\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.93      1.00      0.96        54\n",
      "           1       1.00      0.91      0.95        46\n",
      "\n",
      "    accuracy                           0.96       100\n",
      "   macro avg       0.97      0.96      0.96       100\n",
      "weighted avg       0.96      0.96      0.96       100\n",
      "\n",
      "Confusion Matrix:\n",
      " [[54  0]\n",
      " [ 4 42]]\n",
      "==================================================\n",
      "Model: Support Vector Classifier\n",
      "Accuracy: 0.97\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.95      1.00      0.97        54\n",
      "           1       1.00      0.93      0.97        46\n",
      "\n",
      "    accuracy                           0.97       100\n",
      "   macro avg       0.97      0.97      0.97       100\n",
      "weighted avg       0.97      0.97      0.97       100\n",
      "\n",
      "Confusion Matrix:\n",
      " [[54  0]\n",
      " [ 3 43]]\n",
      "==================================================\n",
      "Model: Random Forest Classifier\n",
      "Accuracy: 1.0\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        54\n",
      "           1       1.00      1.00      1.00        46\n",
      "\n",
      "    accuracy                           1.00       100\n",
      "   macro avg       1.00      1.00      1.00       100\n",
      "weighted avg       1.00      1.00      1.00       100\n",
      "\n",
      "Confusion Matrix:\n",
      " [[54  0]\n",
      " [ 0 46]]\n",
      "==================================================\n",
      "Model: K Nearest Neighbors\n",
      "Accuracy: 0.97\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.95      1.00      0.97        54\n",
      "           1       1.00      0.93      0.97        46\n",
      "\n",
      "    accuracy                           0.97       100\n",
      "   macro avg       0.97      0.97      0.97       100\n",
      "weighted avg       0.97      0.97      0.97       100\n",
      "\n",
      "Confusion Matrix:\n",
      " [[54  0]\n",
      " [ 3 43]]\n",
      "==================================================\n",
      "Model: Decision Tree Classifier\n",
      "Accuracy: 0.99\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      1.00      0.99        54\n",
      "           1       1.00      0.98      0.99        46\n",
      "\n",
      "    accuracy                           0.99       100\n",
      "   macro avg       0.99      0.99      0.99       100\n",
      "weighted avg       0.99      0.99      0.99       100\n",
      "\n",
      "Confusion Matrix:\n",
      " [[54  0]\n",
      " [ 1 45]]\n",
      "==================================================\n",
      "Model: Gaussian Naive Bayes\n",
      "Accuracy: 0.96\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.93      1.00      0.96        54\n",
      "           1       1.00      0.91      0.95        46\n",
      "\n",
      "    accuracy                           0.96       100\n",
      "   macro avg       0.97      0.96      0.96       100\n",
      "weighted avg       0.96      0.96      0.96       100\n",
      "\n",
      "Confusion Matrix:\n",
      " [[54  0]\n",
      " [ 4 42]]\n",
      "==================================================\n",
      "Model: AdaBoost Classifier\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jigyasa\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\ensemble\\_weight_boosting.py:527: FutureWarning: The SAMME.R algorithm (the default) is deprecated and will be removed in 1.6. Use the SAMME algorithm to circumvent this warning.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 1.0\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        54\n",
      "           1       1.00      1.00      1.00        46\n",
      "\n",
      "    accuracy                           1.00       100\n",
      "   macro avg       1.00      1.00      1.00       100\n",
      "weighted avg       1.00      1.00      1.00       100\n",
      "\n",
      "Confusion Matrix:\n",
      " [[54  0]\n",
      " [ 0 46]]\n",
      "==================================================\n",
      "Model: Gradient Boosting Classifier\n",
      "Accuracy: 0.99\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      1.00      0.99        54\n",
      "           1       1.00      0.98      0.99        46\n",
      "\n",
      "    accuracy                           0.99       100\n",
      "   macro avg       0.99      0.99      0.99       100\n",
      "weighted avg       0.99      0.99      0.99       100\n",
      "\n",
      "Confusion Matrix:\n",
      " [[54  0]\n",
      " [ 1 45]]\n"
     ]
    }
   ],
   "source": [
    "# Define models\n",
    "models = {\n",
    "    \"Logistic Regression\": LogisticRegression(),\n",
    "    \"Support Vector Classifier\": SVC(),\n",
    "    \"Random Forest Classifier\": RandomForestClassifier(),\n",
    "    \"K Nearest Neighbors\": KNeighborsClassifier(),\n",
    "    \"Decision Tree Classifier\": DecisionTreeClassifier(),\n",
    "    \"Gaussian Naive Bayes\": GaussianNB(),\n",
    "    \"AdaBoost Classifier\": AdaBoostClassifier(),\n",
    "    \"Gradient Boosting Classifier\": GradientBoostingClassifier(),\n",
    "}\n",
    "\n",
    "# Train and evaluate each model\n",
    "for name, model in models.items():\n",
    "    print(\"=\"*50)\n",
    "    print(\"Model:\", name)\n",
    "    # Train the model\n",
    "    model.fit(X_train, y_train)\n",
    "    \n",
    "    # Predict on test set\n",
    "    y_pred = model.predict(X_test)\n",
    "    \n",
    "    # Calculate metrics\n",
    "    accuracy = accuracy_score(y_test, y_pred)\n",
    "    classification_rep = classification_report(y_test, y_pred)\n",
    "    conf_matrix = confusion_matrix(y_test, y_pred)\n",
    "    \n",
    "    # Print metrics\n",
    "    print(\"Accuracy:\", accuracy)\n",
    "    print(\"Classification Report:\\n\", classification_rep)\n",
    "    print(\"Confusion Matrix:\\n\", conf_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efe5abdf-42ce-42f9-8c4f-c1172b6b03b9",
   "metadata": {},
   "source": [
    "## Selecting Best Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d1b3d5fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "confusion matrix \n",
      ":  [[54  0]\n",
      " [ 1 45]]\n",
      "classification report \n",
      ":                precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      1.00      0.99        54\n",
      "           1       1.00      0.98      0.99        46\n",
      "\n",
      "    accuracy                           0.99       100\n",
      "   macro avg       0.99      0.99      0.99       100\n",
      "weighted avg       0.99      0.99      0.99       100\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model_gbc = GradientBoostingClassifier()\n",
    "\n",
    "model_gbc.fit(X_train,y_train)\n",
    "\n",
    "y_pred = model_gbc.predict(X_test)\n",
    "\n",
    "\n",
    "\n",
    "print(\"confusion matrix \\n: \", confusion_matrix(y_test,y_pred))\n",
    "print(\"classification report \\n: \", classification_report(y_test, y_pred))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3fdc1ed",
   "metadata": {},
   "source": [
    "# Saving Model, Encoder, Scaler for production"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "3923b8d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import os\n",
    "\n",
    "# Create the 'models' directory if it does not exist\n",
    "os.makedirs('models', exist_ok=True)\n",
    "\n",
    "pickle.dump(scaler, open(\"models/scaler.pkl\",'wb'))\n",
    "pickle.dump(model_gbc,open(\"models/model_gbc.pkl\",'wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9881d1b2",
   "metadata": {},
   "source": [
    "# Inference (Prediction on new data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "2f19eb38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Patient has Chronic Kidney Disease\n"
     ]
    }
   ],
   "source": [
    "# Load the encoder, scaler, and trained model from saved files\n",
    "scaler = pickle.load(open(\"models/scaler.pkl\", 'rb'))  # Load the scaler\n",
    "model_gbc = pickle.load(open(\"models/model_gbc.pkl\", 'rb'))  # Load the trained model\n",
    "\n",
    "def predict_chronic_disease(age, bp, sg, al, hemo, sc, htn, dm, cad, appet, pc):\n",
    "    # Create a DataFrame with input variables, following the correct order\n",
    "    df_dict = {\n",
    "        'age': [age],\n",
    "        'bp': [bp],\n",
    "        'sg': [sg],\n",
    "        'al': [al],\n",
    "        'hemo': [hemo],\n",
    "        'sc': [sc],\n",
    "        'htn': [htn],\n",
    "        'dm': [dm],\n",
    "        'cad': [cad],\n",
    "        'appet': [appet],\n",
    "        'pc': [pc]\n",
    "    }\n",
    "    df = pd.DataFrame(df_dict)\n",
    "\n",
    "    # Encode the categorical columns\n",
    "    df['htn'] = df['htn'].map({'yes':1, \"no\":0})\n",
    "    df['dm'] = df['dm'].map({'yes':1, \"no\":0})\n",
    "    df['cad'] = df['cad'].map({'yes':1, \"no\":0})\n",
    "    df['appet'] = df['appet'].map({'good':1, \"poor\":0})\n",
    "    df['pc'] = df['pc'].map({'normal':1, \"abnormal\":0})\n",
    "\n",
    "    # Scale the numeric columns using the previously fitted scaler\n",
    "    numeric_cols = ['age', 'bp', 'sg', 'al', 'hemo', 'sc']\n",
    "    df[numeric_cols] = scaler.transform(df[numeric_cols])\n",
    "\n",
    "    # Make the prediction\n",
    "    prediction = model_gbc.predict(df)\n",
    "\n",
    "    # Return the predicted class\n",
    "    return prediction[0]\n",
    "\n",
    "# Example usage:\n",
    "result = predict_chronic_disease(age=30, bp=20, sg=1.020, al=1.0, hemo=15.4, sc=1.2, htn=\"no\", dm=\"no\", cad='no', appet='good', pc='normal')\n",
    "\n",
    "# Check the result and print the appropriate message\n",
    "if result == 1:\n",
    "    print(\"The Patient has Chronic Kidney Disease\")\n",
    "else:\n",
    "    print(\"The Patient does not have Chronic Kidney Disease\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "f45de763",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Patient has Chronic Kidney Disease\n"
     ]
    }
   ],
   "source": [
    "# Example usage with higher chance of CKD\n",
    "result = predict_chronic_disease(\n",
    "    age=65,     # Older age is a risk factor for CKD\n",
    "    bp=160,     # High blood pressure\n",
    "    sg=1.030,   # Abnormal specific gravity (suggestive of kidney dysfunction)\n",
    "    al=3.0,     # Elevated albumin in urine (indicative of kidney damage)\n",
    "    hemo=9.0,   # Low hemoglobin (anemia is common in CKD)\n",
    "    sc=2.0,     # Elevated serum creatinine (indicating kidney dysfunction)\n",
    "    htn=\"yes\",   # Hypertension present\n",
    "    dm=\"yes\",       # Diabetes mellitus present\n",
    "    cad=\"yes\",      # Coronary artery disease (cardiovascular issues)\n",
    "    appet=\"poor\",    # Lack of appetite (common in advanced kidney disease)\n",
    "    pc='abnormal'  # Abnormal proteinuria (strong indicator of kidney damage)\n",
    ")\n",
    "\n",
    "# Check the result and print the appropriate message\n",
    "if result == 1:\n",
    "    print(\"The Patient has Chronic Kidney Disease\")\n",
    "else:\n",
    "    print(\"The Patient does not have Chronic Kidney Disease\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "1a091075",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5.1\n"
     ]
    }
   ],
   "source": [
    "import sklearn\n",
    "\n",
    "print(sklearn.__version__)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}