random_forest_classifier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset():\n",
    "    dataset_df1 = pd.read_csv(r\"./Premonsoon/ground_water_quality_2018_pre.csv\")\n",
    "    dataset_df2 = pd.read_csv(r\"./Premonsoon/ground_water_quality_2019_pre.csv\")\n",
    "    dataset_df3 = pd.read_csv(r\"./Premonsoon/ground_water_quality_2020_pre .csv\")\n",
    "    dataset_df4 = pd.read_csv(r\"./Premonsoon/ground_water_quality_2021_pre.csv\")\n",
    "    dataset_df5 = pd.read_csv(r\"./Premonsoon/ground_water_quality_2022_pre.csv\")\n",
    "    dataset_df6 = pd.read_csv(r\"./postmonsoon/ground_water_quality_2018_post.csv\")\n",
    "    dataset_df7 = pd.read_csv(r\"./postmonsoon/ground_water_quality_2019_post.csv\")\n",
    "    dataset_df8 = pd.read_csv(r\"./postmonsoon/ground_water_quality_2020_post.csv\")\n",
    "    dataset_df9 = pd.read_csv(r\"./postmonsoon/ground_water_quality_2021_post.csv\")\n",
    "    dataset_df = pd.concat([dataset_df1,dataset_df2,dataset_df3,dataset_df4,dataset_df5,dataset_df6,dataset_df7,dataset_df8,dataset_df9],join='outer',ignore_index=True)\n",
    "    dataset_df.drop(columns=['long_gis','lat_gis','sno','RL_GIS','sno','village','mandal','district','gwl','Classification.1','season'],inplace=True)\n",
    "\n",
    "    dataset_df['pH'] = pd.to_numeric(dataset_df['pH'], errors='coerce')\n",
    "\n",
    "    # Now convert to float\n",
    "    dataset_df['pH'] = dataset_df['pH'].astype(float)\n",
    "    dataset_df['RSC  meq  / L'] = pd.to_numeric(dataset_df['RSC  meq  / L'], errors='coerce')\n",
    "\n",
    "    # Now convert to float\n",
    "    dataset_df['RSC  meq  / L'] = dataset_df['RSC  meq  / L'].astype(float)\n",
    "\n",
    "    temp = dataset_df['Classification'].copy()\n",
    "    dataset_df['Classification'] = dataset_df['RSC  meq  / L']\n",
    "    dataset_df['RSC  meq  / L'] = temp\n",
    "    dataset_df = dataset_df.rename(columns={'Classification': 'RSC  meq  / L', 'RSC  meq  / L': 'Classification'})\n",
    "\n",
    "    null_threshold = len(dataset_df) * 0.25\n",
    "    for column in dataset_df.columns:\n",
    "        null_count = dataset_df[column].isnull().sum()\n",
    "        if null_count > null_threshold:\n",
    "            dataset_df.drop(column, axis=1, inplace=True)\n",
    "        elif null_count > 0:\n",
    "            dataset_df.dropna(subset=[column], inplace=True)\n",
    "    dataset_df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    Classification_labels = []\n",
    "\n",
    "    unique_labels = dataset_df['Classification'].unique()\n",
    "    print(unique_labels)\n",
    "\n",
    "    # Convert unique_labels to a set to remove duplicates and then back to a list\n",
    "    Classification_labels = list(set(unique_labels))\n",
    "\n",
    "    # Items to remove from the list\n",
    "    items_to_remove = ['OG', 'BELOW THE GRAPH', 'O.G', 'OUT OF SAR GRAPH', 'BG']\n",
    "\n",
    "    # Create a new list without the items to remove\n",
    "    Classification_labels = [label for label in Classification_labels if label not in items_to_remove]\n",
    "\n",
    "    # Filter dataset_df based on the updated Classification_labels\n",
    "    dataset_df = dataset_df[dataset_df['Classification'].isin(Classification_labels)]\n",
    "\n",
    "    dataset_df = dataset_df.reset_index(drop=True)\n",
    "    print(dataset_df['Classification'].unique())\n",
    "    print(dataset_df.info())\n",
    "    return dataset_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C3S1' 'C2S1' 'C3S2' 'C4S1' 'C4S2' 'C1S1' 'C4S3' 'C4S4' 'C3S3' 'OG'\n",
      " 'C3S4' 'BELOW THE GRAPH' 'O.G' 'OUT OF SAR GRAPH' 'C2S2' 'BG']\n",
      "['C3S1' 'C2S1' 'C3S2' 'C4S1' 'C4S2' 'C1S1' 'C4S3' 'C4S4' 'C3S3' 'C3S4'\n",
      " 'C2S2']\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 4907 entries, 0 to 4906\n",
      "Data columns (total 17 columns):\n",
      " #   Column          Non-Null Count  Dtype  \n",
      "---  ------          --------------  -----  \n",
      " 0   pH              4907 non-null   float64\n",
      " 1   E.C             4907 non-null   float64\n",
      " 2   TDS             4907 non-null   float64\n",
      " 3   CO3             4907 non-null   float64\n",
      " 4   HCO3            4907 non-null   float64\n",
      " 5   Cl              4907 non-null   float64\n",
      " 6   F               4907 non-null   float64\n",
      " 7   NO3             4907 non-null   float64\n",
      " 8   SO4             4907 non-null   float64\n",
      " 9   Na              4907 non-null   float64\n",
      " 10  K               4907 non-null   float64\n",
      " 11  Ca              4907 non-null   float64\n",
      " 12  Mg              4907 non-null   float64\n",
      " 13  T.H             4907 non-null   float64\n",
      " 14  SAR             4907 non-null   float64\n",
      " 15  RSC  meq  / L   4907 non-null   float64\n",
      " 16  Classification  4907 non-null   object \n",
      "dtypes: float64(16), object(1)\n",
      "memory usage: 651.8+ KB\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "dataset_df = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <b>  Random Forest Classifier </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import seed\n",
    "from random import randrange\n",
    "from math import sqrt\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification\n",
      "1     3107\n",
      "0     1169\n",
      "3      238\n",
      "2      148\n",
      "4      112\n",
      "7       52\n",
      "5       26\n",
      "6       25\n",
      "9       23\n",
      "8        6\n",
      "10       1\n",
      "Name: count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "dataset_df['Classification'] = dataset_df['Classification'].map({'C2S1': 0, 'C3S1': 1, 'C4S2': 2, 'C4S1': 3, 'C3S2': 4\n",
    "                                                                 , 'C4S4': 5, 'C4S3': 6, 'C1S1': 7, 'C3S4': 8, 'C3S3': 9, 'C2S2': 10}).astype(int)\n",
    "input_X = dataset_df.drop(columns=['Classification'])\n",
    "input_y = dataset_df['Classification']\n",
    "print(input_y.value_counts())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(input_X, input_y, test_size=0.33, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class DecisionTree:\n",
    "    def __init__(self, max_depth=None, max_features=None):\n",
    "        self.max_depth = max_depth\n",
    "        self.max_features = max_features\n",
    "        self.tree = None\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        self.tree = self._grow_tree(X, y, depth=0)\n",
    "\n",
    "    def _grow_tree(self, X, y, depth):\n",
    "        n_samples, n_features = X.shape\n",
    "        self.n_classes = len(np.unique(y))\n",
    "        n_classes = len(np.unique(y))\n",
    "\n",
    "        # Stopping criteria\n",
    "        if (depth == self.max_depth) or (n_classes == 1) or (n_samples < 2):\n",
    "            return {'class': np.argmax(np.bincount(y)), 'split_feature': None, 'split_threshold': None,\n",
    "                    'left': None, 'right': None}\n",
    "\n",
    "        # Select random subset of features\n",
    "        if self.max_features is not None and self.max_features < n_features:\n",
    "            feature_idxs = np.random.choice(n_features, self.max_features, replace=False)\n",
    "            X = X[:, feature_idxs]\n",
    "        else:\n",
    "            feature_idxs = np.arange(n_features)\n",
    "\n",
    "        # Find best split\n",
    "        best_gini = float('inf')\n",
    "        best_split_feature, best_split_threshold = None, None\n",
    "        for feature in feature_idxs:\n",
    "            thresholds = np.unique(X[:, feature])\n",
    "            for threshold in thresholds:\n",
    "                left_idxs = X[:, feature] < threshold\n",
    "                y_left = y[left_idxs]\n",
    "                y_right = y[~left_idxs]\n",
    "                gini = (len(y_left) / n_samples) * self._gini_impurity(y_left) + \\\n",
    "                       (len(y_right) / n_samples) * self._gini_impurity(y_right)\n",
    "                if gini < best_gini:\n",
    "                    best_gini = gini\n",
    "                    best_split_feature = feature\n",
    "                    best_split_threshold = threshold\n",
    "\n",
    "        # Split the dataset\n",
    "        left_idxs = X[:, best_split_feature] < best_split_threshold\n",
    "        right_idxs = ~left_idxs\n",
    "        if np.sum(left_idxs) == 0:\n",
    "            return {'class': np.argmax(np.bincount(y[right_idxs])), 'split_feature': None, 'split_threshold': None,\n",
    "                    'left': None, 'right': None}\n",
    "\n",
    "        # Check if right subtree is empty\n",
    "        if np.sum(right_idxs) == 0:\n",
    "            return {'class': np.argmax(np.bincount(y[left_idxs])), 'split_feature': None, 'split_threshold': None,\n",
    "                    'left': None, 'right': None}\n",
    "        \n",
    "        # Grow left and right subtrees\n",
    "        left_subtree = self._grow_tree(X[left_idxs], y[left_idxs], depth + 1)\n",
    "        right_subtree = self._grow_tree(X[right_idxs], y[right_idxs], depth + 1)\n",
    "\n",
    "        return {'class': None, 'split_feature': best_split_feature, 'split_threshold': best_split_threshold,\n",
    "                'left': left_subtree, 'right': right_subtree}\n",
    "\n",
    "    def _gini_impurity(self, y):\n",
    "        _, counts = np.unique(y, return_counts=True)\n",
    "        probas = counts / len(y)\n",
    "        return 1 - np.sum(probas ** 2)\n",
    "\n",
    "    def predict(self, X):\n",
    "        return np.array([self._predict_tree(x, self.tree)[0] for x in X]),np.array([self._predict_tree(x, self.tree)[1] for x in X])\n",
    "\n",
    "    def _predict_tree(self, x, tree):\n",
    "        if tree['class'] is not None:\n",
    "            return tree['class'], np.eye(1, self.n_classes, tree['class'])[0]\n",
    "\n",
    "        if x[tree['split_feature']] < tree['split_threshold']:\n",
    "            class_pred, class_probs = self._predict_tree(x, tree['left'])\n",
    "        else:\n",
    "            class_pred, class_probs = self._predict_tree(x, tree['right'])\n",
    "\n",
    "        return class_pred, class_probs\n",
    "\n",
    "class RandomForest:\n",
    "    def __init__(self, n_trees=100, max_depth=None, max_features=None):\n",
    "        self.n_trees = n_trees\n",
    "        self.max_depth = max_depth\n",
    "        self.max_features = max_features\n",
    "        self.trees = []\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        self.classes_ = 11\n",
    "        for _ in range(self.n_trees):\n",
    "            indices = np.random.choice(len(X), size=len(X), replace=True)\n",
    "            tree = DecisionTree(max_depth=self.max_depth, max_features=self.max_features)\n",
    "            tree.fit(X.iloc[indices].values, y.iloc[indices])\n",
    "            self.trees.append(tree)\n",
    "\n",
    "    def predict(self, X):\n",
    "        predictions = np.array([tree.predict(X.values)[0] for tree in self.trees])\n",
    "        predictions=predictions.T\n",
    "        predictions = np.array([np.bincount(pred).argmax() for pred in predictions])\n",
    "        probs = np.zeros((len(X), self.classes_))\n",
    "        for tree in self.trees:\n",
    "            tree_probs = np.array([tree._predict_tree(x, tree.tree)[1] for x in X.values])\n",
    "            if tree_probs.shape[1] < self.classes_:\n",
    "                padded_probs = np.zeros((tree_probs.shape[0], self.classes_))\n",
    "                padded_probs[:, :tree_probs.shape[1]] = tree_probs\n",
    "                tree_probs = padded_probs\n",
    "            probs += tree_probs\n",
    "        probs /= self.n_trees\n",
    "        return predictions,probs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_forest_acc = []\n",
    "random_forest_probs = []\n",
    "for i in [1, 2, 5, 10, 50 ,100]:\n",
    "    rf = RandomForest(n_trees=i, max_depth=7)\n",
    "    rf.fit(X_train, y_train )\n",
    "    predictions,probs = rf.predict(X_test)\n",
    "    random_forest_probs.append(probs)\n",
    "    acc = np.sum(predictions==y_test)/len(y_test) * 100\n",
    "    random_forest_acc.append(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/sklearn/model_selection/_split.py:737: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=5.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Parameters: {'max_depth': 7}\n",
      "Best Score: 0.9534570420026555\n"
     ]
    }
   ],
   "source": [
    "from xgboost import XGBClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# Define the range of values for max_depth\n",
    "param_grid = {\n",
    "    'max_depth': [3, 4, 5, 6, 7, 8, 10, 12]  # Example range of values\n",
    "}\n",
    "\n",
    "# Initialize the XGBoost classifier\n",
    "xgb = XGBClassifier(n_estimators=1)\n",
    "\n",
    "# Initialize GridSearchCV with cross-validation\n",
    "grid_search = GridSearchCV(estimator=xgb, param_grid=param_grid, cv=5, scoring='accuracy')\n",
    "\n",
    "# Fit the grid search to the data\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# Get the best parameters and best score\n",
    "best_params = grid_search.best_params_\n",
    "best_score = grid_search.best_score_\n",
    "\n",
    "print(\"Best Parameters:\", best_params)\n",
    "print(\"Best Score:\", best_score)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XGBoost's prediction accuracy with 1 trees: 93.52%\n",
      "Time consumed for training with 1 trees: 0.018 seconds\n",
      "Time consumed for prediction with 1 trees: 0.00166 seconds\n",
      "\n",
      "XGBoost's prediction accuracy with 2 trees: 93.83%\n",
      "Time consumed for training with 2 trees: 0.017 seconds\n",
      "Time consumed for prediction with 2 trees: 0.00163 seconds\n",
      "\n",
      "XGBoost's prediction accuracy with 5 trees: 94.63%\n",
      "Time consumed for training with 5 trees: 0.034 seconds\n",
      "Time consumed for prediction with 5 trees: 0.00177 seconds\n",
      "\n",
      "XGBoost's prediction accuracy with 10 trees: 94.75%\n",
      "Time consumed for training with 10 trees: 0.078 seconds\n",
      "Time consumed for prediction with 10 trees: 0.00262 seconds\n",
      "\n",
      "XGBoost's prediction accuracy with 50 trees: 94.69%\n",
      "Time consumed for training with 50 trees: 0.493 seconds\n",
      "Time consumed for prediction with 50 trees: 0.00704 seconds\n",
      "\n",
      "XGBoost's prediction accuracy with 100 trees: 94.63%\n",
      "Time consumed for training with 100 trees: 1.144 seconds\n",
      "Time consumed for prediction with 100 trees: 0.00920 seconds\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import time\n",
    "\n",
    "xgboost_acc = []\n",
    "n_estimators_values = [1, 2, 5, 10, 50, 100]  # List of values for n_estimators\n",
    "\n",
    "for n_estimators in n_estimators_values:\n",
    "    xgb = XGBClassifier(n_estimators=n_estimators,max_depth=7,colsample_bytree=0.6)\n",
    "\n",
    "    training_start = time.perf_counter()\n",
    "    xgb.fit(X_train, y_train)\n",
    "    training_end = time.perf_counter()\n",
    "\n",
    "    prediction_start = time.perf_counter()\n",
    "    preds = xgb.predict(X_test)\n",
    "    prediction_end = time.perf_counter()\n",
    "\n",
    "    acc_xgb = (preds == y_test).sum().astype(float) / len(preds) * 100\n",
    "    xgboost_acc.append(acc_xgb)\n",
    "    xgb_train_time = training_end - training_start\n",
    "    xgb_prediction_time = prediction_end - prediction_start\n",
    "\n",
    "    print(f\"XGBoost's prediction accuracy with {n_estimators} trees: {acc_xgb:.2f}%\")\n",
    "    print(f\"Time consumed for training with {n_estimators} trees: {xgb_train_time:.3f} seconds\")\n",
    "    print(f\"Time consumed for prediction with {n_estimators} trees: {xgb_prediction_time:.5f} seconds\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1620\n"
     ]
    }
   ],
   "source": [
    "n_estimators = [1, 2, 5, 10, 50, 100]  # Number of trees\n",
    "# Create a figure and axis\n",
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "\n",
    "# Plot the data\n",
    "ax.plot(n_estimators, random_forest_acc, marker='o', label='Random Forest')\n",
    "ax.plot(n_estimators, xgboost_acc, marker='s', label='XGBoost')\n",
    "\n",
    "# Set labels and title\n",
    "ax.set_xlabel('Number of Trees')\n",
    "ax.set_ylabel('Accuracy (%)')\n",
    "ax.set_title('Accuracy of Random Forest and XGBoost')\n",
    "\n",
    "# Add a legend\n",
    "ax.legend()\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for 1 trees : 94.57\n",
      "Accuracy for 2 trees : 94.14\n",
      "Accuracy for 5 trees : 95.19\n",
      "Accuracy for 10 trees : 94.94\n",
      "Accuracy for 50 trees : 95.74\n",
      "Accuracy for 100 trees : 95.43\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "sklearn_acc = []\n",
    "for n_estimators in n_estimators_values:\n",
    "    rf_clf = RandomForestClassifier(n_estimators, random_state=42,max_depth=7,max_features=5)\n",
    "\n",
    "    # Train the model\n",
    "    rf_clf.fit(X_train, y_train)\n",
    "\n",
    "    # Make predictions on the test set\n",
    "    y_pred = rf_clf.predict(X_test)\n",
    "\n",
    "    # Calculate the accuracy score\n",
    "    accuracy = accuracy_score(y_test, y_pred) * 100\n",
    "    sklearn_acc.append(accuracy)\n",
    "    print(f\"Accuracy for {n_estimators} trees : {accuracy:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "n_estimators = [1, 2, 5, 10, 50, 100]\n",
    "# Plot the data\n",
    "ax.plot(n_estimators, random_forest_acc, marker='o', label='Random Forest')\n",
    "ax.plot(n_estimators, xgboost_acc, marker='s', label='XGBoost')\n",
    "ax.plot(n_estimators, sklearn_acc, marker='s', label='Sci-kit learn RandomForestClassifier')\n",
    "\n",
    "# Set labels and title\n",
    "ax.set_xlabel('Number of Trees')\n",
    "ax.set_ylabel('Accuracy (%)')\n",
    "ax.set_title('Accuracy of Random Forest and XGBoost')\n",
    "\n",
    "# Add a legend\n",
    "ax.legend()\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}