{ "cells": [ { "cell_type": "code", "execution_count": 198, "metadata": {}, "outputs": [], "source": [ "\n", "\n", "import pandas as pd\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.metrics import classification_report\n", "from imblearn.combine import SMOTEENN\n", "from sklearn.model_selection import GridSearchCV\n" ] }, { "cell_type": "code", "execution_count": 199, "metadata": {}, "outputs": [], "source": [ "from matplotlib import pyplot as plt\n", "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": 200, "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": 201, "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 + fp) # Corrected formula for Precision (N)\n", " recall_n = tn / (tn + fp) # Correct formula for Recall (N)\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) # Correct formula for Precision (P)\n", " recall_p = tp / (tp + fn) # Correct formula for Recall (P)\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))" ] }, { "cell_type": "code", "execution_count": 202, "metadata": {}, "outputs": [], "source": [ "pcos_data = pd.read_csv(\"new_pcos_dataset.csv\")\n" ] }, { "cell_type": "code", "execution_count": 203, "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": 203, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pcos_data.head()" ] }, { "cell_type": "code", "execution_count": 204, "metadata": {}, "outputs": [], "source": [ "# Select non-clinical factors for vertical fragmentation\n", "non_clinical_data = pcos_data[\n", " [\n", " \"PCOS (Y/N)\", # Target\n", " \"Skin darkening (Y/N)\",\n", " \"hair growth(Y/N)\",\n", " \"Weight gain(Y/N)\",\n", " \"Fast food (Y/N)\",\n", " \"Pimples(Y/N)\",\n", " \"Age (yrs)\",\n", " \"BMI\",\n", " ]\n", "]" ] }, { "cell_type": "code", "execution_count": 205, "metadata": {}, "outputs": [], "source": [ "# Drop rows with missing values in the selected columns\n", "non_clinical_data = non_clinical_data.dropna()\n" ] }, { "cell_type": "code", "execution_count": 206, "metadata": {}, "outputs": [], "source": [ "# Separate features and target variable\n", "X = non_clinical_data.drop(columns=[\"PCOS (Y/N)\"])\n", "y = non_clinical_data[\"PCOS (Y/N)\"]" ] }, { "cell_type": "code", "execution_count": 207, "metadata": {}, "outputs": [], "source": [ "# Apply SMOTEENN to handle class imbalance with tuned parameters\n", "smoteenn = SMOTEENN(random_state=42, sampling_strategy='auto', smote=None, enn=None)\n", "X_resampled, y_resampled = smoteenn.fit_resample(X, y)" ] }, { "cell_type": "code", "execution_count": 208, "metadata": {}, "outputs": [], "source": [ "# Split the data into training and testing sets\n", "X_train, X_test, y_train, y_test = train_test_split(X_resampled, y_resampled, test_size=0.2, random_state=42)" ] }, { "cell_type": "code", "execution_count": 209, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model has been saved as logistic_regression_model.pkl\n", "\n", "--- Training Data Evaluation ---\n", "Accuracy: 86.65\n", "True Negative: 129\n", "True Positive: 176\n", "False Positive: 18\n", "False Negative: 29\n", "\n", "-------------------------------------------------------\n", "Negative Class Results (No PCOS)\n", "Precision (N): 87.76\n", "Recall (N): 87.76\n", "F1 Score (N): 87.76\n", "\n", "-------------------------------------------------------\n", "Positive Class Results (PCOS)\n", "Precision (P): 90.72\n", "Recall (P): 85.85\n", "F1 Score (P): 88.22\n", "Classification Report (Training Data):\n", " precision recall f1-score support\n", "\n", " 0 0.82 0.88 0.85 147\n", " 1 0.91 0.86 0.88 205\n", "\n", " accuracy 0.87 352\n", " macro avg 0.86 0.87 0.86 352\n", "weighted avg 0.87 0.87 0.87 352\n", "\n", "ROC AUC Score (Training Data): 0.9386095901775343\n", "\n", "--- Test Data Evaluation ---\n", "Accuracy: 92.05\n", "True Negative: 45\n", "True Positive: 36\n", "False Positive: 4\n", "False Negative: 3\n", "\n", "-------------------------------------------------------\n", "Negative Class Results (No PCOS)\n", "Precision (N): 91.84\n", "Recall (N): 91.84\n", "F1 Score (N): 91.84\n", "\n", "-------------------------------------------------------\n", "Positive Class Results (PCOS)\n", "Precision (P): 90.00\n", "Recall (P): 92.31\n", "F1 Score (P): 91.14\n", "Classification Report (Test Data):\n", " precision recall f1-score support\n", "\n", " 0 0.94 0.92 0.93 49\n", " 1 0.90 0.92 0.91 39\n", "\n", " accuracy 0.92 88\n", " macro avg 0.92 0.92 0.92 88\n", "weighted avg 0.92 0.92 0.92 88\n", "\n", "ROC AUC Score (Test Data): 0.9586603872318158\n" ] } ], "source": [ "from sklearn.linear_model import LogisticRegression\n", "from sklearn.metrics import classification_report, roc_auc_score\n", "import joblib\n", "\n", "# Train Logistic Regression model\n", "log_reg = LogisticRegression(random_state=0, max_iter=1000)\n", "log_reg.fit(X_train, y_train.values.ravel())\n", "\n", "# Save the trained model\n", "model_filename = \"logistic_regression_model.pkl\"\n", "joblib.dump(log_reg, model_filename)\n", "print(f\"Model has been saved as {model_filename}\")\n", "\n", "# Predictions & Probabilities - Training Data\n", "y_pred_train = log_reg.predict(X_train)\n", "y_pred_proba_train = log_reg.predict_proba(X_train)[:, 1]\n", "\n", "# Evaluate on Training Data\n", "print(\"\\n--- Training Data Evaluation ---\")\n", "test_results(log_reg, X_train, y_train)\n", "print(\"Classification Report (Training Data):\\n\", classification_report(y_train, y_pred_train))\n", "print(\"ROC AUC Score (Training Data):\", roc_auc_score(y_train, y_pred_proba_train))\n", "\n", "# Predictions & Probabilities - Test Data\n", "y_pred = log_reg.predict(X_test)\n", "y_pred_proba = log_reg.predict_proba(X_test)[:, 1]\n", "\n", "# Evaluate on Test Data\n", "print(\"\\n--- Test Data Evaluation ---\")\n", "test_results(log_reg, X_test, y_test)\n", "print(\"Classification Report (Test Data):\\n\", classification_report(y_test, y_pred))\n", "print(\"ROC AUC Score (Test Data):\", roc_auc_score(y_test, y_pred_proba))\n" ] }, { "cell_type": "code", "execution_count": 173, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 93.18\n", "True Negative: 46\n", "True Positive: 36\n", "False Positive: 3\n", "False Negative: 3\n", "\n", "-------------------------------------------------------\n", "Negative Class Results (No PCOS)\n", "Precision (N): 93.88\n", "Recall (N): 93.88\n", "F1 Score (N): 93.88\n", "\n", "-------------------------------------------------------\n", "Positive Class Results (PCOS)\n", "Precision (P): 92.31\n", "Recall (P): 92.31\n", "F1 Score (P): 92.31\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.94 0.94 0.94 49\n", " 1 0.92 0.92 0.92 39\n", "\n", " accuracy 0.93 88\n", " macro avg 0.93 0.93 0.93 88\n", "weighted avg 0.93 0.93 0.93 88\n", "\n", "ROC AUC Score: 0.9602302459445317\n" ] } ], "source": [ "\n", "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": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best Parameters: {'C': 1.0, 'class_weight': 'balanced', 'l1_ratio': 0.5, 'max_iter': 200, 'penalty': 'l1', 'solver': 'saga'}\n", "Best F1-Score (Weighted): 0.8663439708166745\n" ] } ], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "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": 223, "metadata": {}, "output_type": "execute_result" } ], "source": [] }, { "cell_type": "code", "execution_count": 242, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best Parameters: {'C': 1, 'penalty': 'l2', 'solver': 'liblinear'}\n", "Best F1-Score (Weighted): 0.8577525433911326\n" ] } ], "source": [ "from sklearn.model_selection import StratifiedKFold, GridSearchCV\n", "from sklearn.linear_model import LogisticRegression\n", "from yellowbrick.model_selection import CVScores\n", "\n", "# --- Use StratifiedKFold with 10 folds ---\n", "cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)\n", "\n", "# Define the parameter grid\n", "param_grid = [\n", " {'solver': ['liblinear'], 'penalty': ['l2', 'l1'], 'C': [0.1, 1, 10]},\n", " {'solver': ['saga'], 'penalty': ['l2', 'l1', 'elasticnet'], 'C': [0.1, 1, 10], 'l1_ratio': [0.5]}\n", "]\n", "\n", "# Initialize Logistic Regression model\n", "log_reg = LogisticRegression(random_state=42)\n", "\n", "# Set up GridSearchCV with correct parameters\n", "grid_search = GridSearchCV(\n", " estimator=log_reg,\n", " param_grid=param_grid,\n", " scoring='f1_weighted', # Focus on F1 score (weighted)\n", " cv=cv, # 10-Fold Cross-validation\n", " n_jobs=-1,\n", " error_score='raise'\n", ")\n", "\n", "# Fit the model to the training data\n", "grid_search.fit(X_train, y_train)\n", "\n", "# Check the best parameters and score\n", "print(\"Best Parameters:\", grid_search.best_params_)\n", "print(\"Best F1-Score (Weighted):\", grid_search.best_score_)" ] }, { "cell_type": "code", "execution_count": 243, "metadata": {}, "outputs": [], "source": [ "best_model = grid_search.best_estimator_\n" ] }, { "cell_type": "code", "execution_count": 244, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 244, "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": 245, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10-Fold CV Mean F1-Score: 0.8505\n", "10-Fold CV Score Standard Deviation: 0.0360\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": 246, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
LogisticRegression(C=0.1, class_weight='balanced', random_state=0,\n",
       "                   solver='saga')
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='saga')" ] }, "execution_count": 246, "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": 247, "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": 248, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 94.32\n", "True Negative: 47\n", "True Positive: 36\n", "False Positive: 2\n", "False Negative: 3\n", "\n", "-------------------------------------------------------\n", "Negative Class Results (No PCOS)\n", "Precision (N): 95.92\n", "Recall (N): 95.92\n", "F1 Score (N): 95.92\n", "\n", "-------------------------------------------------------\n", "Positive Class Results (PCOS)\n", "Precision (P): 94.74\n", "Recall (P): 92.31\n", "F1 Score (P): 93.51\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.92 1.00 0.96 49\n", " 1 1.00 0.90 0.95 39\n", "\n", " accuracy 0.95 88\n", " macro avg 0.96 0.95 0.95 88\n", "weighted avg 0.96 0.95 0.95 88\n", "\n", "ROC AUC Score: 0.9654631083202512\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": 249, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 249, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Visualize confusion matrix using Yellowbrick\n", "cm = ConfusionMatrix(final_model, classes=['Negative', 'Positive'])\n", "cm.score(X_test_scaled, y_test)\n", "cm.show()" ] }, { "cell_type": "code", "execution_count": 250, "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.56\n", "AUC: 0.95\n" ] } ], "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]\n", "# 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": 251, "metadata": {}, "outputs": [], "source": [ "import pickle\n", "filename='nonclinical_LR_model.pkl'\n", "pickle.dump(final_model, open(filename, 'wb'))\n", "\n", "loaded_model = pickle.load(open(filename, 'rb'))" ] }, { "cell_type": "code", "execution_count": 259, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 94.32\n", "True Negative: 47\n", "True Positive: 36\n", "False Positive: 2\n", "False Negative: 3\n", "\n", "-------------------------------------------------------\n", "Negative Class Results (No PCOS)\n", "Precision (N): 95.92\n", "Recall (N): 95.92\n", "F1 Score (N): 95.92\n", "\n", "-------------------------------------------------------\n", "Positive Class Results (PCOS)\n", "Precision (P): 94.74\n", "Recall (P): 92.31\n", "F1 Score (P): 93.51\n", "Classification Report on Test Set:\n", " precision recall f1-score support\n", "\n", " 0 0.94 0.96 0.95 49\n", " 1 0.95 0.92 0.94 39\n", "\n", " accuracy 0.94 88\n", " macro avg 0.94 0.94 0.94 88\n", "weighted avg 0.94 0.94 0.94 88\n", "\n", "Confusion Matrix on Test Set:\n", " [[47 2]\n", " [ 3 36]]\n" ] } ], "source": [ "# Assuming you have your test set X_test, y_test already defined\n", "test_results(final_model, X_test, y_test)\n", "# Make predictions on the test set\n", "y_pred_test = final_model.predict(X_test)\n", "\n", "# Calculate performance metrics on the test set\n", "from sklearn.metrics import classification_report, confusion_matrix\n", "\n", "# Print classification report to get precision, recall, F1 score\n", "print(\"Classification Report on Test Set:\\n\", classification_report(y_test, y_pred_test))\n", "\n", "# Confusion matrix to understand true positives, false positives, etc.\n", "print(\"Confusion Matrix on Test Set:\\n\", confusion_matrix(y_test, y_pred_test))" ] }, { "cell_type": "code", "execution_count": 254, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fragmented Non-Clinical Data:\n", " PCOS (Y/N) Skin darkening (Y/N) hair growth(Y/N) Weight gain(Y/N) \\\n", "0 0 0 0 0 \n", "1 0 0 0 0 \n", "2 1 0 0 0 \n", "3 0 0 0 0 \n", "4 0 0 0 0 \n", "\n", " Fast food (Y/N) Pimples(Y/N) Age (yrs) BMI \n", "0 1.0 0 28 19.3 \n", "1 0.0 0 36 24.9 \n", "2 1.0 1 33 25.3 \n", "3 0.0 0 37 29.7 \n", "4 0.0 0 25 20.1 \n" ] } ], "source": [ "# Display the fragmented dataset after selecting non-clinical factors\n", "print(\"Fragmented Non-Clinical Data:\")\n", "print(non_clinical_data.head()) " ] }, { "cell_type": "code", "execution_count": 258, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Predicted Class: 0\n", "Prediction Probability for Class 1 (PCOS Yes): 0.4045777527233318\n" ] } ], "source": [ "import numpy as np\n", "import pandas as pd\n", "import joblib\n", "\n", "# Load the trained model\n", "loaded_model = joblib.load('logistic_regression_model.pkl')\n", "\n", "# Prepare the input data for prediction\n", "# The order of features should be the same as in the training set\n", "input_data = np.array([[0, 0, 0, 1, 1, 33, 25.3]]) \n", "\n", "# Define the column names based on the features used during training\n", "feature_columns = [\n", " \"Skin darkening (Y/N)\", # Make sure these match the training data\n", " \"hair growth(Y/N)\",\n", " \"Weight gain(Y/N)\",\n", " \"Fast food (Y/N)\",\n", " \"Pimples(Y/N)\",\n", " \"Age (yrs)\",\n", " \"BMI\"\n", "]\n", "\n", "# Convert input data to DataFrame with proper column names\n", "input_data_df = pd.DataFrame(input_data, columns=feature_columns)\n", "\n", "# Make the prediction using the trained model\n", "prediction = loaded_model.predict(input_data_df)\n", "\n", "# Print the predicted class (0 or 1)\n", "print(f\"Predicted Class: {prediction[0]}\")\n", "\n", "# If you need the prediction probability for class 1 (PCOS = Yes)\n", "y_prob = loaded_model.predict_proba(input_data_df)[:, 1]\n", "print(f\"Prediction Probability for Class 1 (PCOS Yes): {y_prob[0]}\")" ] }, { "cell_type": "code", "execution_count": 257, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Predicted Class: 0\n", "Prediction Probability for Class 1 (PCOS Yes): 0.27319456376880163\n" ] } ], "source": [ "import numpy as np\n", "import pandas as pd\n", "import joblib\n", "\n", "# Load the trained model\n", "loaded_model = joblib.load('logistic_regression_model.pkl')\n", "\n", "# Prepare the input data for prediction\n", "# The order of features should be the same as in the training set\n", "input_data = np.array([[0, 0, 0, 1, 0, 28, 19.3]]) \n", "\n", "# Define the column names based on the features used during training\n", "feature_columns = [\n", " \"Skin darkening (Y/N)\", # Make sure these match the training data\n", " \"hair growth(Y/N)\",\n", " \"Weight gain(Y/N)\",\n", " \"Fast food (Y/N)\",\n", " \"Pimples(Y/N)\",\n", " \"Age (yrs)\",\n", " \"BMI\"\n", "]\n", "\n", "# Convert input data to DataFrame with proper column names\n", "input_data_df = pd.DataFrame(input_data, columns=feature_columns)\n", "\n", "# Make the prediction using the trained model\n", "prediction = loaded_model.predict(input_data_df)\n", "\n", "# Print the predicted class (0 or 1)\n", "print(f\"Predicted Class: {prediction[0]}\")\n", "\n", "# If you need the prediction probability for class 1 (PCOS = Yes)\n", "y_prob = loaded_model.predict_proba(input_data_df)[:, 1]\n", "print(f\"Prediction Probability for Class 1 (PCOS Yes): {y_prob[0]}\")" ] }, { "cell_type": "code", "execution_count": 256, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model saved as 'logistic_regression_model.pkl'\n", "MinMaxScaler saved as 'minmax_scaler.pkl'\n" ] } ], "source": [ "import joblib\n", "\n", "\n", "# Save the trained model\n", "joblib.dump(final_model, 'logistic_regression_model.pkl')\n", "\n", "print(\"Model saved as 'logistic_regression_model.pkl'\")\n", "\n", "# Save the MinMaxScaler\n", "joblib.dump(scaler, 'minmax_scaler.pkl')\n", "\n", "print(\"MinMaxScaler saved as 'minmax_scaler.pkl'\")" ] }, { "cell_type": "code", "execution_count": 260, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 85.23\n", "True Negative: 132\n", "True Positive: 168\n", "False Positive: 15\n", "False Negative: 37\n", "\n", "-------------------------------------------------------\n", "Negative Class Results (No PCOS)\n", "Precision (N): 89.80\n", "Recall (N): 89.80\n", "F1 Score (N): 89.80\n", "\n", "-------------------------------------------------------\n", "Positive Class Results (PCOS)\n", "Precision (P): 91.80\n", "Recall (P): 81.95\n", "F1 Score (P): 86.60\n", "Classification Report (Training Data):\n", " precision recall f1-score support\n", "\n", " 0 0.78 0.90 0.84 147\n", " 1 0.92 0.82 0.87 205\n", "\n", " accuracy 0.85 352\n", " macro avg 0.85 0.86 0.85 352\n", "weighted avg 0.86 0.85 0.85 352\n", "\n", "ROC AUC Score (Training Data): 0.9277916044466566\n" ] } ], "source": [ "y_pred_train = final_model.predict(X_train)\n", "y_pred_proba_train = final_model.predict_proba(X_train)[:, 1]\n", "\n", "test_results(final_model, X_train, y_train)\n", "\n", "print(\"Classification Report (Training Data):\\n\", classification_report(y_train, y_pred_train))\n", "print(\"ROC AUC Score (Training Data):\", roc_auc_score(y_train, y_pred_proba_train))\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 }