{ "cells": [ { "cell_type": "code", "execution_count": 41, "id": "23be4e1a-6c0e-4a2d-9fef-d71e8ad3ed9a", "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.svm import SVC\n", "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.ensemble import RandomForestClassifier\n", "from sklearn.naive_bayes import GaussianNB\n", "from sklearn.metrics import classification_report, accuracy_score, precision_score, recall_score, f1_score\n" ] }, { "cell_type": "code", "execution_count": 42, "id": "48931f5e-4f9a-4d29-ab90-bc5e45e42713", "metadata": {}, "outputs": [], "source": [ "diabetes = pd.read_csv('diabetes.csv')" ] }, { "cell_type": "code", "execution_count": 43, "id": "43f38f09-ca66-4d98-8bbf-341faf3a6190", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset Preview:\n", " PatientId Pregnancies Glucose BloodPressure SkinThickness Insulin \\\n", "0 1 6 148 72 35 0 \n", "1 2 1 85 66 29 0 \n", "2 3 8 183 64 0 0 \n", "3 4 1 89 66 23 94 \n", "4 5 0 137 40 35 168 \n", "\n", " BMI DiabetesPedigreeFunction Age Outcome \n", "0 33.6 0.627 50 1 \n", "1 26.6 0.351 31 0 \n", "2 23.3 0.672 32 1 \n", "3 28.1 0.167 21 0 \n", "4 43.1 2.288 33 1 \n", "\n", "Dataset Info:\n", "\n", "RangeIndex: 768 entries, 0 to 767\n", "Data columns (total 10 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 PatientId 768 non-null int64 \n", " 1 Pregnancies 768 non-null int64 \n", " 2 Glucose 768 non-null int64 \n", " 3 BloodPressure 768 non-null int64 \n", " 4 SkinThickness 768 non-null int64 \n", " 5 Insulin 768 non-null int64 \n", " 6 BMI 768 non-null float64\n", " 7 DiabetesPedigreeFunction 768 non-null float64\n", " 8 Age 768 non-null int64 \n", " 9 Outcome 768 non-null int64 \n", "dtypes: float64(2), int64(8)\n", "memory usage: 60.1 KB\n", "None\n" ] } ], "source": [ "print(\"Dataset Preview:\")\n", "print(diabetes.head())\n", "print(\"\\nDataset Info:\")\n", "print(diabetes.info())" ] }, { "cell_type": "code", "execution_count": 44, "id": "8dd47376-cacb-4bb6-9942-290e3c6ef030", "metadata": {}, "outputs": [], "source": [ "X = diabetes.drop('Outcome', axis=1)\n", "y = diabetes['Outcome']" ] }, { "cell_type": "code", "execution_count": 45, "id": "38463bad-e204-4a7a-9614-c8aee067d830", "metadata": {}, "outputs": [], "source": [ "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)" ] }, { "cell_type": "code", "execution_count": 46, "id": "bd44e7b9-cd4f-4b4a-b166-7c5bdaa433bc", "metadata": {}, "outputs": [], "source": [ "scaler = StandardScaler()\n", "X_train_scaled = scaler.fit_transform(X_train)\n", "X_test_scaled = scaler.transform(X_test)" ] }, { "cell_type": "code", "execution_count": 47, "id": "e728b024-195c-454e-8547-707a935e7e11", "metadata": {}, "outputs": [], "source": [ "scaler = StandardScaler()\n", "X_train_scaled = scaler.fit_transform(X_train)\n", "X_test_scaled = scaler.transform(X_test)" ] }, { "cell_type": "code", "execution_count": 48, "id": "e58286e7-4f2c-4f34-8368-6156bcef0c8a", "metadata": {}, "outputs": [], "source": [ "classifiers = {\n", " 'SVM Linear': SVC(kernel='linear', random_state=42),\n", " 'SVM RBF': SVC(kernel='rbf', random_state=42),\n", " 'Decision Tree': DecisionTreeClassifier(random_state=42),\n", " 'Random Forest': RandomForestClassifier(random_state=42),\n", " 'Naive Bayes': GaussianNB()\n", "}" ] }, { "cell_type": "code", "execution_count": 49, "id": "21f9eaf4-9d9f-4186-b869-43cf34c2f95c", "metadata": {}, "outputs": [], "source": [ "results = {\n", " 'Classifier': [],\n", " 'Train Accuracy': [],\n", " 'Train Precision': [],\n", " 'Train Recall': [],\n", " 'Train F1': [],\n", " 'Test Accuracy': [],\n", " 'Test Precision': [],\n", " 'Test Recall': [],\n", " 'Test F1': []\n", "}\n" ] }, { "cell_type": "code", "execution_count": 50, "id": "b56a5df6-da1f-44e0-b090-10ee3ec1d713", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "--------------------------------------------------\n", "SVM Linear Results:\n", "--------------------------------------------------\n", "\n", "Training Metrics:\n", "Accuracy: 0.7821\n", "Precision: 0.7483\n", "Recall: 0.5691\n", "F1 Score: 0.6465\n", "\n", "Training Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.79 0.90 0.84 349\n", " 1 0.75 0.57 0.65 188\n", "\n", " accuracy 0.78 537\n", " macro avg 0.77 0.73 0.74 537\n", "weighted avg 0.78 0.78 0.77 537\n", "\n", "\n", "Testing Metrics:\n", "Accuracy: 0.7446\n", "Precision: 0.6329\n", "Recall: 0.6250\n", "F1 Score: 0.6289\n", "\n", "Testing Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.80 0.81 0.81 151\n", " 1 0.63 0.62 0.63 80\n", "\n", " accuracy 0.74 231\n", " macro avg 0.72 0.72 0.72 231\n", "weighted avg 0.74 0.74 0.74 231\n", "\n", "\n", "--------------------------------------------------\n", "SVM RBF Results:\n", "--------------------------------------------------\n", "\n", "Training Metrics:\n", "Accuracy: 0.8380\n", "Precision: 0.8483\n", "Recall: 0.6543\n", "F1 Score: 0.7387\n", "\n", "Training Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.83 0.94 0.88 349\n", " 1 0.85 0.65 0.74 188\n", "\n", " accuracy 0.84 537\n", " macro avg 0.84 0.80 0.81 537\n", "weighted avg 0.84 0.84 0.83 537\n", "\n", "\n", "Testing Metrics:\n", "Accuracy: 0.7489\n", "Precision: 0.6618\n", "Recall: 0.5625\n", "F1 Score: 0.6081\n", "\n", "Testing Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.79 0.85 0.82 151\n", " 1 0.66 0.56 0.61 80\n", "\n", " accuracy 0.75 231\n", " macro avg 0.72 0.71 0.71 231\n", "weighted avg 0.74 0.75 0.74 231\n", "\n", "\n", "--------------------------------------------------\n", "Decision Tree Results:\n", "--------------------------------------------------\n", "\n", "Training Metrics:\n", "Accuracy: 1.0000\n", "Precision: 1.0000\n", "Recall: 1.0000\n", "F1 Score: 1.0000\n", "\n", "Training Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 1.00 1.00 1.00 349\n", " 1 1.00 1.00 1.00 188\n", "\n", " accuracy 1.00 537\n", " macro avg 1.00 1.00 1.00 537\n", "weighted avg 1.00 1.00 1.00 537\n", "\n", "\n", "Testing Metrics:\n", "Accuracy: 0.6926\n", "Precision: 0.5506\n", "Recall: 0.6125\n", "F1 Score: 0.5799\n", "\n", "Testing Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.78 0.74 0.76 151\n", " 1 0.55 0.61 0.58 80\n", "\n", " accuracy 0.69 231\n", " macro avg 0.67 0.67 0.67 231\n", "weighted avg 0.70 0.69 0.70 231\n", "\n", "\n", "--------------------------------------------------\n", "Random Forest Results:\n", "--------------------------------------------------\n", "\n", "Training Metrics:\n", "Accuracy: 1.0000\n", "Precision: 1.0000\n", "Recall: 1.0000\n", "F1 Score: 1.0000\n", "\n", "Training Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 1.00 1.00 1.00 349\n", " 1 1.00 1.00 1.00 188\n", "\n", " accuracy 1.00 537\n", " macro avg 1.00 1.00 1.00 537\n", "weighted avg 1.00 1.00 1.00 537\n", "\n", "\n", "Testing Metrics:\n", "Accuracy: 0.7446\n", "Precision: 0.6235\n", "Recall: 0.6625\n", "F1 Score: 0.6424\n", "\n", "Testing Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.82 0.79 0.80 151\n", " 1 0.62 0.66 0.64 80\n", "\n", " accuracy 0.74 231\n", " macro avg 0.72 0.73 0.72 231\n", "weighted avg 0.75 0.74 0.75 231\n", "\n", "\n", "--------------------------------------------------\n", "Naive Bayes Results:\n", "--------------------------------------------------\n", "\n", "Training Metrics:\n", "Accuracy: 0.7691\n", "Precision: 0.7000\n", "Recall: 0.5957\n", "F1 Score: 0.6437\n", "\n", "Training Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.80 0.86 0.83 349\n", " 1 0.70 0.60 0.64 188\n", "\n", " accuracy 0.77 537\n", " macro avg 0.75 0.73 0.74 537\n", "weighted avg 0.76 0.77 0.76 537\n", "\n", "\n", "Testing Metrics:\n", "Accuracy: 0.7489\n", "Precision: 0.6310\n", "Recall: 0.6625\n", "F1 Score: 0.6463\n", "\n", "Testing Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.82 0.79 0.81 151\n", " 1 0.63 0.66 0.65 80\n", "\n", " accuracy 0.75 231\n", " macro avg 0.72 0.73 0.73 231\n", "weighted avg 0.75 0.75 0.75 231\n", "\n" ] } ], "source": [ "for name, clf in classifiers.items():\n", " print(f\"\\n{'-'*50}\")\n", " print(f\"{name} Results:\")\n", " print(f\"{'-'*50}\")\n", " \n", " # Train the model\n", " clf.fit(X_train_scaled, y_train)\n", " \n", " # Evaluate on training data\n", " y_train_pred = clf.predict(X_train_scaled)\n", " train_accuracy = accuracy_score(y_train, y_train_pred)\n", " train_precision = precision_score(y_train, y_train_pred)\n", " train_recall = recall_score(y_train, y_train_pred)\n", " train_f1 = f1_score(y_train, y_train_pred)\n", " \n", " print(f\"\\nTraining Metrics:\")\n", " print(f\"Accuracy: {train_accuracy:.4f}\")\n", " print(f\"Precision: {train_precision:.4f}\")\n", " print(f\"Recall: {train_recall:.4f}\")\n", " print(f\"F1 Score: {train_f1:.4f}\")\n", " print(\"\\nTraining Classification Report:\")\n", " print(classification_report(y_train, y_train_pred))\n", " \n", " # Evaluate on testing data\n", " y_test_pred = clf.predict(X_test_scaled)\n", " test_accuracy = accuracy_score(y_test, y_test_pred)\n", " test_precision = precision_score(y_test, y_test_pred)\n", " test_recall = recall_score(y_test, y_test_pred)\n", " test_f1 = f1_score(y_test, y_test_pred)\n", " \n", " print(f\"\\nTesting Metrics:\")\n", " print(f\"Accuracy: {test_accuracy:.4f}\")\n", " print(f\"Precision: {test_precision:.4f}\")\n", " print(f\"Recall: {test_recall:.4f}\")\n", " print(f\"F1 Score: {test_f1:.4f}\")\n", " print(\"\\nTesting Classification Report:\")\n", " print(classification_report(y_test, y_test_pred))\n", " \n", " # Store results\n", " results['Classifier'].append(name)\n", " results['Train Accuracy'].append(train_accuracy)\n", " results['Train Precision'].append(train_precision)\n", " results['Train Recall'].append(train_recall)\n", " results['Train F1'].append(train_f1)\n", " results['Test Accuracy'].append(test_accuracy)\n", " results['Test Precision'].append(test_precision)\n", " results['Test Recall'].append(test_recall)\n", " results['Test F1'].append(test_f1)" ] }, { "cell_type": "code", "execution_count": 51, "id": "3d1ff2a0-1428-4ba3-9e23-4ba4d863e594", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Summary of Results:\n", " Classifier Train Accuracy Train Precision Train Recall Train F1 \\\n", "0 SVM Linear 0.782123 0.748252 0.569149 0.646526 \n", "1 SVM RBF 0.837989 0.848276 0.654255 0.738739 \n", "2 Decision Tree 1.000000 1.000000 1.000000 1.000000 \n", "3 Random Forest 1.000000 1.000000 1.000000 1.000000 \n", "4 Naive Bayes 0.769088 0.700000 0.595745 0.643678 \n", "\n", " Test Accuracy Test Precision Test Recall Test F1 \n", "0 0.744589 0.632911 0.6250 0.628931 \n", "1 0.748918 0.661765 0.5625 0.608108 \n", "2 0.692641 0.550562 0.6125 0.579882 \n", "3 0.744589 0.623529 0.6625 0.642424 \n", "4 0.748918 0.630952 0.6625 0.646341 \n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "results_df = pd.DataFrame(results)\n", "print(\"\\nSummary of Results:\")\n", "print(results_df)\n", "\n", "# Visualize the results\n", "plt.figure(figsize=(15, 10))\n", "\n", "# Plot test metrics\n", "plt.subplot(2, 1, 1)\n", "bar_width = 0.2\n", "index = np.arange(len(classifiers))\n", "\n", "plt.bar(index, results_df['Test Accuracy'], bar_width, label='Accuracy')\n", "plt.bar(index + bar_width, results_df['Test Precision'], bar_width, label='Precision')\n", "plt.bar(index + 2*bar_width, results_df['Test Recall'], bar_width, label='Recall')\n", "plt.bar(index + 3*bar_width, results_df['Test F1'], bar_width, label='F1 Score')\n", "\n", "plt.xlabel('Classifier')\n", "plt.ylabel('Score')\n", "plt.title('Test Performance Metrics')\n", "plt.xticks(index + 1.5*bar_width, results_df['Classifier'])\n", "plt.legend()\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "c5364b6c-487d-4701-abef-d48f8dc53f1d", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "708201d9-69b2-496c-b0bc-99504773da6f", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "anaconda-2024.02-py310", "language": "python", "name": "conda-env-anaconda-2024.02-py310-py" }, "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.10.14" } }, "nbformat": 4, "nbformat_minor": 5 }