diff --git "a/final.ipynb" "b/final.ipynb" new file mode 100644--- /dev/null +++ "b/final.ipynb" @@ -0,0 +1,2561 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [], + "source": [ + "df=pd.read_csv(\"new_pcos_dataset.csv\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PCOS (Y/N)Follicle No. (R)Follicle No. (L)Skin darkening (Y/N)hair growth(Y/N)Weight gain(Y/N)Cycle length(days)AMH(ng/mL)Fast food (Y/N)Cycle(R/I)FSH/LHPRL(ng/mL)Pimples(Y/N)Age (yrs)BMI
003300052.071.002.16032645.1602819.3
105300051.530.006.17431220.0903624.9
21151300056.631.006.29545510.5213325.3
302200051.220.003.41525436.9003729.7
404300052.260.004.42222230.0902520.1
\n", + "
" + ], + "text/plain": [ + " PCOS (Y/N) Follicle No. (R) Follicle No. (L) Skin darkening (Y/N) \\\n", + "0 0 3 3 0 \n", + "1 0 5 3 0 \n", + "2 1 15 13 0 \n", + "3 0 2 2 0 \n", + "4 0 4 3 0 \n", + "\n", + " hair growth(Y/N) Weight gain(Y/N) Cycle length(days) AMH(ng/mL) \\\n", + "0 0 0 5 2.07 \n", + "1 0 0 5 1.53 \n", + "2 0 0 5 6.63 \n", + "3 0 0 5 1.22 \n", + "4 0 0 5 2.26 \n", + "\n", + " Fast food (Y/N) Cycle(R/I) FSH/LH PRL(ng/mL) Pimples(Y/N) Age (yrs) \\\n", + "0 1.0 0 2.160326 45.16 0 28 \n", + "1 0.0 0 6.174312 20.09 0 36 \n", + "2 1.0 0 6.295455 10.52 1 33 \n", + "3 0.0 0 3.415254 36.90 0 37 \n", + "4 0.0 0 4.422222 30.09 0 25 \n", + "\n", + " BMI \n", + "0 19.3 \n", + "1 24.9 \n", + "2 25.3 \n", + "3 29.7 \n", + "4 20.1 " + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [], + "source": [ + "X=df.drop([\"PCOS (Y/N)\"],axis=1)\n", + "y = df[[\"PCOS (Y/N)\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(540, 14)" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(540, 1)" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "from imblearn.combine import SMOTEENN\n", + "\n", + "resample = SMOTEENN(sampling_strategy=1/1, random_state =0)\n", + "X, y = resample.fit_resample(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(527, 14)" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(527, 1)" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: yellowbrick in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (1.5)\n", + "Requirement already satisfied: matplotlib!=3.0.0,>=2.0.2 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from yellowbrick) (3.10.0)\n", + "Requirement already satisfied: scipy>=1.0.0 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from yellowbrick) (1.15.1)\n", + "Requirement already satisfied: scikit-learn>=1.0.0 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from yellowbrick) (1.6.1)\n", + "Requirement already satisfied: numpy>=1.16.0 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from yellowbrick) (2.2.2)\n", + "Requirement already satisfied: cycler>=0.10.0 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from yellowbrick) (0.12.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (1.3.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (4.55.4)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (1.4.8)\n", + "Requirement already satisfied: packaging>=20.0 in c:\\users\\user\\appdata\\roaming\\python\\python313\\site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (24.2)\n", + "Requirement already satisfied: pillow>=8 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (11.1.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (3.2.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in c:\\users\\user\\appdata\\roaming\\python\\python313\\site-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick) (2.9.0.post0)\n", + "Requirement already satisfied: joblib>=1.2.0 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from scikit-learn>=1.0.0->yellowbrick) (1.4.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in c:\\users\\user\\appdata\\local\\programs\\python\\python313\\lib\\site-packages (from scikit-learn>=1.0.0->yellowbrick) (3.5.0)\n", + "Requirement already satisfied: six>=1.5 in c:\\users\\user\\appdata\\roaming\\python\\python313\\site-packages (from python-dateutil>=2.7->matplotlib!=3.0.0,>=2.0.2->yellowbrick) (1.17.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "[notice] A new release of pip is available: 24.3.1 -> 25.0.1\n", + "[notice] To update, run: python.exe -m pip install --upgrade pip\n" + ] + } + ], + "source": [ + "import sys\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "plt.style.use(\"ggplot\")\n", + "plt.rcParams['figure.figsize'] = (12, 8)\n", + "import seaborn as sns\n", + "sns.set(style='whitegrid', color_codes=True)\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "from sklearn.feature_selection import chi2,f_classif, mutual_info_classif, SelectKBest\n", + "from sklearn.model_selection import train_test_split, cross_val_score\n", + "from sklearn.model_selection import RepeatedStratifiedKFold\n", + "from sklearn.model_selection import StratifiedKFold\n", + "from sklearn.metrics import confusion_matrix\n", + "\n", + "%pip install yellowbrick\n", + "from yellowbrick.model_selection import CVScores" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [], + "source": [ + "from yellowbrick.classifier import confusion_matrix\n", + "\n", + "def vis_conf(model, X_test, y_test):\n", + " plt.figure(figsize=(6, 5))\n", + " visualizer = confusion_matrix(\n", + " model,\n", + " X_test, y_test,\n", + " is_fitted=True,\n", + " classes=['Negative', 'Positive']\n", + " )\n", + " visualizer.show();" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [], + "source": [ + "def test_results(model, X_test, y_test):\n", + " from sklearn.metrics import confusion_matrix\n", + " y_pred = model.predict(X_test)\n", + " tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()\n", + "\n", + " accuracy = (tp + tn) / (tp + fp + tn + fn)\n", + " print(\"Accuracy: \", '{:.2f}'.format(accuracy * 100))\n", + " print(\"True Negative:\", tn)\n", + " print(\"True Positive:\", tp)\n", + " print(\"False Positive:\", fp)\n", + " print(\"False Negative:\", fn)\n", + " print(\"\\n-------------------------------------------------------\")\n", + "\n", + " # Negative Class (No PCOS)\n", + " print(\"Negative Class Results (No PCOS)\")\n", + " precision_n = tn / (tn + fn) # Corrected\n", + " recall_n = tn / (tn + fp) # Corrected\n", + " f1_score_n = 2 * (precision_n * recall_n) / (precision_n + recall_n) if (precision_n + recall_n) > 0 else 0\n", + " print(\"Precision (N): \", '{:.2f}'.format(precision_n * 100))\n", + " print(\"Recall (N): \", '{:.2f}'.format(recall_n * 100))\n", + " print(\"F1 Score (N): \", '{:.2f}'.format(f1_score_n * 100))\n", + " print(\"\\n-------------------------------------------------------\")\n", + "\n", + " # Positive Class (PCOS)\n", + " print(\"Positive Class Results (PCOS)\")\n", + " precision_p = tp / (tp + fp) # Fixed: Should be TP / (TP + FP)\n", + " recall_p = tp / (tp + fn) # Fixed: Should be TP / (TP + FN)\n", + " f1_score_p = 2 * (precision_p * recall_p) / (precision_p + recall_p) if (precision_p + recall_p) > 0 else 0\n", + " print(\"Precision (P): \", '{:.2f}'.format(precision_p * 100))\n", + " print(\"Recall (P): \", '{:.2f}'.format(recall_p * 100))\n", + " print(\"F1 Score (P): \", '{:.2f}'.format(f1_score_p * 100))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0, stratify= y)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scaler has been saved as scaler1.pkl\n" + ] + } + ], + "source": [ + "from sklearn.preprocessing import MinMaxScaler\n", + "import pandas as pd\n", + "import joblib\n", + "\n", + "scaler = MinMaxScaler().fit(X_train)\n", + "\n", + "X_train = scaler.transform(X_train)\n", + "X_train = pd.DataFrame(X_train)\n", + "\n", + "X_test = scaler.transform(X_test)\n", + "X_test = pd.DataFrame(X_test)\n", + "\n", + "\n", + "# Setting Column Names from dataset\n", + "X_train.columns = X.columns\n", + "X_test.columns = X.columns\n", + "\n", + "scaler_filename = \"scaler1.pkl\"\n", + "joblib.dump(scaler, scaler_filename)\n", + "\n", + "print(f\"Scaler has been saved as {scaler_filename}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import classification_report, roc_auc_score\n", + "import joblib" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
LogisticRegression(max_iter=1000, random_state=0)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LogisticRegression(max_iter=1000, random_state=0)" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "log_reg = LogisticRegression(random_state=0, max_iter=1000)\n", + "log_reg.fit(X_train, y_train.values.ravel())" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model has been saved as logistic_regression_model.pkl\n" + ] + } + ], + "source": [ + "model_filename = \"logistic_regression_model.pkl\"\n", + "joblib.dump(log_reg, model_filename)\n", + "print(f\"Model has been saved as {model_filename}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [], + "source": [ + "y_pred = log_reg.predict(X_test)\n", + "y_pred_proba = log_reg.predict_proba(X_test)[:, 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 95.28\n", + "True Negative: 49\n", + "True Positive: 52\n", + "False Positive: 2\n", + "False Negative: 3\n", + "\n", + "-------------------------------------------------------\n", + "Negative Class Results (No PCOS)\n", + "Precision (N): 94.23\n", + "Recall (N): 96.08\n", + "F1 Score (N): 95.15\n", + "\n", + "-------------------------------------------------------\n", + "Positive Class Results (PCOS)\n", + "Precision (P): 96.30\n", + "Recall (P): 94.55\n", + "F1 Score (P): 95.41\n", + "Classification Report:\n", + " precision recall f1-score support\n", + "\n", + " 0 0.94 0.96 0.95 51\n", + " 1 0.96 0.95 0.95 55\n", + "\n", + " accuracy 0.95 106\n", + " macro avg 0.95 0.95 0.95 106\n", + "weighted avg 0.95 0.95 0.95 106\n", + "\n", + "ROC AUC Score: 0.9814616755793226\n" + ] + } + ], + "source": [ + "test_results(log_reg, X_test, y_test)\n", + "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n", + "print(\"ROC AUC Score:\", roc_auc_score(y_test, y_pred_proba))" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "vis_conf(log_reg, X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import StratifiedKFold, GridSearchCV\n", + "from sklearn.linear_model import LogisticRegression\n", + "from yellowbrick.model_selection import CVScores" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Use StratifiedKFold with 10 folds\n", + "cv = StratifiedKFold(n_splits=10, random_state=0, shuffle=True)\n", + "\n", + "# Hyperparameter tuning with GridSearchCV\n", + "param_grid = {\n", + " 'C': [0.01, 0.1, 1.0, 10.0], # Regularization strength\n", + " 'penalty': ['l1', 'l2', 'elasticnet'], # Regularization types\n", + " 'solver': ['liblinear', 'saga'], # Solver choices\n", + " 'class_weight': ['balanced'], # Class weight for focus on recall\n", + " 'max_iter': [100, 200, 300] # Iteration counts\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "grid_search = GridSearchCV(\n", + " estimator=LogisticRegression(random_state=0),\n", + " param_grid=param_grid,\n", + " scoring='f1_weighted', # Focus on F1 score\n", + " cv=cv, # 10-Fold CV\n", + " n_jobs=-1 # Use all processors\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
GridSearchCV(cv=StratifiedKFold(n_splits=10, random_state=0, shuffle=True),\n",
+       "             estimator=LogisticRegression(random_state=0), n_jobs=-1,\n",
+       "             param_grid={'C': [0.01, 0.1, 1.0, 10.0],\n",
+       "                         'class_weight': ['balanced'],\n",
+       "                         'max_iter': [100, 200, 300],\n",
+       "                         'penalty': ['l1', 'l2', 'elasticnet'],\n",
+       "                         'solver': ['liblinear', 'saga']},\n",
+       "             scoring='f1_weighted')
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "GridSearchCV(cv=StratifiedKFold(n_splits=10, random_state=0, shuffle=True),\n", + " estimator=LogisticRegression(random_state=0), n_jobs=-1,\n", + " param_grid={'C': [0.01, 0.1, 1.0, 10.0],\n", + " 'class_weight': ['balanced'],\n", + " 'max_iter': [100, 200, 300],\n", + " 'penalty': ['l1', 'l2', 'elasticnet'],\n", + " 'solver': ['liblinear', 'saga']},\n", + " scoring='f1_weighted')" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grid_search.fit(X, y)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best Parameters: {'C': 0.1, 'class_weight': 'balanced', 'max_iter': 100, 'penalty': 'l2', 'solver': 'liblinear'}\n" + ] + } + ], + "source": [ + "best_params = grid_search.best_params_\n", + "print(f\"Best Parameters: {best_params}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [], + "source": [ + "best_model = grid_search.best_estimator_\n" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 153, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "visualizer = CVScores(\n", + " best_model,\n", + " cv=cv,\n", + " scoring='f1_weighted', # Focus on F1 score\n", + " is_fitted=False,\n", + " stratify=True\n", + ")\n", + "visualizer.fit(X, y)\n", + "visualizer.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10-Fold CV Mean F1-Score: 0.9564\n", + "10-Fold CV Score Standard Deviation: 0.0224\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import cross_val_score\n", + "\n", + "# Calculate cross-validation scores\n", + "cv_scores = cross_val_score(best_model, X, y.values.ravel(), cv=cv, scoring='f1_weighted')\n", + "\n", + "# Print mean and standard deviation of the scores\n", + "print(f\"10-Fold CV Mean F1-Score: {cv_scores.mean():.4f}\")\n", + "print(f\"10-Fold CV Score Standard Deviation: {cv_scores.std():.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
LogisticRegression(C=0.1, class_weight='balanced', random_state=0,\n",
+       "                   solver='liblinear')
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LogisticRegression(C=0.1, class_weight='balanced', random_state=0,\n", + " solver='liblinear')" + ] + }, + "execution_count": 155, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Train the final model with best parameters\n", + "final_model = LogisticRegression(**best_params, random_state=0)\n", + "final_model.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [], + "source": [ + "y_pred_final = final_model.predict(X_test)\n", + "y_pred_proba_final = final_model.predict_proba(X_test)[:, 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 94.34\n", + "True Negative: 48\n", + "True Positive: 52\n", + "False Positive: 3\n", + "False Negative: 3\n", + "\n", + "-------------------------------------------------------\n", + "Negative Class Results (No PCOS)\n", + "Precision (N): 94.12\n", + "Recall (N): 94.12\n", + "F1 Score (N): 94.12\n", + "\n", + "-------------------------------------------------------\n", + "Positive Class Results (PCOS)\n", + "Precision (P): 94.55\n", + "Recall (P): 94.55\n", + "F1 Score (P): 94.55\n", + "Classification Report:\n", + " precision recall f1-score support\n", + "\n", + " 0 0.94 0.96 0.95 51\n", + " 1 0.96 0.95 0.95 55\n", + "\n", + " accuracy 0.95 106\n", + " macro avg 0.95 0.95 0.95 106\n", + "weighted avg 0.95 0.95 0.95 106\n", + "\n", + "ROC AUC Score: 0.9814616755793226\n" + ] + } + ], + "source": [ + "test_results( final_model, X_test, y_test)\n", + "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n", + "print(\"ROC AUC Score:\", roc_auc_score(y_test, y_pred_proba))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vis_conf(final_model, X_test, y_test)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import roc_curve, roc_auc_score\n", + "\n", + "# Predict probabilities\n", + "y_probs = final_model.predict_proba(X_test)[:, 1]\n", + "\n", + "# Compute ROC curve\n", + "fpr, tpr, thresholds = roc_curve(y_test, y_probs)\n", + "\n", + "# Compute AUC\n", + "roc_auc = roc_auc_score(y_test, y_probs)\n", + "\n", + "# Find the optimal threshold (Youden's J statistic)\n", + "j_scores = tpr - fpr\n", + "optimal_idx = j_scores.argmax()\n", + "optimal_threshold = thresholds[optimal_idx]" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal Threshold (Youden's J): 0.50\n", + "AUC: 0.98\n" + ] + } + ], + "source": [ + "# Plot ROC curve\n", + "plt.figure(figsize=(8, 6))\n", + "plt.plot(fpr, tpr, color='blue', label=f'Logistic Regression (AUC = {roc_auc:.2f})')\n", + "plt.scatter(fpr[optimal_idx], tpr[optimal_idx], color='red', label=f'Optimal Threshold = {optimal_threshold:.2f}')\n", + "plt.plot([0, 1], [0, 1], color='gray', linestyle='--')\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC Curve for Logistic Regression')\n", + "plt.legend(loc='lower right')\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "print(f\"Optimal Threshold (Youden's J): {optimal_threshold:.2f}\")\n", + "print(f\"AUC: {roc_auc:.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import precision_recall_curve, f1_score\n", + "\n", + "# Predict probabilities\n", + "y_probs = final_model.predict_proba(X_test)[:, 1]\n", + "\n", + "# Calculate precision-recall curve\n", + "precision, recall, thresholds = precision_recall_curve(y_test, y_probs)\n", + "\n", + "# Calculate F1 score for each threshold\n", + "f1_scores = [f1_score(y_test, (y_probs >= t).astype(int)) for t in thresholds]\n", + "\n", + "# Find the best threshold (highest F1 score)\n", + "best_index = f1_scores.index(max(f1_scores))\n", + "best_threshold = thresholds[best_index]" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best Threshold (Max F1): 0.48\n", + "Max F1 Score: 0.95\n" + ] + } + ], + "source": [ + "# Plot the PR curve\n", + "plt.figure(figsize=(8, 5))\n", + "plt.plot(recall, precision, label=f'PR Curve (Best Threshold={best_threshold:.2f}, F1={max(f1_scores):.2f})')\n", + "plt.xlabel('Recall')\n", + "plt.ylabel('Precision')\n", + "plt.title('Precision-Recall Curve for Logistic Regression')\n", + "plt.legend(loc='best')\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "print(f\"Best Threshold (Max F1): {best_threshold:.2f}\")\n", + "print(f\"Max F1 Score: {max(f1_scores):.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final model saved as LR1.pkl\n" + ] + } + ], + "source": [ + "import joblib\n", + "joblib.dump(final_model, \"LR1.pkl\")\n", + "print(\"Final model saved as LR1.pkl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [], + "source": [ + "# Predict probabilities using the best model\n", + "y_probs = final_model.predict_proba(X_test)[:, 1]\n", + "\n", + "# Apply threshold of 0.50\n", + "y_pred = (y_probs >= 0.50).astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 94.34\n", + "True Negative: 48\n", + "True Positve: 52\n", + "False Positive: 3\n", + "False Negative: 3\n", + "\n", + "-------------------------------------------------------\n", + "Negative Class Results\n", + "Precision (N): 94.55\n", + "Recall (N): 94.55\n", + "F1 Score (N): 94.55\n", + "\n", + "-------------------------------------------------------\n", + "Positive Class Results\n", + "Precision (P): 94.12\n", + "Recall (P): 94.12\n", + "F1 Score (P): 94.12\n" + ] + } + ], + "source": [ + "test_results(final_model, X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal Threshold: 0.501\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import roc_curve, auc\n", + "\n", + "# --- ROC Curve with Optimal Threshold ---\n", + "fpr, tpr, thresholds = roc_curve(y_test, y_probs)\n", + "roc_auc = auc(fpr, tpr)\n", + "\n", + "# Find Optimal Threshold (closest to top-left corner)\n", + "distances = np.sqrt((1 - tpr)**2 + fpr**2) # Euclidean distance\n", + "optimal_idx = np.argmin(distances) # Index of smallest distance\n", + "optimal_threshold = thresholds[optimal_idx]\n", + "\n", + "# Plot ROC Curve\n", + "plt.figure(figsize=(7, 5))\n", + "plt.plot(fpr, tpr, label=f'ROC Curve (AUC = {roc_auc:.2f})', color='blue')\n", + "plt.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Random Classifier')\n", + "\n", + "# Mark the Optimal Threshold Point\n", + "plt.scatter(fpr[optimal_idx], tpr[optimal_idx], color='red', label=f'Optimal Threshold: {optimal_threshold:.3f}', s=100, edgecolors='black')\n", + "\n", + "plt.xlabel('False Positive Rate (FPR)')\n", + "plt.ylabel('True Positive Rate (TPR)')\n", + "plt.title('ROC Curve with Optimal Threshold')\n", + "plt.legend(loc='lower right')\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "print(f\"Optimal Threshold: {optimal_threshold:.3f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [], + "source": [ + "# Predict probabilities using the best model\n", + "y_probs = final_model.predict_proba(X_test)[:, 1]\n", + "\n", + "# Apply threshold of 0.677\n", + "y_pred = (y_probs >= 0.677).astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 94.34\n", + "True Negative: 48\n", + "True Positve: 52\n", + "False Positive: 3\n", + "False Negative: 3\n", + "\n", + "-------------------------------------------------------\n", + "Negative Class Results\n", + "Precision (N): 94.55\n", + "Recall (N): 94.55\n", + "F1 Score (N): 94.55\n", + "\n", + "-------------------------------------------------------\n", + "Positive Class Results\n", + "Precision (P): 94.12\n", + "Recall (P): 94.12\n", + "F1 Score (P): 94.12\n" + ] + } + ], + "source": [ + "test_results(final_model, X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "\n", + "input_data = np.array([[8,15,1,1,1,2,7.94,1.0,1,1.3245033112582782,22.43,1,25,32.0\n", + "\n", + "]]) " + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1]\n" + ] + } + ], + "source": [ + "prediction = final_model.predict(input_data)\n", + "print(prediction) " + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1]\n" + ] + } + ], + "source": [ + "predicted_value = final_model.predict(input_data)\n", + "print(predicted_value) " + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PCOS Detected\n" + ] + } + ], + "source": [ + "if prediction == 1:\n", + " print(\"PCOS Detected\")\n", + "else:\n", + " print(\"No PCOS\")" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [], + "source": [ + "y_pred_test = final_model.predict(X_test)\n", + "y_pred_proba = final_model.predict_proba(X_test)[:, 1] # Get probability scores\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 94.34\n", + "True Negative: 48\n", + "True Positve: 52\n", + "False Positive: 3\n", + "False Negative: 3\n", + "\n", + "-------------------------------------------------------\n", + "Negative Class Results\n", + "Precision (N): 94.55\n", + "Recall (N): 94.55\n", + "F1 Score (N): 94.55\n", + "\n", + "-------------------------------------------------------\n", + "Positive Class Results\n", + "Precision (P): 94.12\n", + "Recall (P): 94.12\n", + "F1 Score (P): 94.12\n" + ] + } + ], + "source": [ + "\n", + "test_results(final_model, X_test, y_test)\n", + "\n", + "\n", + "\n" + ] + } + ], + "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.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}