{ "cells": [ { "cell_type": "code", "execution_count": 25, "id": "c1393d1a-19f9-4d0a-a3d3-e73d99d0c888", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import seaborn as sns\n", "from sklearn.metrics import confusion_matrix\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 accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n", "from sklearn.metrics import classification_report" ] }, { "cell_type": "code", "execution_count": 4, "id": "7cb32767-05fa-4f46-8e49-6a399d898b36", "metadata": {}, "outputs": [], "source": [ "# Load the diabetes dataset\n", "diabetes = pd.read_csv('diabetes.csv')" ] }, { "cell_type": "code", "execution_count": 5, "id": "a96e6238-1125-438b-95a3-995126e1e5f1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset shape: (768, 10)\n", "\n", "First 5 rows of the dataset:\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" ] } ], "source": [ "print(\"Dataset shape:\", diabetes.shape)\n", "print(\"\\nFirst 5 rows of the dataset:\")\n", "print(diabetes.head())" ] }, { "cell_type": "code", "execution_count": 6, "id": "d7ea2089-6f4e-4f44-b31f-1da40da12ef0", "metadata": {}, "outputs": [], "source": [ "X = diabetes.drop('Outcome', axis=1)\n", "y = diabetes['Outcome']" ] }, { "cell_type": "code", "execution_count": 7, "id": "ed8f358e-f62e-40ee-ac98-6de34e88acc4", "metadata": {}, "outputs": [], "source": [ "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)" ] }, { "cell_type": "code", "execution_count": 8, "id": "49108751-1c67-4099-8c7e-1444e0752b31", "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": 9, "id": "d64485db-ae35-4d91-829c-4265887d7ed6", "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": 10, "id": "e1c78308-b1f0-4515-a79d-ae66848ef9dd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "SVM Linear Results:\n", "Training - Accuracy: 0.7720, Precision: 0.7239, Recall: 0.5540, F1: 0.6277\n", "Testing - Accuracy: 0.7532, Precision: 0.6545, Recall: 0.6545, F1: 0.6545\n", "Overfitting indicator (train_acc - test_acc): 0.0187\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.81 0.81 0.81 99\n", " 1 0.65 0.65 0.65 55\n", "\n", " accuracy 0.75 154\n", " macro avg 0.73 0.73 0.73 154\n", "weighted avg 0.75 0.75 0.75 154\n", "\n", "\n", "SVM RBF Results:\n", "Training - Accuracy: 0.8306, Precision: 0.8225, Recall: 0.6526, F1: 0.7277\n", "Testing - Accuracy: 0.7597, Precision: 0.7045, Recall: 0.5636, F1: 0.6263\n", "Overfitting indicator (train_acc - test_acc): 0.0709\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.78 0.87 0.82 99\n", " 1 0.70 0.56 0.63 55\n", "\n", " accuracy 0.76 154\n", " macro avg 0.74 0.72 0.72 154\n", "weighted avg 0.75 0.76 0.75 154\n", "\n", "\n", "Decision Tree Results:\n", "Training - Accuracy: 1.0000, Precision: 1.0000, Recall: 1.0000, F1: 1.0000\n", "Testing - Accuracy: 0.7468, Precision: 0.6379, Recall: 0.6727, F1: 0.6549\n", "Overfitting indicator (train_acc - test_acc): 0.2532\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.81 0.79 0.80 99\n", " 1 0.64 0.67 0.65 55\n", "\n", " accuracy 0.75 154\n", " macro avg 0.73 0.73 0.73 154\n", "weighted avg 0.75 0.75 0.75 154\n", "\n", "\n", "Random Forest Results:\n", "Training - Accuracy: 1.0000, Precision: 1.0000, Recall: 1.0000, F1: 1.0000\n", "Testing - Accuracy: 0.7532, Precision: 0.6441, Recall: 0.6909, F1: 0.6667\n", "Overfitting indicator (train_acc - test_acc): 0.2468\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.82 0.79 0.80 99\n", " 1 0.64 0.69 0.67 55\n", "\n", " accuracy 0.75 154\n", " macro avg 0.73 0.74 0.74 154\n", "weighted avg 0.76 0.75 0.76 154\n", "\n", "\n", "Naive Bayes Results:\n", "Training - Accuracy: 0.7524, Precision: 0.6631, Recall: 0.5822, F1: 0.6200\n", "Testing - Accuracy: 0.7597, Precision: 0.6500, Recall: 0.7091, F1: 0.6783\n", "Overfitting indicator (train_acc - test_acc): -0.0073\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.83 0.79 0.81 99\n", " 1 0.65 0.71 0.68 55\n", "\n", " accuracy 0.76 154\n", " macro avg 0.74 0.75 0.74 154\n", "weighted avg 0.77 0.76 0.76 154\n", "\n" ] } ], "source": [ "for name, clf in classifiers.items():\n", "\n", " clf.fit(X_train_scaled, y_train)\n", " \n", " y_train_pred = clf.predict(X_train_scaled)\n", " y_test_pred = clf.predict(X_test_scaled)\n", " \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", " 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", " results[name] = {\n", " 'train_accuracy': train_accuracy,\n", " 'train_precision': train_precision,\n", " 'train_recall': train_recall,\n", " 'train_f1': train_f1,\n", " 'test_accuracy': test_accuracy,\n", " 'test_precision': test_precision,\n", " 'test_recall': test_recall,\n", " 'test_f1': test_f1,\n", " 'overfitting': train_accuracy - test_accuracy\n", " }\n", " \n", " print(f\"\\n{name} Results:\")\n", " print(f\"Training - Accuracy: {train_accuracy:.4f}, Precision: {train_precision:.4f}, Recall: {train_recall:.4f}, F1: {train_f1:.4f}\")\n", " print(f\"Testing - Accuracy: {test_accuracy:.4f}, Precision: {test_precision:.4f}, Recall: {test_recall:.4f}, F1: {test_f1:.4f}\")\n", " print(f\"Overfitting indicator (train_acc - test_acc): {train_accuracy - test_accuracy:.4f}\")\n", "\n", " print(\"\\nClassification Report (Test Set):\")\n", " print(classification_report(y_test, y_test_pred))\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "4ad53e4c-6580-437b-87bd-6ccfa57fe810", "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": 12, "id": "ac25c5df-7eb5-4de2-9f2e-7d7a3c8fbc12", "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", "}\n", "\n", "# Dictionary to store results\n", "results = {}" ] }, { "cell_type": "code", "execution_count": 13, "id": "cc631b0e-730f-485b-8601-3653e8e71ef5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "SVM Linear Results:\n", "Training - Accuracy: 0.7720, Precision: 0.7239, Recall: 0.5540, F1: 0.6277\n", "Testing - Accuracy: 0.7532, Precision: 0.6545, Recall: 0.6545, F1: 0.6545\n", "Overfitting indicator (train_acc - test_acc): 0.0187\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.81 0.81 0.81 99\n", " 1 0.65 0.65 0.65 55\n", "\n", " accuracy 0.75 154\n", " macro avg 0.73 0.73 0.73 154\n", "weighted avg 0.75 0.75 0.75 154\n", "\n", "\n", "SVM RBF Results:\n", "Training - Accuracy: 0.8306, Precision: 0.8225, Recall: 0.6526, F1: 0.7277\n", "Testing - Accuracy: 0.7597, Precision: 0.7045, Recall: 0.5636, F1: 0.6263\n", "Overfitting indicator (train_acc - test_acc): 0.0709\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.78 0.87 0.82 99\n", " 1 0.70 0.56 0.63 55\n", "\n", " accuracy 0.76 154\n", " macro avg 0.74 0.72 0.72 154\n", "weighted avg 0.75 0.76 0.75 154\n", "\n", "\n", "Decision Tree Results:\n", "Training - Accuracy: 1.0000, Precision: 1.0000, Recall: 1.0000, F1: 1.0000\n", "Testing - Accuracy: 0.7468, Precision: 0.6379, Recall: 0.6727, F1: 0.6549\n", "Overfitting indicator (train_acc - test_acc): 0.2532\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.81 0.79 0.80 99\n", " 1 0.64 0.67 0.65 55\n", "\n", " accuracy 0.75 154\n", " macro avg 0.73 0.73 0.73 154\n", "weighted avg 0.75 0.75 0.75 154\n", "\n", "\n", "Random Forest Results:\n", "Training - Accuracy: 1.0000, Precision: 1.0000, Recall: 1.0000, F1: 1.0000\n", "Testing - Accuracy: 0.7532, Precision: 0.6441, Recall: 0.6909, F1: 0.6667\n", "Overfitting indicator (train_acc - test_acc): 0.2468\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.82 0.79 0.80 99\n", " 1 0.64 0.69 0.67 55\n", "\n", " accuracy 0.75 154\n", " macro avg 0.73 0.74 0.74 154\n", "weighted avg 0.76 0.75 0.76 154\n", "\n", "\n", "Naive Bayes Results:\n", "Training - Accuracy: 0.7524, Precision: 0.6631, Recall: 0.5822, F1: 0.6200\n", "Testing - Accuracy: 0.7597, Precision: 0.6500, Recall: 0.7091, F1: 0.6783\n", "Overfitting indicator (train_acc - test_acc): -0.0073\n", "\n", "Classification Report (Test Set):\n", " precision recall f1-score support\n", "\n", " 0 0.83 0.79 0.81 99\n", " 1 0.65 0.71 0.68 55\n", "\n", " accuracy 0.76 154\n", " macro avg 0.74 0.75 0.74 154\n", "weighted avg 0.77 0.76 0.76 154\n", "\n" ] } ], "source": [ "for name, clf in classifiers.items():\n", " # Train the model\n", " clf.fit(X_train_scaled, y_train)\n", " \n", " # Predictions on training and test sets\n", " y_train_pred = clf.predict(X_train_scaled)\n", " y_test_pred = clf.predict(X_test_scaled)\n", " \n", " # Calculate metrics for training set\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", " # Calculate metrics for test set\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", " # Store results\n", " results[name] = {\n", " 'train_accuracy': train_accuracy,\n", " 'train_precision': train_precision,\n", " 'train_recall': train_recall,\n", " 'train_f1': train_f1,\n", " 'test_accuracy': test_accuracy,\n", " 'test_precision': test_precision,\n", " 'test_recall': test_recall,\n", " 'test_f1': test_f1,\n", " 'overfitting': train_accuracy - test_accuracy\n", " }\n", " \n", " # Print results for each classifier\n", " print(f\"\\n{name} Results:\")\n", " print(f\"Training - Accuracy: {train_accuracy:.4f}, Precision: {train_precision:.4f}, Recall: {train_recall:.4f}, F1: {train_f1:.4f}\")\n", " print(f\"Testing - Accuracy: {test_accuracy:.4f}, Precision: {test_precision:.4f}, Recall: {test_recall:.4f}, F1: {test_f1:.4f}\")\n", " print(f\"Overfitting indicator (train_acc - test_acc): {train_accuracy - test_accuracy:.4f}\")\n", " \n", " # Print classification report for test set\n", " print(\"\\nClassification Report (Test Set):\")\n", " print(classification_report(y_test, y_test_pred))\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "07490970-149e-4a6a-b9ac-cc83e9b468bb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Comparison of all models:\n", " SVM Linear SVM RBF Decision Tree Random Forest \\\n", "Train Accuracy 0.771987 0.830619 1.000000 1.000000 \n", "Test Accuracy 0.753247 0.759740 0.746753 0.753247 \n", "Train Precision 0.723926 0.822485 1.000000 1.000000 \n", "Test Precision 0.654545 0.704545 0.637931 0.644068 \n", "Train Recall 0.553991 0.652582 1.000000 1.000000 \n", "Test Recall 0.654545 0.563636 0.672727 0.690909 \n", "Train F1 0.627660 0.727749 1.000000 1.000000 \n", "Test F1 0.654545 0.626263 0.654867 0.666667 \n", "Overfitting 0.018740 0.070879 0.253247 0.246753 \n", "\n", " Naive Bayes \n", "Train Accuracy 0.752443 \n", "Test Accuracy 0.759740 \n", "Train Precision 0.663102 \n", "Test Precision 0.650000 \n", "Train Recall 0.582160 \n", "Test Recall 0.709091 \n", "Train F1 0.620000 \n", "Test F1 0.678261 \n", "Overfitting -0.007297 \n" ] } ], "source": [ "results_df = pd.DataFrame({\n", " model: {\n", " 'Train Accuracy': results[model]['train_accuracy'],\n", " 'Test Accuracy': results[model]['test_accuracy'],\n", " 'Train Precision': results[model]['train_precision'],\n", " 'Test Precision': results[model]['test_precision'],\n", " 'Train Recall': results[model]['train_recall'],\n", " 'Test Recall': results[model]['test_recall'],\n", " 'Train F1': results[model]['train_f1'],\n", " 'Test F1': results[model]['test_f1'],\n", " 'Overfitting': results[model]['overfitting']\n", " } for model in results\n", "})\n", "\n", "print(\"\\nComparison of all models:\")\n", "print(results_df)" ] }, { "cell_type": "code", "execution_count": 15, "id": "c68c6ea4-d112-41cf-bef0-15f0ac5b13d2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Models showing signs of overfitting:\n", "- Decision Tree (difference: 0.2532)\n", "- Random Forest (difference: 0.2468)\n" ] }, { "data": { "text/plain": [ "
" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "overfitting_threshold = 0.1 # 10% difference between train and test accuracy\n", "overfitting_models = [model for model, data in results.items() if data['overfitting'] > overfitting_threshold]\n", "print(\"\\nModels showing signs of overfitting:\")\n", "for model in overfitting_models:\n", " print(f\"- {model} (difference: {results[model]['overfitting']:.4f})\")\n", "\n", "# Visualize the results\n", "plt.figure(figsize=(15, 10))" ] }, { "cell_type": "code", "execution_count": 16, "id": "fd6b4ef5-3585-4c61-b358-296c54c22b59", "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.subplot(2, 2, 1)\n", "models = list(results.keys())\n", "train_acc = [results[model]['train_accuracy'] for model in models]\n", "test_acc = [results[model]['test_accuracy'] for model in models]\n", "\n", "x = np.arange(len(models))\n", "width = 0.35\n", "\n", "plt.bar(x - width/2, train_acc, width, label='Train')\n", "plt.bar(x + width/2, test_acc, width, label='Test')\n", "plt.xlabel('Models')\n", "plt.ylabel('Accuracy')\n", "plt.title('Train vs Test Accuracy')\n", "plt.xticks(x, models, rotation=45)\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 17, "id": "3b6b3112-d785-4fd7-927b-f5b1fb4ec038", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.subplot(2, 2, 2)\n", "train_f1 = [results[model]['train_f1'] for model in models]\n", "test_f1 = [results[model]['test_f1'] for model in models]\n", "\n", "plt.bar(x - width/2, train_f1, width, label='Train')\n", "plt.bar(x + width/2, test_f1, width, label='Test')\n", "plt.xlabel('Models')\n", "plt.ylabel('F1 Score')\n", "plt.title('Train vs Test F1 Score')\n", "plt.xticks(x, models, rotation=45)\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 18, "id": "9a0f321d-9c7f-491c-abdc-66a21392e366", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.subplot(2, 2, 3)\n", "train_recall = [results[model]['train_recall'] for model in models]\n", "test_recall = [results[model]['test_recall'] for model in models]\n", "\n", "plt.bar(x - width/2, train_recall, width, label='Train')\n", "plt.bar(x + width/2, test_recall, width, label='Test')\n", "plt.xlabel('Models')\n", "plt.ylabel('Recall')\n", "plt.title('Train vs Test Recall')\n", "plt.xticks(x, models, rotation=45)\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 19, "id": "c777d23e-c86b-4db8-92eb-7a9dd8a0ef36", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.subplot(2, 2, 4)\n", "overfitting = [results[model]['overfitting'] for model in models]\n", "\n", "plt.bar(x, overfitting, width, color=['red' if val > overfitting_threshold else 'green' for val in overfitting])\n", "plt.axhline(y=overfitting_threshold, color='r', linestyle='--', label=f'Threshold ({overfitting_threshold})')\n", "plt.xlabel('Models')\n", "plt.ylabel('Train-Test Difference')\n", "plt.title('Overfitting Analysis')\n", "plt.xticks(x, models, rotation=45)\n", "plt.legend()" ] }, { "cell_type": "code", "execution_count": 20, "id": "742480ca-65a1-42d9-b61e-e7ee34e56301", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 26, "id": "97d379c5-fad8-4d8f-942e-acff49add79d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Confusion Matrices:\n", "\n", "SVM Linear:\n", "Training confusion matrix not available\n", "\n", "SVM RBF:\n", "Training confusion matrix not available\n", "\n", "Decision Tree:\n", "Training confusion matrix not available\n", "\n", "Random Forest:\n", "Training confusion matrix not available\n", "\n", "Naive Bayes:\n", "Training confusion matrix not available\n" ] } ], "source": [ "print(\"\\nConfusion Matrices:\")\n", "for model_name in models:\n", " print(f\"\\n{model_name}:\")\n", " \n", " # Get predictions for training data\n", " y_train_pred = results[model_name].get('train_predictions')\n", " if y_train_pred is not None and 'y_train' in locals():\n", " # Calculate confusion matrix if not already in results\n", " if 'train_confusion_matrix' not in results[model_name]:\n", " results[model_name]['train_confusion_matrix'] = confusion_matrix(y_train, y_train_pred)\n", " \n", " print(\"Training Confusion Matrix:\")\n", " print(results[model_name]['train_confusion_matrix'])\n", " else:\n", " print(\"Training confusion matrix not available\")\n", " " ] }, { "cell_type": "code", "execution_count": null, "id": "84b768b9-b583-4cdd-b7c2-6c193cf382fd", "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 }