--- a
+++ b/Classification pCR/.ipynb_checkpoints/FinalPCR-checkpoint.ipynb
@@ -0,0 +1,917 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "3907693e-9962-46d3-b895-73bf3649a737",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.impute import SimpleImputer\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.model_selection import GridSearchCV\n",
+    "from sklearn.metrics import balanced_accuracy_score, classification_report"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16438710-37d5-49b8-9d71-34d37bf5d70c",
+   "metadata": {},
+   "source": [
+    "### Load the Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "334ad187-b8b3-422e-9270-75d6112ba33b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the dataset\n",
+    "df = pd.read_excel(\"TrainDataset2024.xls\")\n",
+    "df=df.drop('ID',axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2ad4ed8-37ba-48cc-8f71-4d619b366ee9",
+   "metadata": {},
+   "source": [
+    "### Data preprocessing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "4533e952-af49-42c2-8d1d-943bc2fbd83f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(308, 120)"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#replacing the 999 value to nan for easy removal\n",
+    "\n",
+    "df.replace(999, np.nan, inplace= True)\n",
+    "df.dropna(inplace =True)\n",
+    "df.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "4dd462f5-d8cf-4bfa-90ee-0ba54f2fb730",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = df.rename(columns={\"pCR (outcome)\": \"PCR\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "67bb4488-3630-44b7-a051-ac7ace0037a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plotting for zero and one value count in PCR column\n",
+    "outcomes = df['PCR'].value_counts()\n",
+    "outcome_labels =['0','1']\n",
+    "outcome_values = outcomes.values\n",
+    "plt.bar(outcome_labels, outcome_values)\n",
+    "plt.xlabel('Outcome')\n",
+    "plt.ylabel('Count')\n",
+    "plt.title('Distribution of Outcomes in PCR')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "afc5a1a4-e5ad-4afd-966c-64ad52b46ad7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of outliers: 62\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Calculate Z-scores for the entire dataset\n",
+    "z_scores = np.abs((df - df.mean()) / df.std())\n",
+    "\n",
+    "# Identify rows that have z-scores above the threshold (3 in this case)\n",
+    "outliers = (z_scores > 3).any(axis=1)\n",
+    "\n",
+    "# Print the number of outliers\n",
+    "print(f\"Number of outliers: {outliers.sum()}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "556d9ea6-739f-4a00-a8ad-cc1a1e16cf5a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Remove outliers from the dataset\n",
+    "df_no_outliers = df[~outliers]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "f656af78-2810-4e60-8c23-1199932871df",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "correlated features:  82\n"
+     ]
+    }
+   ],
+   "source": [
+    "df1 = df.copy()\n",
+    "# checking for correlated features of dataset\n",
+    "def correlation(data, threshold):\n",
+    "    col_corr = {}  # Dictionary to store correlated features\n",
+    "    corr_matrix = data.corr()\n",
+    "    for i in range(len(corr_matrix.columns)):\n",
+    "        for j in range(i):\n",
+    "            if abs(corr_matrix.iloc[i, j]) > threshold:  # We are interested in absolute coefficient value\n",
+    "                colname = corr_matrix.columns[i]\n",
+    "                if colname not in col_corr:\n",
+    "                    col_corr[colname] = set()\n",
+    "                col_corr[colname].add(corr_matrix.columns[j])\n",
+    "\n",
+    "    return col_corr\n",
+    "\n",
+    "corr_features = correlation(df1, 0.8)\n",
+    "print('correlated features: ', len(corr_features))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "505a4523-9cde-4915-bb9e-7d44833b3103",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(308, 38)"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# removing the correlated features\n",
+    "df_corr= df1.drop(labels=corr_features, axis=1)\n",
+    "df_corr.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "1d8f6f55-40a4-4d68-953b-ebb3e8b5164c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# dataset using correlated feature selection\n",
+    "X_corr = df_corr.drop([\"PCR\",\"RelapseFreeSurvival (outcome)\"],axis=1)\n",
+    "y_corr = df_corr[\"PCR\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "812b6f93-e64a-4fed-a1f4-105d02ddd195",
+   "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>ER</th>\n",
+       "      <th>PgR</th>\n",
+       "      <th>HER2</th>\n",
+       "      <th>TrippleNegative</th>\n",
+       "      <th>ChemoGrade</th>\n",
+       "      <th>HistologyType</th>\n",
+       "      <th>LNStatus</th>\n",
+       "      <th>TumourStage</th>\n",
+       "      <th>Gene</th>\n",
+       "      <th>...</th>\n",
+       "      <th>original_gldm_DependenceEntropy</th>\n",
+       "      <th>original_gldm_SmallDependenceEmphasis</th>\n",
+       "      <th>original_glrlm_LongRunLowGrayLevelEmphasis</th>\n",
+       "      <th>original_glrlm_ShortRunHighGrayLevelEmphasis</th>\n",
+       "      <th>original_glszm_GrayLevelNonUniformity</th>\n",
+       "      <th>original_glszm_GrayLevelNonUniformityNormalized</th>\n",
+       "      <th>original_glszm_SizeZoneNonUniformityNormalized</th>\n",
+       "      <th>original_glszm_SmallAreaEmphasis</th>\n",
+       "      <th>original_ngtdm_Busyness</th>\n",
+       "      <th>original_ngtdm_Strength</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>41.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>4.529461</td>\n",
+       "      <td>0.005563</td>\n",
+       "      <td>10.779989</td>\n",
+       "      <td>0.789987</td>\n",
+       "      <td>27.545455</td>\n",
+       "      <td>0.834711</td>\n",
+       "      <td>0.180900</td>\n",
+       "      <td>0.403535</td>\n",
+       "      <td>473.464852</td>\n",
+       "      <td>0.000758</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>39.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.799725</td>\n",
+       "      <td>0.006518</td>\n",
+       "      <td>27.650685</td>\n",
+       "      <td>0.442279</td>\n",
+       "      <td>78.025000</td>\n",
+       "      <td>0.975313</td>\n",
+       "      <td>0.198125</td>\n",
+       "      <td>0.444391</td>\n",
+       "      <td>59.459710</td>\n",
+       "      <td>0.003685</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>31.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.863091</td>\n",
+       "      <td>0.007181</td>\n",
+       "      <td>25.338218</td>\n",
+       "      <td>0.503046</td>\n",
+       "      <td>72.027027</td>\n",
+       "      <td>0.973338</td>\n",
+       "      <td>0.275749</td>\n",
+       "      <td>0.534549</td>\n",
+       "      <td>33.935384</td>\n",
+       "      <td>0.006447</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>35.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.756432</td>\n",
+       "      <td>0.004902</td>\n",
+       "      <td>31.461354</td>\n",
+       "      <td>0.399896</td>\n",
+       "      <td>99.019802</td>\n",
+       "      <td>0.980394</td>\n",
+       "      <td>0.253014</td>\n",
+       "      <td>0.506185</td>\n",
+       "      <td>46.859265</td>\n",
+       "      <td>0.004543</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>61.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.676170</td>\n",
+       "      <td>0.007222</td>\n",
+       "      <td>27.916261</td>\n",
+       "      <td>0.473278</td>\n",
+       "      <td>56.034483</td>\n",
+       "      <td>0.966112</td>\n",
+       "      <td>0.216409</td>\n",
+       "      <td>0.462282</td>\n",
+       "      <td>39.621023</td>\n",
+       "      <td>0.005626</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 36 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    Age  ER  PgR  HER2  TrippleNegative  ChemoGrade  HistologyType  LNStatus  \\\n",
+       "0  41.0   0  0.0   0.0              1.0         3.0            1.0       1.0   \n",
+       "1  39.0   1  1.0   0.0              0.0         3.0            1.0       1.0   \n",
+       "2  31.0   0  0.0   0.0              1.0         2.0            1.0       0.0   \n",
+       "3  35.0   0  0.0   0.0              1.0         3.0            1.0       1.0   \n",
+       "4  61.0   1  0.0   0.0              0.0         2.0            1.0       0.0   \n",
+       "\n",
+       "   TumourStage  Gene  ...  original_gldm_DependenceEntropy  \\\n",
+       "0            2   1.0  ...                         4.529461   \n",
+       "1            2   0.0  ...                         2.799725   \n",
+       "2            2   1.0  ...                         2.863091   \n",
+       "3            3   1.0  ...                         2.756432   \n",
+       "4            2   1.0  ...                         2.676170   \n",
+       "\n",
+       "   original_gldm_SmallDependenceEmphasis  \\\n",
+       "0                               0.005563   \n",
+       "1                               0.006518   \n",
+       "2                               0.007181   \n",
+       "3                               0.004902   \n",
+       "4                               0.007222   \n",
+       "\n",
+       "   original_glrlm_LongRunLowGrayLevelEmphasis  \\\n",
+       "0                                   10.779989   \n",
+       "1                                   27.650685   \n",
+       "2                                   25.338218   \n",
+       "3                                   31.461354   \n",
+       "4                                   27.916261   \n",
+       "\n",
+       "   original_glrlm_ShortRunHighGrayLevelEmphasis  \\\n",
+       "0                                      0.789987   \n",
+       "1                                      0.442279   \n",
+       "2                                      0.503046   \n",
+       "3                                      0.399896   \n",
+       "4                                      0.473278   \n",
+       "\n",
+       "   original_glszm_GrayLevelNonUniformity  \\\n",
+       "0                              27.545455   \n",
+       "1                              78.025000   \n",
+       "2                              72.027027   \n",
+       "3                              99.019802   \n",
+       "4                              56.034483   \n",
+       "\n",
+       "   original_glszm_GrayLevelNonUniformityNormalized  \\\n",
+       "0                                         0.834711   \n",
+       "1                                         0.975313   \n",
+       "2                                         0.973338   \n",
+       "3                                         0.980394   \n",
+       "4                                         0.966112   \n",
+       "\n",
+       "   original_glszm_SizeZoneNonUniformityNormalized  \\\n",
+       "0                                        0.180900   \n",
+       "1                                        0.198125   \n",
+       "2                                        0.275749   \n",
+       "3                                        0.253014   \n",
+       "4                                        0.216409   \n",
+       "\n",
+       "   original_glszm_SmallAreaEmphasis  original_ngtdm_Busyness  \\\n",
+       "0                          0.403535               473.464852   \n",
+       "1                          0.444391                59.459710   \n",
+       "2                          0.534549                33.935384   \n",
+       "3                          0.506185                46.859265   \n",
+       "4                          0.462282                39.621023   \n",
+       "\n",
+       "   original_ngtdm_Strength  \n",
+       "0                 0.000758  \n",
+       "1                 0.003685  \n",
+       "2                 0.006447  \n",
+       "3                 0.004543  \n",
+       "4                 0.005626  \n",
+       "\n",
+       "[5 rows x 36 columns]"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_corr.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "513bda72-85cc-4dbe-9d75-5c3ccf1f7835",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# saving the feature in text file for future use in model training and prediction\n",
+    "with open('30cor.txt', 'w') as f:\n",
+    "    for feature in X_corr.columns:\n",
+    "        f.write(feature + '\\n')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "2ce3c60a-87ec-4145-81b7-c0dd29a211d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "# Split the correlated feature into training and testing sets ( correlated features)\n",
+    "X_train1, X_test1, y_train1, y_test1 = train_test_split(X_corr, y_corr, test_size=0.2,shuffle=True,random_state=42)\n",
+    "# Standardize the features\n",
+    "scaler = StandardScaler()\n",
+    "X_train_sc1 = scaler.fit_transform(X_train1)\n",
+    "X_test_sc1 = scaler.fit_transform(X_test1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "8982309b-a9b3-44ff-9267-01ec13cd0431",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((246, 36),)"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train1.shape, "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "1a06c806-469c-41d1-9160-3cf9028a4cf5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# dataset using correlated feature selection for forward feature selection\n",
+    "X_for = df_corr.drop([\"PCR\",\"RelapseFreeSurvival (outcome)\"],axis=1)\n",
+    "y_for = df_corr[\"PCR\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42c12a4b-0e06-45dd-b178-8108db5b7125",
+   "metadata": {},
+   "source": [
+    "### Random forest Final Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "aa1edb33-ce99-4800-8b37-d0dd3d209a2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import joblib\n",
+    "import matplotlib.pyplot as plt\n",
+    "from imblearn.over_sampling import SMOTE\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.model_selection import train_test_split, learning_curve\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.metrics import classification_report, balanced_accuracy_score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "70de1f75-c04c-40b4-b884-1aaf6f06cec0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "         0.0       0.80      1.00      0.89        74\n",
+      "         1.0       0.00      0.00      0.00        19\n",
+      "\n",
+      "    accuracy                           0.80        93\n",
+      "   macro avg       0.40      0.50      0.44        93\n",
+      "weighted avg       0.63      0.80      0.71        93\n",
+      "\n",
+      "\n",
+      "Initial Balanced Accuracy Score:\n",
+      "0.5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\LLR User\\miniconda3\\envs\\MLE\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
+      "C:\\Users\\LLR User\\miniconda3\\envs\\MLE\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
+      "C:\\Users\\LLR User\\miniconda3\\envs\\MLE\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Splitting the data into training and testing sets\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X_corr, y_corr, test_size=0.3, shuffle=True, random_state=64)\n",
+    "\n",
+    "# Standardizing the features\n",
+    "scaler = StandardScaler()\n",
+    "X_train_norm = scaler.fit_transform(X_train)\n",
+    "X_test_norm = scaler.transform(X_test)\n",
+    "\n",
+    "# Initial training of Random Forest model (without SMOTE)\n",
+    "rf_classifier = RandomForestClassifier(max_depth=5, min_samples_leaf=3, min_samples_split=15, n_estimators=25, random_state=42)\n",
+    "rf_classifier.fit(X_train_norm, y_train)\n",
+    "\n",
+    "# Predicting class labels for testing data (initial prediction)\n",
+    "y_pred = rf_classifier.predict(X_test_norm)\n",
+    "\n",
+    "# Calculating classification report and balanced accuracy score (initial performance)\n",
+    "report = classification_report(y_test, y_pred)\n",
+    "balanced_accuracy = balanced_accuracy_score(y_test, y_pred)\n",
+    "\n",
+    "print('Initial Classification Report:')\n",
+    "print(report)\n",
+    "\n",
+    "print('\\nInitial Balanced Accuracy Score:')\n",
+    "print(balanced_accuracy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "4b3632e2-2072-46a3-ad66-076cfb235094",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Classification Report After SMOTE:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "         0.0       0.87      0.88      0.87        74\n",
+      "         1.0       0.50      0.47      0.49        19\n",
+      "\n",
+      "    accuracy                           0.80        93\n",
+      "   macro avg       0.68      0.68      0.68        93\n",
+      "weighted avg       0.79      0.80      0.79        93\n",
+      "\n",
+      "\n",
+      "Balanced Accuracy Score After SMOTE:\n",
+      "0.6760312944523471\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Now applying SMOTE for oversampling the minority class in the training data\n",
+    "smote = SMOTE(random_state=42)\n",
+    "X_train_smote, y_train_smote = smote.fit_resample(X_train_norm, y_train)\n",
+    "\n",
+    "# Retraining the Random Forest model on the SMOTE-resampled data\n",
+    "rf_classifier_smote = RandomForestClassifier(max_depth=5, min_samples_leaf=3, min_samples_split=15, n_estimators=25, random_state=42)\n",
+    "rf_classifier_smote.fit(X_train_smote, y_train_smote)\n",
+    "\n",
+    "# Predicting class labels for testing data (after SMOTE resampling)\n",
+    "y_pred_smote = rf_classifier_smote.predict(X_test_norm)\n",
+    "\n",
+    "# Calculating classification report and balanced accuracy score (after SMOTE)\n",
+    "report_smote = classification_report(y_test, y_pred_smote)\n",
+    "balanced_accuracy_smote = balanced_accuracy_score(y_test, y_pred_smote)\n",
+    "\n",
+    "print('\\nClassification Report After SMOTE:')\n",
+    "print(report_smote)\n",
+    "\n",
+    "print('\\nBalanced Accuracy Score After SMOTE:')\n",
+    "print(balanced_accuracy_smote)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "2338844d-31b3-4d07-ac64-fbc4c58a8a2c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy for each fold:\n",
+      "Fold 0: 0.8000\n",
+      "Fold 1: 0.8000\n",
+      "Fold 2: 0.8000\n",
+      "Fold 3: 0.9200\n",
+      "Fold 4: 0.8000\n",
+      "Fold 5: 0.8000\n",
+      "Fold 6: 0.8750\n",
+      "Fold 7: 0.7917\n",
+      "Fold 8: 0.8750\n",
+      "Fold 9: 0.8750\n",
+      "Average accuracy: 0.8337\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Ensure that you are using X_train and y_train for cross-validation, not X_train and y_corr\n",
+    "from sklearn.model_selection import train_test_split, KFold, cross_val_score\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "\n",
+    "# Split the data\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X_corr, y_corr, test_size=0.2, shuffle=True, random_state=60)\n",
+    "\n",
+    "# Initialize the model\n",
+    "rf_classifier = RandomForestClassifier(max_depth=15, min_samples_leaf=2, min_samples_split=15, n_estimators=1000, random_state=42)\n",
+    "\n",
+    "# Perform 10-fold cross-validation on the dataset using RandomForest\n",
+    "k = KFold(n_splits=10)\n",
+    "scores = cross_val_score(rf_classifier, X_train, y_train, cv=k)\n",
+    "\n",
+    "# Printing the accuracy of each fold\n",
+    "print(\"Accuracy for each fold:\")\n",
+    "for i in range(len(scores)):\n",
+    "    print(f\"Fold {i}: {scores[i]:.4f}\")\n",
+    "\n",
+    "# Printing the average accuracy\n",
+    "average_accuracy = np.mean(scores)\n",
+    "print(f\"Average accuracy: {average_accuracy:.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "306361af-a43c-4bc0-b205-6145f4c8cf8c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plotting Learning Curve for Random Forest model with SMOTE\n",
+    "train_sizes, train_scores, test_scores = learning_curve(\n",
+    "    rf_classifier_smote, X_train_smote, y_train_smote, cv=5, n_jobs=-1,\n",
+    "    train_sizes=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]\n",
+    ")\n",
+    "\n",
+    "# Calculate mean and std for train and test scores\n",
+    "train_mean = train_scores.mean(axis=1)\n",
+    "test_mean = test_scores.mean(axis=1)\n",
+    "train_std = train_scores.std(axis=1)\n",
+    "test_std = test_scores.std(axis=1)\n",
+    "\n",
+    "# Plotting the learning curve\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(train_sizes, train_mean, label='Training score', color='blue')\n",
+    "plt.plot(train_sizes, test_mean, label='Cross-validation score', color='green')\n",
+    "\n",
+    "# Plotting the confidence intervals\n",
+    "plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color='blue', alpha=0.2)\n",
+    "plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color='green', alpha=0.2)\n",
+    "\n",
+    "plt.title('Learning Curve for Random Forest Classifier with SMOTE')\n",
+    "plt.xlabel('Training Set Size')\n",
+    "plt.ylabel('Score')\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "57e9f657-5172-408e-ac03-80fc36f37031",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['scaler.pkl']"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Save the Random Forest model and scaler using joblib\n",
+    "joblib.dump(rf_classifier_smote, 'rf_classifier_smote.pkl')  # Save the trained model\n",
+    "joblib.dump(scaler, 'scaler.pkl')  # Save the scaler used for standardizing the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "bb709a33-09a0-49cd-ab95-72410f72e254",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predictions on Test Dataset: [0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.\n",
+      " 0. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 1. 1. 0. 0. 0. 0. 1. 1. 0.\n",
+      " 1. 1. 1. 1. 1. 1. 0. 0. 0. 1. 1. 0. 0. 1. 1. 0. 1. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 1. 0. 1. 0. 1. 0. 1. 0. 1. 1. 1. 1. 0. 1. 1. 0. 0.\n",
+      " 1. 0. 1. 0. 0. 0. 0. 0. 1. 0. 0. 0. 1.]\n",
+      "Number of 1s in predictions: 41\n",
+      "Number of 0s in predictions: 92\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ---- Loading the model and scaler from the pickle file ----\n",
+    "# Load the trained model and scaler from the saved pickle files\n",
+    "loaded_rf_model = joblib.load('rf_classifier_smote.pkl')\n",
+    "loaded_scaler = joblib.load('scaler.pkl')\n",
+    "\n",
+    "# Now, let's use the loaded model and scaler to make predictions on new data\n",
+    "# Assume df_test is your test data\n",
+    "df_test = pd.read_excel(\"FinalTestDataset2024.xls\")\n",
+    "\n",
+    "# Apply the same feature selection\n",
+    "with open('30cor.txt', 'r') as file:\n",
+    "    features = [line.strip() for line in file.readlines()]\n",
+    "\n",
+    "df_test_selected = df_test[features]\n",
+    "\n",
+    "# Transform the test data using the loaded scaler\n",
+    "X_test_sc = loaded_scaler.transform(df_test_selected)\n",
+    "\n",
+    "# Make predictions using the loaded Random Forest model\n",
+    "y_pred_loaded = loaded_rf_model.predict(X_test_sc)\n",
+    "\n",
+    "# Count occurrences of predicted classes\n",
+    "count_1 = np.sum(y_pred_loaded == 1)\n",
+    "count_0 = np.sum(y_pred_loaded == 0)\n",
+    "\n",
+    "# Print predictions and counts\n",
+    "print(\"Predictions on Test Dataset:\", y_pred_loaded)\n",
+    "print(f\"Number of 1s in predictions: {count_1}\")\n",
+    "print(f\"Number of 0s in predictions: {count_0}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "d952d9a5-d5d6-4e68-827e-c9f9915a306c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predictions have been saved to finalPCRoutput.xlsx\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "# Ensure the 'ID' column exists\n",
+    "if 'ID' not in df_test.columns:\n",
+    "    raise ValueError(\"The input test dataset must contain an 'ID' column.\")\n",
+    "\n",
+    "# Create a DataFrame for predictions\n",
+    "output_df = pd.DataFrame({\n",
+    "    'ID': df_test['ID'],\n",
+    "    'Prediction': y_pred_loaded\n",
+    "})\n",
+    "\n",
+    "# Save the predictions to an Excel file in 'xlsx' format\n",
+    "output_file_name = 'finalPCRoutput.xlsx'\n",
+    "output_df.to_excel(output_file_name, index=False)\n",
+    "\n",
+    "print(f\"Predictions have been saved to {output_file_name}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5cc9187-dc3a-4778-a09c-a52157133309",
+   "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.13.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}