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.
DecisionTreeClassifier(random_state=42)
"
],
"text/plain": [
"DecisionTreeClassifier(random_state=42)"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Train a decision tree classifier\n",
"model = DecisionTreeClassifier(random_state=42)\n",
"model.fit(X_train, y_train)"
]
},
{
"cell_type": "code",
"execution_count": 38,
"id": "696f2083-2c1d-4d57-b2d1-c58d3366c26a",
"metadata": {},
"outputs": [],
"source": [
"y_pred = model.predict(X_test)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"id": "638c9296-7213-4db7-838a-41ba93583846",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Accuracy: 0.7467532467532467\n"
]
}
],
"source": [
"accuracy = accuracy_score(y_test, y_pred)\n",
"print(\"Accuracy:\", accuracy)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"id": "e8fda619-ab5b-4322-999b-7f14d73994a4",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Training Accuracy: 1.00\n",
"Testing Accuracy: 0.75\n"
]
}
],
"source": [
"# Accuracy on training data (how well model learned)\n",
"train_accuracy = model.score(X_train, y_train)\n",
"\n",
"# Accuracy on testing data (how well model performs on unseen data)\n",
"test_accuracy = model.score(X_test, y_test)\n",
"\n",
"print(f\"Training Accuracy: {train_accuracy:.2f}\") # e.g., 0.85 means 85%\n",
"print(f\"Testing Accuracy: {test_accuracy:.2f}\")\n"
]
},
{
"cell_type": "markdown",
"id": "fb96d4e1-fdfb-458c-9bfc-7b228d50c56c",
"metadata": {},
"source": [
"Here is Comparison of \n",
"Decision Tree,\n",
"Random Forest,\n",
"Naïve Bayes,\n",
"SVM (Linear),\n",
"SVM (RBF)\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "c04e8431-7312-4040-931c-adc2d8875480",
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.tree import DecisionTreeClassifier\n",
"from sklearn.ensemble import RandomForestClassifier\n",
"from sklearn.naive_bayes import GaussianNB\n",
"from sklearn.svm import SVC\n",
"from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "3df19501-f9e3-4f79-9fef-8569353d5031",
"metadata": {},
"outputs": [],
"source": [
"df = pd.read_csv('diabetes.csv')\n",
"X = df.drop('Outcome', axis=1)\n",
"y = df['Outcome']\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "4f892682-b735-43d5-84c5-b4618645e9f4",
"metadata": {},
"outputs": [],
"source": [
"models = {\n",
" 'Decision Tree': DecisionTreeClassifier(random_state=42),\n",
" 'Random Forest': RandomForestClassifier(random_state=42),\n",
" 'Naïve Bayes': GaussianNB(),\n",
" 'SVM (Linear)': SVC(kernel='linear', random_state=42),\n",
" 'SVM (RBF)': SVC(kernel='rbf', random_state=42)\n",
"}\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "cfbc9ac7-8ca2-4ba5-9d41-df2054def665",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Model Training Accuracy Test Accuracy Precision Recall \\\n",
"0 Decision Tree 1.000000 0.746753 0.637931 0.672727 \n",
"1 Random Forest 1.000000 0.753247 0.644068 0.690909 \n",
"2 Naïve Bayes 0.752443 0.759740 0.650000 0.709091 \n",
"3 SVM (Linear) 0.773616 0.766234 0.672727 0.672727 \n",
"4 SVM (RBF) 0.744300 0.746753 0.750000 0.436364 \n",
"\n",
" F1-score \n",
"0 0.654867 \n",
"1 0.666667 \n",
"2 0.678261 \n",
"3 0.672727 \n",
"4 0.551724 \n"
]
}
],
"source": [
"results = []\n",
"\n",
"for name, model in models.items():\n",
" # Train model\n",
" model.fit(X_train, y_train)\n",
" \n",
" # Predict on train and test data\n",
" y_train_pred = model.predict(X_train)\n",
" y_test_pred = model.predict(X_test)\n",
" \n",
" # Calculate metrics\n",
" train_acc = accuracy_score(y_train, y_train_pred)\n",
" test_acc = accuracy_score(y_test, y_test_pred)\n",
" precision = precision_score(y_test, y_test_pred)\n",
" recall = recall_score(y_test, y_test_pred)\n",
" f1 = f1_score(y_test, y_test_pred)\n",
" \n",
" # Store results\n",
" results.append({\n",
" 'Model': name,\n",
" 'Training Accuracy': train_acc,\n",
" 'Test Accuracy': test_acc,\n",
" 'Precision': precision,\n",
" 'Recall': recall,\n",
" 'F1-score': f1\n",
" })\n",
"\n",
"# Convert to DataFrame for a nice table\n",
"results_df = pd.DataFrame(results)\n",
"print(results_df)\n"
]
},
{
"cell_type": "markdown",
"id": "a738dcc8-ea0f-47d3-b6e0-614cecf7d6bd",
"metadata": {},
"source": [
"1. Which algorithm performed best on the test data? Why might that be the case?\n",
"\n",
"- SVM (Linear) has the highest test accuracy (76.6%) and a balanced F1-score (0.673).\n",
"- Naïve Bayes also has decent test accuracy (76.0%) with the best recall (0.709) and F1-score (0.678).\n",
"- So, SVM (Linear) performs best overall by test accuracy, possibly because the linear kernel fits the data well without overfitting.\n",
"- Naïve Bayes performs well despite its simple assumptions, likely because the dataset features somewhat satisfy independence.\n",
"\n",
"---\n",
"\n",
"2. Did any algorithm show signs of overfitting (high training accuracy, low test accuracy)?\n",
"\n",
"- Decision Tree and Random Forest have perfect training accuracy (1.0) but noticeably lower test accuracy (~74.7% and 75.3%).\n",
"- This suggests overfitting: they fit the training data perfectly but don’t generalize as well to unseen data.\n",
"- SVMs and Naïve Bayes have similar training and test accuracies, indicating better generalization.\n",
"\n",
"---\n",
"\n",
"3. How does Naïve Bayes handle correlated features compared to Decision Tree or SVM?\n",
"\n",
"- Despite Naïve Bayes assuming feature independence, it achieved good results (Test Accuracy 76%, F1 0.678).\n",
"- This suggests that feature correlations in this dataset might not heavily degrade Naïve Bayes' performance.\n",
"- Decision Trees and SVMs don’t assume independence, so they model feature interactions better, but here Naïve Bayes still performs competitively.\n",
"\n",
"---\n",
"\n",
"4. Why might Random Forest outperform a single Decision Tree?\n",
"\n",
"- Random Forest slightly outperforms the Decision Tree on test accuracy (75.3% vs 74.7%) and F1-score (0.667 vs 0.655).\n",
"- This is because Random Forest combines many trees and averages results, reducing overfitting and variance compared to a single tree.\n",
"- However, in this case, the improvement is small, possibly due to dataset size or feature characteristics.\n",
"\n",
"---\n",
"\n",
"5. If you had to deploy a model for predicting diabetes, which one would you choose, and why?\n",
"\n",
"- SVM (Linear): best test accuracy and balanced metrics, good generalization.\n",
"- Naïve Bayes: fast, simple, good recall (important for health predictions to reduce false negatives).\n",
"- Random Forest: good balance of performance and robustness, but slight overfitting signs.\n",
"\n",
"Recommendation: Use SVM (Linear) for its accuracy and generalization. If interpretability or speed is critical, Naïve Bayes is a solid alternative.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "facdff69-a041-4ddc-9892-070549805db0",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "59711b17-fbc4-4268-a7df-1f782d28e63e",
"metadata": {},
"source": [
"Among all the models we tested, the SVM with a linear kernel did the best on the test data, with the highest accuracy of about 76.6% and a good balance between precision and recall (F1-score 0.673). This means the SVM (Linear) fits the data well without overfitting.\n",
"\n",
"Naïve Bayes also did pretty well, scoring 76% accuracy and the highest recall (0.709), which is important in medical diagnosis to catch as many positive cases as possible. Even though Naïve Bayes assumes that features are independent, it still worked well, suggesting this assumption wasn’t a big problem here.\n",
"\n",
"Both Decision Tree and Random Forest had perfect accuracy on the training data but performed worse on the test data, showing signs of overfitting. Random Forest did a bit better than a single Decision Tree because it combines many trees to make better predictions.\n",
"\n",
"The SVM with the RBF kernel had high precision but low recall, meaning it missed a lot of positive cases, which isn’t ideal for health-related predictions.\n",
"\n",
"Overall, I would choose the SVM (Linear) model for deployment because it generalizes well and performs best overall. If you need a simpler or faster model, Naïve Bayes is a good alternative. This shows how important it is to consider all metrics, not just accuracy, especially in healthcare.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c933446d-6f23-47dd-81c2-1a2c84fabdc3",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "anaconda-panel-2023.05-py310",
"language": "python",
"name": "conda-env-anaconda-panel-2023.05-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.11.5"
}
},
"nbformat": 4,
"nbformat_minor": 5
}