{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "852cdcd2",
   "metadata": {},
   "source": [
    "# Assignment 2: Machine Learning Pipeline for Diabetes Prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89b5eabd",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## 1. Introduction\n",
    "This notebook implements a machine learning pipeline for the Pima Indians Diabetes Database. The steps include:\n",
    "1. Loading the dataset.\n",
    "2. Handling missing values.\n",
    "3. Applying machine learning models (Logistic Regression, Random Forest, SVM, KNN) with Grid Search optimization.\n",
    "4. Evaluating model performance.\n",
    "5. Applying feature selection methods (SelectKBest, RFE).\n",
    "6. Applying machine learning models to the selected features and evaluating performance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa2a07d2",
   "metadata": {},
   "source": [
    "## 2. Load Data and Initial Exploration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7fe3edb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First 5 rows of the dataset:\n",
      "   6  148  72  35    0  33.6  0.627  50  1\n",
      "0  1   85  66  29    0  26.6  0.351  31  0\n",
      "1  8  183  64   0    0  23.3  0.672  32  1\n",
      "2  1   89  66  23   94  28.1  0.167  21  0\n",
      "3  0  137  40  35  168  43.1  2.288  33  1\n",
      "4  5  116  74   0    0  25.6  0.201  30  0\n",
      "\n",
      "Dataset Info:\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 767 entries, 0 to 766\n",
      "Data columns (total 9 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   6       767 non-null    int64  \n",
      " 1   148     767 non-null    int64  \n",
      " 2   72      767 non-null    int64  \n",
      " 3   35      767 non-null    int64  \n",
      " 4   0       767 non-null    int64  \n",
      " 5   33.6    767 non-null    float64\n",
      " 6   0.627   767 non-null    float64\n",
      " 7   50      767 non-null    int64  \n",
      " 8   1       767 non-null    int64  \n",
      "dtypes: float64(2), int64(7)\n",
      "memory usage: 54.1 KB\n",
      "\n",
      "Dataset Description:\n",
      "                6         148          72          35           0        33.6  \\\n",
      "count  767.000000  767.000000  767.000000  767.000000  767.000000  767.000000   \n",
      "mean     3.842243  120.859192   69.101695   20.517601   79.903520   31.990482   \n",
      "std      3.370877   31.978468   19.368155   15.954059  115.283105    7.889091   \n",
      "min      0.000000    0.000000    0.000000    0.000000    0.000000    0.000000   \n",
      "25%      1.000000   99.000000   62.000000    0.000000    0.000000   27.300000   \n",
      "50%      3.000000  117.000000   72.000000   23.000000   32.000000   32.000000   \n",
      "75%      6.000000  140.000000   80.000000   32.000000  127.500000   36.600000   \n",
      "max     17.000000  199.000000  122.000000   99.000000  846.000000   67.100000   \n",
      "\n",
      "            0.627          50           1  \n",
      "count  767.000000  767.000000  767.000000  \n",
      "mean     0.471674   33.219035    0.348110  \n",
      "std      0.331497   11.752296    0.476682  \n",
      "min      0.078000   21.000000    0.000000  \n",
      "25%      0.243500   24.000000    0.000000  \n",
      "50%      0.371000   29.000000    0.000000  \n",
      "75%      0.625000   41.000000    1.000000  \n",
      "max      2.420000   81.000000    1.000000  \n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# Define column names based on dataset description\n",
    "column_names = [\"Pregnancies\", \"Glucose\", \"BloodPressure\", \"SkinThickness\", \"Insulin\", \"BMI\", \"DiabetesPedigreeFunction\", \"Age\", \"Outcome\"]\n",
    "\n",
    "# Load the dataset\n",
    "#file_path = \"diabetes.csv\" # Assuming the csv is in the same directory\n",
    "#df = pd.read_csv(file_path, header=None, names=column_names)\n",
    "df = pd.read_csv(r'C:\\Assignment\\diabetes.csv')\n",
    "\n",
    "# Display the first few rows and basic info\n",
    "print(\"First 5 rows of the dataset:\")\n",
    "print(df.head())\n",
    "print(\"\\nDataset Info:\")\n",
    "df.info()\n",
    "print(\"\\nDataset Description:\")\n",
    "print(df.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cde46bd",
   "metadata": {},
   "source": [
    "## 3. Handle Missing Values\n",
    "The dataset description mentions that certain zero values in columns like Glucose, BloodPressure, SkinThickness, Insulin, and BMI are physiologically impossible and likely represent missing data. We will replace these with NaN and then impute them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9f892219",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Columns in the dataset:\n",
      "Index(['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin',\n",
      "       'BMI', 'DiabetesPedigreeFunction', 'Age', 'Outcome'],\n",
      "      dtype='object')\n",
      "\n",
      "Replacing 0 values with NaN in columns: ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']\n",
      "\n",
      "Missing values count after replacing 0s:\n",
      "Pregnancies                   0\n",
      "Glucose                       5\n",
      "BloodPressure                35\n",
      "SkinThickness               227\n",
      "Insulin                     374\n",
      "BMI                          11\n",
      "DiabetesPedigreeFunction      0\n",
      "Age                           0\n",
      "Outcome                       0\n",
      "dtype: int64\n",
      "\n",
      "Imputing missing values using median...\n",
      "\n",
      "Missing values count after imputation:\n",
      "Pregnancies                 0\n",
      "Glucose                     0\n",
      "BloodPressure               0\n",
      "SkinThickness               0\n",
      "Insulin                     0\n",
      "BMI                         0\n",
      "DiabetesPedigreeFunction    0\n",
      "Age                         0\n",
      "Outcome                     0\n",
      "dtype: int64\n",
      "\n",
      "First 5 rows of the cleaned dataset:\n",
      "   Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
      "0            6    148.0           72.0           35.0    125.0  33.6   \n",
      "1            1     85.0           66.0           29.0    125.0  26.6   \n",
      "2            8    183.0           64.0           29.0    125.0  23.3   \n",
      "3            1     89.0           66.0           23.0     94.0  28.1   \n",
      "4            0    137.0           40.0           35.0    168.0  43.1   \n",
      "\n",
      "   DiabetesPedigreeFunction  Age  Outcome  \n",
      "0                     0.627   50        1  \n",
      "1                     0.351   31        0  \n",
      "2                     0.672   32        1  \n",
      "3                     0.167   21        0  \n",
      "4                     2.288   33        1  \n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# Define the correct column names\n",
    "column_names = [\"Pregnancies\", \"Glucose\", \"BloodPressure\", \"SkinThickness\",\n",
    "                \"Insulin\", \"BMI\", \"DiabetesPedigreeFunction\", \"Age\", \"Outcome\"]\n",
    "\n",
    "# Load the dataset with correct headers\n",
    "df = pd.read_csv(r'C:\\Assignment\\diabetes.csv', header=None, names=column_names)\n",
    "\n",
    "# Print columns to verify\n",
    "print(\"Columns in the dataset:\")\n",
    "print(df.columns)\n",
    "\n",
    "# Identify columns where 0 means missing value\n",
    "columns_with_zeros_as_missing = [\"Glucose\", \"BloodPressure\", \"SkinThickness\", \"Insulin\", \"BMI\"]\n",
    "\n",
    "# Replace 0 with NaN\n",
    "print(f\"\\nReplacing 0 values with NaN in columns: {columns_with_zeros_as_missing}\")\n",
    "df[columns_with_zeros_as_missing] = df[columns_with_zeros_as_missing].replace(0, np.nan)\n",
    "\n",
    "# Check missing values\n",
    "print(\"\\nMissing values count after replacing 0s:\")\n",
    "print(df.isnull().sum())\n",
    "\n",
    "# Fill missing values with median\n",
    "print(\"\\nImputing missing values using median...\")\n",
    "for col in columns_with_zeros_as_missing:\n",
    "    median_val = df[col].median()\n",
    "    df[col] = df[col].fillna(median_val)\n",
    "\n",
    "# Confirm no missing values left\n",
    "print(\"\\nMissing values count after imputation:\")\n",
    "print(df.isnull().sum())\n",
    "\n",
    "# Show the first 5 rows\n",
    "print(\"\\nFirst 5 rows of the cleaned dataset:\")\n",
    "print(df.head())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a736434f",
   "metadata": {},
   "source": [
    "## 4. Data Splitting and Scaling\n",
    "Before applying machine learning models, we need to split the data into training and testing sets and scale the features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8e25fa38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Columns in the dataset:\n",
      "Index(['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin',\n",
      "       'BMI', 'DiabetesPedigreeFunction', 'Age', 'Outcome'],\n",
      "      dtype='object')\n",
      "\n",
      "Replacing 0 values with NaN in columns: ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']\n",
      "\n",
      "Missing values count after replacing 0s:\n",
      "Pregnancies                   0\n",
      "Glucose                       5\n",
      "BloodPressure                35\n",
      "SkinThickness               227\n",
      "Insulin                     374\n",
      "BMI                          11\n",
      "DiabetesPedigreeFunction      0\n",
      "Age                           0\n",
      "Outcome                       0\n",
      "dtype: int64\n",
      "\n",
      "Imputing missing values using median...\n",
      "\n",
      "Missing values count after imputation:\n",
      "Pregnancies                 0\n",
      "Glucose                     0\n",
      "BloodPressure               0\n",
      "SkinThickness               0\n",
      "Insulin                     0\n",
      "BMI                         0\n",
      "DiabetesPedigreeFunction    0\n",
      "Age                         0\n",
      "Outcome                     0\n",
      "dtype: int64\n",
      "\n",
      "Training set shape: (614, 8), (614,)\n",
      "Testing set shape: (154, 8), (154,)\n",
      "\n",
      "Features scaled using StandardScaler.\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Step 1: Define correct column names\n",
    "column_names = [\"Pregnancies\", \"Glucose\", \"BloodPressure\", \"SkinThickness\",\n",
    "                \"Insulin\", \"BMI\", \"DiabetesPedigreeFunction\", \"Age\", \"Outcome\"]\n",
    "\n",
    "# Step 2: Load the dataset correctly (since CSV has no header)\n",
    "df = pd.read_csv(r'C:\\Assignment\\diabetes.csv', header=None, names=column_names)\n",
    "\n",
    "# Step 3: Confirm columns are loaded correctly\n",
    "print(\"Columns in the dataset:\")\n",
    "print(df.columns)\n",
    "\n",
    "# Step 4: Handle missing values\n",
    "# Identify columns where 0 means missing\n",
    "columns_with_zeros_as_missing = [\"Glucose\", \"BloodPressure\", \"SkinThickness\", \"Insulin\", \"BMI\"]\n",
    "\n",
    "# Replace 0 with NaN\n",
    "print(f\"\\nReplacing 0 values with NaN in columns: {columns_with_zeros_as_missing}\")\n",
    "df[columns_with_zeros_as_missing] = df[columns_with_zeros_as_missing].replace(0, np.nan)\n",
    "\n",
    "# Check missing values\n",
    "print(\"\\nMissing values count after replacing 0s:\")\n",
    "print(df.isnull().sum())\n",
    "\n",
    "# Fill missing values using median\n",
    "print(\"\\nImputing missing values using median...\")\n",
    "for col in columns_with_zeros_as_missing:\n",
    "    median_val = df[col].median()\n",
    "    df[col] = df[col].fillna(median_val)\n",
    "\n",
    "# Confirm no missing values left\n",
    "print(\"\\nMissing values count after imputation:\")\n",
    "print(df.isnull().sum())\n",
    "\n",
    "# Step 5: Split features (X) and target (y)\n",
    "X = df.drop(\"Outcome\", axis=1)\n",
    "y = df[\"Outcome\"]\n",
    "\n",
    "# Step 6: Split into training and testing sets (80% train, 20% test)\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, y, test_size=0.2, random_state=42, stratify=y\n",
    ")\n",
    "\n",
    "print(f\"\\nTraining set shape: {X_train.shape}, {y_train.shape}\")\n",
    "print(f\"Testing set shape: {X_test.shape}, {y_test.shape}\")\n",
    "\n",
    "# Step 7: Scale the features\n",
    "scaler = StandardScaler()\n",
    "X_train_scaled = scaler.fit_transform(X_train)\n",
    "X_test_scaled = scaler.transform(X_test)\n",
    "\n",
    "print(\"\\nFeatures scaled using StandardScaler.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3485efad",
   "metadata": {},
   "source": [
    "## 5. Apply Machine Learning Models with Grid Search\n",
    "We will apply Logistic Regression, Random Forest, SVM, and KNN models using GridSearchCV to find the best hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e786ecfd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Applying Models with Grid Search ---\n",
      "\n",
      "Training Logistic Regression...\n",
      "Best Parameters for Logistic Regression: {'C': 10, 'penalty': 'l1'}\n",
      "Best Cross-Validation Accuracy for Logistic Regression: 0.7818\n",
      "Test Set Accuracy for Logistic Regression: 0.7078\n",
      "\n",
      "Training Random Forest...\n",
      "Best Parameters for Random Forest: {'max_depth': None, 'min_samples_split': 5, 'n_estimators': 100}\n",
      "Best Cross-Validation Accuracy for Random Forest: 0.7720\n",
      "Test Set Accuracy for Random Forest: 0.7338\n",
      "\n",
      "Training SVM...\n",
      "Best Parameters for SVM: {'C': 1, 'gamma': 'scale', 'kernel': 'rbf'}\n",
      "Best Cross-Validation Accuracy for SVM: 0.7688\n",
      "Test Set Accuracy for SVM: 0.7403\n",
      "\n",
      "Training KNN...\n",
      "Best Parameters for KNN: {'metric': 'manhattan', 'n_neighbors': 9, 'weights': 'uniform'}\n",
      "Best Cross-Validation Accuracy for KNN: 0.7622\n",
      "Test Set Accuracy for KNN: 0.7662\n",
      "\n",
      "--- Model Training and Evaluation Complete ---\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "\n",
    "# Define models and their parameter grids\n",
    "models_and_params = {\n",
    "    \"Logistic Regression\": {\n",
    "        \"model\": LogisticRegression(solver='liblinear', random_state=42),\n",
    "        \"params\": {\n",
    "            'C': [0.01, 0.1, 1, 10, 100],\n",
    "            'penalty': ['l1', 'l2']\n",
    "        }\n",
    "    },\n",
    "    \"Random Forest\": {\n",
    "        \"model\": RandomForestClassifier(random_state=42),\n",
    "        \"params\": {\n",
    "            'n_estimators': [50, 100, 200],\n",
    "            'max_depth': [None, 10, 20],\n",
    "            'min_samples_split': [2, 5]\n",
    "        }\n",
    "    },\n",
    "    \"SVM\": {\n",
    "        \"model\": SVC(probability=True, random_state=42),\n",
    "        \"params\": {\n",
    "            'C': [0.1, 1, 10],\n",
    "            'gamma': ['scale', 'auto'],\n",
    "            'kernel': ['rbf'] # Reduced kernel options for faster grid search\n",
    "        }\n",
    "    },\n",
    "    \"KNN\": {\n",
    "        \"model\": KNeighborsClassifier(),\n",
    "        \"params\": {\n",
    "            'n_neighbors': [3, 5, 7, 9],\n",
    "            'weights': ['uniform', 'distance'],\n",
    "            'metric': ['euclidean', 'manhattan']\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "results = {}\n",
    "\n",
    "print(\"\\n--- Applying Models with Grid Search ---\")\n",
    "\n",
    "for model_name, mp in models_and_params.items():\n",
    "    print(f\"\\nTraining {model_name}...\")\n",
    "    grid_search = GridSearchCV(mp[\"model\"], mp[\"params\"], cv=5, scoring=\"accuracy\", n_jobs=-1)\n",
    "    grid_search.fit(X_train_scaled, y_train)\n",
    "\n",
    "    best_model = grid_search.best_estimator_\n",
    "    y_pred = best_model.predict(X_test_scaled)\n",
    "\n",
    "    accuracy = accuracy_score(y_test, y_pred)\n",
    "    report = classification_report(y_test, y_pred)\n",
    "\n",
    "    results[model_name] = {\n",
    "        \"best_params\": grid_search.best_params_,\n",
    "        \"best_score (CV Accuracy)\": grid_search.best_score_,\n",
    "        \"test_accuracy\": accuracy,\n",
    "        \"classification_report\": report,\n",
    "        \"best_estimator\": best_model\n",
    "    }\n",
    "\n",
    "    print(f\"Best Parameters for {model_name}: {grid_search.best_params_}\")\n",
    "    print(f\"Best Cross-Validation Accuracy for {model_name}: {grid_search.best_score_:.4f}\")\n",
    "    print(f\"Test Set Accuracy for {model_name}: {accuracy:.4f}\")\n",
    "    # print(f\"Classification Report for {model_name}:\\n{report}\") # Optional: uncomment to print full report during run\n",
    "\n",
    "print(\"\\n--- Model Training and Evaluation Complete ---\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee64bb90",
   "metadata": {},
   "source": [
    "## 6. Feature Selection Methods\n",
    "We will apply two feature selection methods:\n",
    "1. SelectKBest with f_classif (ANOVA F-value)\n",
    "2. Recursive Feature Elimination (RFE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f863f044",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.feature_selection import SelectKBest, f_classif, RFE\n",
    "\n",
    "# Ensure plots are displayed inline in Jupyter\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ed7891e",
   "metadata": {},
   "source": [
    "### 6.1 Method 1: SelectKBest with f_classif (ANOVA F-value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "586c7484",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Feature Selection Method 1: SelectKBest with f_classif ---\n",
      "\n",
      "Feature scores from SelectKBest:\n",
      "Glucose: 217.7648\n",
      "BMI: 74.1978\n",
      "Insulin: 39.3879\n",
      "Age: 37.6296\n",
      "SkinThickness: 35.5352\n",
      "Pregnancies: 27.7229\n",
      "BloodPressure: 21.2949\n",
      "DiabetesPedigreeFunction: 17.1947\n",
      "\n",
      "Top 4 features selected: Glucose, Insulin, BMI, Age\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"\\n--- Feature Selection Method 1: SelectKBest with f_classif ---\")\n",
    "\n",
    "# Apply SelectKBest with f_classif\n",
    "selector = SelectKBest(f_classif, k=4)  # Select top 4 features\n",
    "X_train_selectkbest_data = selector.fit_transform(X_train_scaled, y_train)\n",
    "X_test_selectkbest_data = selector.transform(X_test_scaled)\n",
    "\n",
    "# Get the selected feature indices\n",
    "selected_indices = selector.get_support(indices=True)\n",
    "selected_features = X.columns[selected_indices]\n",
    "\n",
    "# Get the scores\n",
    "scores = selector.scores_\n",
    "feature_scores = list(zip(X.columns, scores))\n",
    "feature_scores.sort(key=lambda x: x[1], reverse=True)\n",
    "\n",
    "print(\"\\nFeature scores from SelectKBest:\")\n",
    "for feature, score in feature_scores:\n",
    "    print(f\"{feature}: {score:.4f}\")\n",
    "\n",
    "print(f\"\\nTop {len(selected_features)} features selected: {', '.join(selected_features)}\")\n",
    "\n",
    "# Visualize feature importance\n",
    "plt.figure(figsize=(10, 6))\n",
    "sns.barplot(x=[x[0] for x in feature_scores], y=[x[1] for x in feature_scores])\n",
    "plt.title('Feature Importance (SelectKBest with f_classif)')\n",
    "plt.xticks(rotation=45, ha='right')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "127fc499",
   "metadata": {},
   "source": [
    "### 6.2 Method 2: Recursive Feature Elimination (RFE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "cc12b661",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Feature Selection Method 2: Recursive Feature Elimination (RFE) ---\n",
      "\n",
      "Feature ranking from RFE (lower is better):\n",
      "Pregnancies: 1\n",
      "Glucose: 1\n",
      "BMI: 1\n",
      "DiabetesPedigreeFunction: 1\n",
      "Age: 2\n",
      "Insulin: 3\n",
      "BloodPressure: 4\n",
      "SkinThickness: 5\n",
      "\n",
      "Top 4 features selected by RFE: Pregnancies, Glucose, BMI, DiabetesPedigreeFunction\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"\\n--- Feature Selection Method 2: Recursive Feature Elimination (RFE) ---\")\n",
    "\n",
    "# Use the best model from grid search for RFE (using Logistic Regression)\n",
    "best_lr_model = results[\"Logistic Regression\"][\"best_estimator\"]\n",
    "\n",
    "# Apply RFE with the best logistic regression model\n",
    "rfe = RFE(estimator=best_lr_model, n_features_to_select=4, step=1)\n",
    "rfe.fit(X_train_scaled, y_train)\n",
    "\n",
    "# Get the selected feature indices\n",
    "rfe_selected_indices = [i for i, selected in enumerate(rfe.support_) if selected]\n",
    "rfe_selected_features = X.columns[rfe_selected_indices]\n",
    "\n",
    "# Get the feature ranking\n",
    "feature_ranking = list(zip(X.columns, rfe.ranking_))\n",
    "feature_ranking.sort(key=lambda x: x[1])\n",
    "\n",
    "print(\"\\nFeature ranking from RFE (lower is better):\")\n",
    "for feature, rank in feature_ranking:\n",
    "    print(f\"{feature}: {rank}\")\n",
    "\n",
    "print(f\"\\nTop {len(rfe_selected_features)} features selected by RFE: {', '.join(rfe_selected_features)}\")\n",
    "\n",
    "# Visualize feature ranking (lower is better)\n",
    "plt.figure(figsize=(10, 6))\n",
    "sns.barplot(x=[x[0] for x in feature_ranking], y=[x[1] for x in feature_ranking])\n",
    "plt.title('Feature Ranking (RFE) - Lower is Better')\n",
    "plt.xticks(rotation=45, ha='right')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Create datasets with selected features for both methods\n",
    "X_train_selectkbest = X_train_scaled[:, selected_indices]\n",
    "X_test_selectkbest = X_test_scaled[:, selected_indices]\n",
    "\n",
    "X_train_rfe = X_train_scaled[:, rfe_selected_indices]\n",
    "X_test_rfe = X_test_scaled[:, rfe_selected_indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8f93225",
   "metadata": {},
   "source": [
    "### 6.3 Compare Selected Features from Both Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "25ea5dd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Comparing Selected Features from Both Methods ---\n",
      "SelectKBest selected: Glucose, Insulin, BMI, Age\n",
      "RFE selected: Pregnancies, Glucose, BMI, DiabetesPedigreeFunction\n",
      "\n",
      "Common features selected by both methods: Glucose, BMI\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n--- Comparing Selected Features from Both Methods ---\")\n",
    "print(f\"SelectKBest selected: {', '.join(selected_features)}\")\n",
    "print(f\"RFE selected: {', '.join(rfe_selected_features)}\")\n",
    "\n",
    "# Find common features\n",
    "common_features = set(selected_features).intersection(set(rfe_selected_features))\n",
    "print(f\"\\nCommon features selected by both methods: {', '.join(common_features)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eaf5950",
   "metadata": {},
   "source": [
    "## 7. Apply Machine Learning Models to Selected Features\n",
    "We will apply the same machine learning models to the datasets with selected features from both methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4801735c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Applying Models to Selected Features ---\n",
      "\n",
      "=== Evaluating models on features selected by SelectKBest ===\n",
      "\n",
      "Training Logistic Regression on selected features...\n",
      "Test Set Accuracy for Logistic Regression: 0.7143\n",
      "\n",
      "Training Random Forest on selected features...\n",
      "Test Set Accuracy for Random Forest: 0.7403\n",
      "\n",
      "Training SVM on selected features...\n",
      "Test Set Accuracy for SVM: 0.7078\n",
      "\n",
      "Training KNN on selected features...\n",
      "Test Set Accuracy for KNN: 0.7403\n",
      "\n",
      "=== Evaluating models on features selected by RFE ===\n",
      "\n",
      "Training Logistic Regression on selected features...\n",
      "Test Set Accuracy for Logistic Regression: 0.6948\n",
      "\n",
      "Training Random Forest on selected features...\n",
      "Test Set Accuracy for Random Forest: 0.6948\n",
      "\n",
      "Training SVM on selected features...\n",
      "Test Set Accuracy for SVM: 0.7208\n",
      "\n",
      "Training KNN on selected features...\n",
      "Test Set Accuracy for KNN: 0.7403\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n--- Applying Models to Selected Features ---\")\n",
    "\n",
    "# Function to evaluate models on selected features\n",
    "def evaluate_models_on_selected_features(X_train_selected, X_test_selected, feature_method_name):\n",
    "    print(f\"\\n=== Evaluating models on features selected by {feature_method_name} ===\")\n",
    "    \n",
    "    selected_results = {}\n",
    "    \n",
    "    for model_name, mp in models_and_params.items():\n",
    "        print(f\"\\nTraining {model_name} on selected features...\")\n",
    "        \n",
    "        # Use the best parameters found earlier\n",
    "        best_params = results[model_name][\"best_params\"]\n",
    "        \n",
    "        # Re-initialize model with best params\n",
    "        if model_name == \"Logistic Regression\":\n",
    "            model = LogisticRegression(solver='liblinear', random_state=42, **best_params)\n",
    "        elif model_name == \"Random Forest\":\n",
    "            model = RandomForestClassifier(random_state=42, **best_params)\n",
    "        elif model_name == \"SVM\":\n",
    "            # SVM needs kernel specified, which might not be in best_params if it was fixed\n",
    "            kernel = best_params.get('kernel', 'rbf') # Default to rbf if not found\n",
    "            temp_params = best_params.copy()\n",
    "            if 'kernel' in temp_params: del temp_params['kernel'] # Remove kernel if present\n",
    "            model = SVC(probability=True, random_state=42, kernel=kernel, **temp_params)\n",
    "        elif model_name == \"KNN\":\n",
    "            model = KNeighborsClassifier(**best_params)\n",
    "        \n",
    "        # Train and evaluate the model\n",
    "        model.fit(X_train_selected, y_train)\n",
    "        y_pred = model.predict(X_test_selected)\n",
    "        \n",
    "        accuracy = accuracy_score(y_test, y_pred)\n",
    "        report = classification_report(y_test, y_pred)\n",
    "        \n",
    "        selected_results[model_name] = {\n",
    "            \"test_accuracy\": accuracy,\n",
    "            \"classification_report\": report\n",
    "        }\n",
    "        \n",
    "        print(f\"Test Set Accuracy for {model_name}: {accuracy:.4f}\")\n",
    "        # print(f\"Classification Report for {model_name}:\\n{report}\") # Optional\n",
    "    \n",
    "    return selected_results\n",
    "\n",
    "# Evaluate models on features selected by SelectKBest\n",
    "selectkbest_results = evaluate_models_on_selected_features(X_train_selectkbest, X_test_selectkbest, \"SelectKBest\")\n",
    "\n",
    "# Evaluate models on features selected by RFE\n",
    "rfe_results = evaluate_models_on_selected_features(X_train_rfe, X_test_rfe, \"RFE\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "935ae882",
   "metadata": {},
   "source": [
    "## 8. Compare Results: All Features vs. Selected Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "35009558",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Comparing Model Performance: All Features vs. Selected Features ---\n",
      "\n",
      "Accuracy Comparison:\n",
      "                 Model  All Features  SelectKBest Features  RFE Features\n",
      "0  Logistic Regression      0.707792              0.714286      0.694805\n",
      "1        Random Forest      0.733766              0.740260      0.694805\n",
      "2                  SVM      0.740260              0.707792      0.720779\n",
      "3                  KNN      0.766234              0.740260      0.740260\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x700 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"\\n--- Comparing Model Performance: All Features vs. Selected Features ---\")\n",
    "\n",
    "# Create a comparison table\n",
    "comparison_data = []\n",
    "\n",
    "for model_name in models_and_params.keys():\n",
    "    all_features_acc = results[model_name][\"test_accuracy\"]\n",
    "    selectkbest_acc = selectkbest_results[model_name][\"test_accuracy\"]\n",
    "    rfe_acc = rfe_results[model_name][\"test_accuracy\"]\n",
    "    \n",
    "    comparison_data.append({\n",
    "        \"Model\": model_name,\n",
    "        \"All Features\": all_features_acc,\n",
    "        \"SelectKBest Features\": selectkbest_acc,\n",
    "        \"RFE Features\": rfe_acc\n",
    "    })\n",
    "\n",
    "comparison_df = pd.DataFrame(comparison_data)\n",
    "print(\"\\nAccuracy Comparison:\")\n",
    "print(comparison_df)\n",
    "\n",
    "# Visualize the comparison\n",
    "plt.figure(figsize=(12, 7)) # Increased figure size\n",
    "ax = comparison_df.set_index('Model').plot(kind='bar', figsize=(12, 7)) # Pass figsize here too\n",
    "plt.title('Model Accuracy Comparison: All Features vs. Selected Features')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.ylim(0.65, 0.85)  # Adjust as needed\n",
    "plt.xticks(rotation=45, ha='right')\n",
    "plt.legend(title='Feature Set', bbox_to_anchor=(1.05, 1), loc='upper left') # Move legend outside\n",
    "plt.tight_layout(rect=[0, 0, 0.85, 1]) # Adjust layout to prevent legend overlap\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c720bfe",
   "metadata": {},
   "source": [
    "## 9. Conclusion and Findings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b8d0de91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Conclusion and Findings ---\n",
      "Best model using all features: KNN with accuracy 0.7662\n",
      "Best model using SelectKBest features: Random Forest with accuracy 0.7403\n",
      "Best model using RFE features: KNN with accuracy 0.7403\n",
      "\n",
      "Overall best configuration: KNN using All Features features with accuracy 0.7662\n",
      "\n",
      "Feature Selection Summary:\n",
      "SelectKBest selected features: Glucose, Insulin, BMI, Age\n",
      "RFE selected features: Pregnancies, Glucose, BMI, DiabetesPedigreeFunction\n",
      "Common features: Glucose, BMI\n",
      "\n",
      "Average accuracy across all models:\n",
      "Using all features: 0.7370\n",
      "Using SelectKBest features: 0.7256\n",
      "Using RFE features: 0.7127\n",
      "\n",
      "Final Remarks:\n",
      "Using all features provided the best average performance across models.\n",
      "\n",
      "The most important features for diabetes prediction according to both methods include:\n",
      "- Glucose\n",
      "- BMI\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n--- Conclusion and Findings ---\")\n",
    "\n",
    "# Find the best model for each feature set\n",
    "best_all = max([(model, results[model][\"test_accuracy\"]) for model in models_and_params.keys()], key=lambda x: x[1])\n",
    "best_selectkbest = max([(model, selectkbest_results[model][\"test_accuracy\"]) for model in models_and_params.keys()], key=lambda x: x[1])\n",
    "best_rfe = max([(model, rfe_results[model][\"test_accuracy\"]) for model in models_and_params.keys()], key=lambda x: x[1])\n",
    "\n",
    "print(f\"Best model using all features: {best_all[0]} with accuracy {best_all[1]:.4f}\")\n",
    "print(f\"Best model using SelectKBest features: {best_selectkbest[0]} with accuracy {best_selectkbest[1]:.4f}\")\n",
    "print(f\"Best model using RFE features: {best_rfe[0]} with accuracy {best_rfe[1]:.4f}\")\n",
    "\n",
    "# Overall best model\n",
    "all_best = [(\"All Features\", best_all[0], best_all[1]), \n",
    "            (\"SelectKBest\", best_selectkbest[0], best_selectkbest[1]), \n",
    "            (\"RFE\", best_rfe[0], best_rfe[1])]\n",
    "overall_best_config = max(all_best, key=lambda x: x[2])\n",
    "\n",
    "print(f\"\\nOverall best configuration: {overall_best_config[1]} using {overall_best_config[0]} features with accuracy {overall_best_config[2]:.4f}\")\n",
    "\n",
    "# Summary of feature selection\n",
    "print(\"\\nFeature Selection Summary:\")\n",
    "print(f\"SelectKBest selected features: {', '.join(selected_features)}\")\n",
    "print(f\"RFE selected features: {', '.join(rfe_selected_features)}\")\n",
    "print(f\"Common features: {', '.join(common_features)}\")\n",
    "\n",
    "# Impact of feature selection\n",
    "avg_all = sum([results[model][\"test_accuracy\"] for model in models_and_params.keys()]) / len(models_and_params)\n",
    "avg_selectkbest = sum([selectkbest_results[model][\"test_accuracy\"] for model in models_and_params.keys()]) / len(models_and_params)\n",
    "avg_rfe = sum([rfe_results[model][\"test_accuracy\"] for model in models_and_params.keys()]) / len(models_and_params)\n",
    "\n",
    "print(f\"\\nAverage accuracy across all models:\")\n",
    "print(f\"Using all features: {avg_all:.4f}\")\n",
    "print(f\"Using SelectKBest features: {avg_selectkbest:.4f}\")\n",
    "print(f\"Using RFE features: {avg_rfe:.4f}\")\n",
    "\n",
    "# Final remarks\n",
    "print(\"\\nFinal Remarks:\")\n",
    "if avg_selectkbest > avg_all and avg_selectkbest > avg_rfe:\n",
    "    print(\"SelectKBest feature selection provided the best average performance across models.\")\n",
    "elif avg_rfe > avg_all and avg_rfe > avg_selectkbest:\n",
    "    print(\"RFE feature selection provided the best average performance across models.\")\n",
    "elif avg_all > avg_selectkbest and avg_all > avg_rfe:\n",
    "    print(\"Using all features provided the best average performance across models.\")\n",
    "else:\n",
    "    print(\"The average performance was similar across different feature sets.\")\n",
    "\n",
    "print(\"\\nThe most important features for diabetes prediction according to both methods include:\")\n",
    "for feature in common_features:\n",
    "    print(f\"- {feature}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4250e801-d123-497d-a822-44e5b21321c3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}