{ "cells": [ { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "from sklearn.model_selection import train_test_split, StratifiedKFold, GridSearchCV\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.metrics import classification_report, roc_auc_score, confusion_matrix, roc_curve\n", "from imblearn.combine import SMOTEENN\n", "from sklearn.preprocessing import MinMaxScaler\n", "import joblib\n", "import matplotlib.pyplot as plt\n", "from yellowbrick.classifier import ConfusionMatrix" ] }, { "cell_type": "code", "execution_count": 3, "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": 4, "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": 5, "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", " \n", " print(\"Negative Class Results (No PCOS)\")\n", " precision_n = tn / (tn + fp) \n", " recall_n = tn / (tn + fp) \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", " \n", " print(\"Positive Class Results (PCOS)\")\n", " precision_p = tp / (tp + fp) \n", " recall_p = 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))" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "\n", "\n", "pcos_data = pd.read_csv(\"new_pcos_dataset.csv\")" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "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": 8, "metadata": {}, "outputs": [], "source": [ "# --- Drop Missing Values ---\n", "non_clinical_data = non_clinical_data.dropna()\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "X = non_clinical_data.drop(columns=[\"PCOS (Y/N)\"])\n", "y = non_clinical_data[\"PCOS (Y/N)\"]" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "\n", "smoteenn = SMOTEENN(random_state=42)\n", "X_resampled, y_resampled = smoteenn.fit_resample(X, y)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "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": 12, "metadata": {}, "outputs": [], "source": [ "scaler = MinMaxScaler()\n", "X_train_scaled = scaler.fit_transform(X_train)\n", "X_test_scaled = scaler.transform(X_test)" ] }, { "cell_type": "code", "execution_count": 13, "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": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.linear_model import LogisticRegression\n", "from sklearn.metrics import classification_report, roc_auc_score\n", "import joblib\n", "log_reg = LogisticRegression(random_state=0, max_iter=1000)\n", "log_reg.fit(X_train, y_train.values.ravel())" ] }, { "cell_type": "code", "execution_count": 14, "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": 15, "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": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "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:\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: 0.9586603872318158\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": 17, "metadata": {}, "outputs": [], "source": [ "\n", "param_grid = [\n", " {'solver': ['liblinear'], 'penalty': ['l1', 'l2'], 'C': [0.1, 1, 10], 'class_weight': ['balanced']},\n", " {'solver': ['saga'], 'penalty': ['l1', 'l2', 'elasticnet'], 'C': [0.1, 1, 10], 'l1_ratio': [0.5], 'class_weight': ['balanced']}\n", "]" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)\n", "grid_search = GridSearchCV(\n", " estimator=LogisticRegression(random_state=42, max_iter=1000),\n", " param_grid=param_grid,\n", " scoring='f1_weighted',\n", " cv=cv,\n", " n_jobs=-1,\n", " error_score='raise'\n", ")" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
GridSearchCV(cv=StratifiedKFold(n_splits=10, random_state=42, shuffle=True),\n",
       "             error_score='raise',\n",
       "             estimator=LogisticRegression(max_iter=1000, random_state=42),\n",
       "             n_jobs=-1,\n",
       "             param_grid=[{'C': [0.1, 1, 10], 'class_weight': ['balanced'],\n",
       "                          'penalty': ['l1', 'l2'], 'solver': ['liblinear']},\n",
       "                         {'C': [0.1, 1, 10], 'class_weight': ['balanced'],\n",
       "                          'l1_ratio': [0.5],\n",
       "                          'penalty': ['l1', 'l2', 'elasticnet'],\n",
       "                          'solver': ['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=42, shuffle=True),\n", " error_score='raise',\n", " estimator=LogisticRegression(max_iter=1000, random_state=42),\n", " n_jobs=-1,\n", " param_grid=[{'C': [0.1, 1, 10], 'class_weight': ['balanced'],\n", " 'penalty': ['l1', 'l2'], 'solver': ['liblinear']},\n", " {'C': [0.1, 1, 10], 'class_weight': ['balanced'],\n", " 'l1_ratio': [0.5],\n", " 'penalty': ['l1', 'l2', 'elasticnet'],\n", " 'solver': ['saga']}],\n", " scoring='f1_weighted')" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\n", "grid_search.fit(X_train_scaled, y_train)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best Parameters: {'C': 0.1, 'class_weight': 'balanced', 'penalty': 'l2', 'solver': 'liblinear'}\n", "Best F1-Score (Weighted): 0.8659154519542922\n" ] } ], "source": [ "best_model = grid_search.best_estimator_\n", "print(\"Best Parameters:\", grid_search.best_params_)\n", "print(\"Best F1-Score (Weighted):\", grid_search.best_score_)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "\n", "y_pred_train = best_model.predict(X_train_scaled)\n", "y_pred_proba_train = best_model.predict_proba(X_train_scaled)[:, 1]" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "--- Training Data Evaluation ---\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.9326364692218351\n" ] } ], "source": [ "print(\"\\n--- Training Data Evaluation ---\")\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" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "y_pred_test = best_model.predict(X_test_scaled)\n", "y_pred_proba_test = best_model.predict_proba(X_test_scaled)[:, 1]" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "--- Test Data Evaluation ---\n", "Classification Report (Test Data):\n", " precision recall f1-score support\n", "\n", " 0 0.94 0.98 0.96 49\n", " 1 0.97 0.92 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 (Test Data): 0.966509680795395\n" ] } ], "source": [ "print(\"\\n--- Test Data Evaluation ---\")\n", "print(\"Classification Report (Test Data):\\n\", classification_report(y_test, y_pred_test))\n", "print(\"ROC AUC Score (Test Data):\", roc_auc_score(y_test, y_pred_proba_test))" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cm = ConfusionMatrix(best_model, classes=['Negative', 'Positive'])\n", "cm.score(X_test_scaled, y_test)\n", "cm.show()" ] }, { "cell_type": "code", "execution_count": 27, "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.5097\n" ] } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from sklearn.metrics import roc_curve, roc_auc_score\n", "\n", "# Compute ROC curve\n", "fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba_test)\n", "roc_auc = roc_auc_score(y_test, y_pred_proba_test)\n", "\n", "# Compute Youden's J statistic to find the optimal threshold\n", "j_scores = tpr - fpr # J = TPR - FPR\n", "optimal_idx = np.argmax(j_scores) # Index of max J\n", "optimal_threshold = thresholds[optimal_idx]\n", "\n", "# Plot ROC Curve\n", "plt.figure(figsize=(8, 6))\n", "plt.plot(fpr, tpr, color='blue', label=f'ROC Curve (AUC = {roc_auc:.2f})')\n", "plt.plot([0, 1], [0, 1], color='gray', linestyle='--') # Diagonal line\n", "plt.scatter(fpr[optimal_idx], tpr[optimal_idx], color='red', label=f'Optimal Threshold = {optimal_threshold:.2f}', zorder=3)\n", "\n", "# Labels and legend\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\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:.4f}\")\n" ] }, { "cell_type": "code", "execution_count": 28, "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": 29, "metadata": {}, "outputs": [], "source": [ "# --- Load Model and Make Predictions ---\n", "loaded_model = joblib.load('logistic_regression_model.pkl')\n", "input_data = np.array([[1, 1, 1, 1, 1, 25, 32.0]]) \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", "input_data_scaled = scaler.transform(input_data)\n", "prediction = loaded_model.predict(input_data_scaled)\n", "prediction_proba = loaded_model.predict_proba(input_data_scaled)[:, 1]" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Predicted Class: 1\n", "Prediction Probability for Class 1 (PCOS Yes): 0.9997\n" ] } ], "source": [ "print(f\"Predicted Class: {prediction[0]}\")\n", "print(f\"Prediction Probability for Class 1 (PCOS Yes): {prediction_proba[0]:.4f}\")" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Scaler has been saved as minmax_scaler.pkl\n" ] } ], "source": [ "scaler_filename = \"minmax_scaler.pkl\"\n", "joblib.dump(scaler, scaler_filename)\n", "print(f\"Scaler has been saved as {scaler_filename}\")" ] } ], "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 }