{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Example: Sleep Stage Classifier Evaluation using Accel & Heart Rate\n", "\n", "This notebook demonstrates the evaluation of a classifier for detecting sleep stages: Wakefulness, REM (Rapid Eye Movement), and NREM (Non-Rapid Eye Movement).\n", "- We'll generate synthetic data based on accelerometer and heart rate features.\n", "- We'll then create a simple classifier, and evaluate its performance using confusion matrix, precision, recall, and F1 score.\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "scrolled": true }, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "from scipy.signal import welch\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.metrics import confusion_matrix, precision_recall_fscore_support, accuracy_score, balanced_accuracy_score\n", "\n", "# Set random seed for reproducibility\n", "np.random.seed(42)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Synthetic Data Generation\n", "\n", "We'll create synthetic data to simulate accelerometer, heart rate, and heart rate variability (HRV) measurements for different sleep stages. This function generates data with the following characteristics:\n", "\n", "- Wakefulness: Higher accelerometer activity, higher heart rate, lower HRV\n", "- REM: Low accelerometer activity, slightly elevated heart rate, moderate HRV\n", "- NREM: Very low accelerometer activity, lower heart rate, higher HRV\n", "\n", "We then extract a bunch of features from the accelerometer and heart rate signals (e.g. min, max, mean, etc); we also extract some specialized features from heart rate corresponding to heart rate variability (e.g. rmssd, sdnn); and obtain the dominant frequency using the `welch` function from SciPy." ] }, { "cell_type": "code", "execution_count": 2, "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", "
accel_meanaccel_stdaccel_maxaccel_minaccel_medianaccel_dominant_freqhr_meanhr_stdhr_maxhr_minhrv_rmssdhrv_sdnnhrv_pnn50Stage
03.1601711.3699945.7363760.7702113.21868333.33333371.75427512.820519103.84706154.71114218.54397412.8205190.000000Wakefulness
12.7574891.1876615.7742160.8101582.6682056.66666770.22254211.53013093.63325243.95071814.82899811.5301300.000000Wakefulness
22.5836520.9600014.7126510.8577762.60019330.00000057.9356387.98652677.87484036.57234410.9917757.9865260.000000NREM
32.8327520.9835414.6337150.8368682.71745823.33333366.55752814.36407491.20921236.12214020.30496214.3640740.000000REM
42.8126971.0540195.0320760.9495562.84869236.66666770.13398812.177066113.35858543.79741919.26258412.1770666.896552Wakefulness
\n", "
" ], "text/plain": [ " accel_mean accel_std accel_max accel_min accel_median \\\n", "0 3.160171 1.369994 5.736376 0.770211 3.218683 \n", "1 2.757489 1.187661 5.774216 0.810158 2.668205 \n", "2 2.583652 0.960001 4.712651 0.857776 2.600193 \n", "3 2.832752 0.983541 4.633715 0.836868 2.717458 \n", "4 2.812697 1.054019 5.032076 0.949556 2.848692 \n", "\n", " accel_dominant_freq hr_mean hr_std hr_max hr_min \\\n", "0 33.333333 71.754275 12.820519 103.847061 54.711142 \n", "1 6.666667 70.222542 11.530130 93.633252 43.950718 \n", "2 30.000000 57.935638 7.986526 77.874840 36.572344 \n", "3 23.333333 66.557528 14.364074 91.209212 36.122140 \n", "4 36.666667 70.133988 12.177066 113.358585 43.797419 \n", "\n", " hrv_rmssd hrv_sdnn hrv_pnn50 Stage \n", "0 18.543974 12.820519 0.000000 Wakefulness \n", "1 14.828998 11.530130 0.000000 Wakefulness \n", "2 10.991775 7.986526 0.000000 NREM \n", "3 20.304962 14.364074 0.000000 REM \n", "4 19.262584 12.177066 6.896552 Wakefulness " ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def generate_synthetic_data(n_samples=1000, window_size=30, class_distribution=[0.5, 0.3, 0.2]):\n", " # Generate base signals\n", " time = np.arange(n_samples * window_size) / 100 # Assuming 100 Hz sampling rate\n", " accel_x = np.random.randn(n_samples * window_size)\n", " accel_y = np.random.randn(n_samples * window_size)\n", " accel_z = np.random.randn(n_samples * window_size)\n", " heart_rate = np.random.normal(60, 10, n_samples * window_size)\n", " \n", " # Generate labels\n", " labels = np.random.choice(['Wakefulness', 'REM', 'NREM'], n_samples, p=class_distribution)\n", " labels = np.repeat(labels, window_size)\n", " \n", " # Adjust signals based on sleep stage (with more overlap and noise)\n", " for i, label in enumerate(labels):\n", " if label == 'Wakefulness':\n", " accel_x[i] += np.random.normal(0, 1.2)\n", " accel_y[i] += np.random.normal(0, 1.2)\n", " accel_z[i] += np.random.normal(0, 1.2)\n", " heart_rate[i] += np.random.normal(10, 5)\n", " elif label == 'REM':\n", " accel_x[i] += np.random.normal(0, 0.9)\n", " accel_y[i] += np.random.normal(0, 0.9)\n", " accel_z[i] += np.random.normal(0, 0.9)\n", " heart_rate[i] += np.random.normal(5, 3)\n", " else: # NREM\n", " accel_x[i] += np.random.normal(0, 0.8)\n", " accel_y[i] += np.random.normal(0, 0.8)\n", " accel_z[i] += np.random.normal(0, 0.8)\n", " heart_rate[i] += np.random.normal(1, 2)\n", " \n", " # Add random noise to all signals\n", " accel_x += np.random.normal(0, 1, len(accel_x))\n", " accel_y += np.random.normal(0, 1, len(accel_y))\n", " accel_z += np.random.normal(0, 1, len(accel_z))\n", " heart_rate += np.random.normal(0, 5, len(heart_rate))\n", " \n", " # Calculate features for each window\n", " features = []\n", " for i in range(0, len(accel_x), window_size):\n", " window_x = accel_x[i:i+window_size]\n", " window_y = accel_y[i:i+window_size]\n", " window_z = accel_z[i:i+window_size]\n", " window_hr = heart_rate[i:i+window_size]\n", " \n", " # Accelerometer features\n", " accel_magnitude = np.sqrt(window_x**2 + window_y**2 + window_z**2)\n", " f, Pxx = welch(accel_magnitude, fs=100, nperseg=window_size)\n", " dominant_freq = f[np.argmax(Pxx)]\n", " \n", " accel_features = {\n", " 'accel_mean': np.mean(accel_magnitude),\n", " 'accel_std': np.std(accel_magnitude),\n", " 'accel_max': np.max(accel_magnitude),\n", " 'accel_min': np.min(accel_magnitude),\n", " 'accel_median': np.median(accel_magnitude),\n", " 'accel_dominant_freq': dominant_freq\n", " }\n", " \n", " # Heart rate features\n", " hr_diff = np.diff(window_hr)\n", " hrv_features = {\n", " 'hr_mean': np.mean(window_hr),\n", " 'hr_std': np.std(window_hr),\n", " 'hr_max': np.max(window_hr),\n", " 'hr_min': np.min(window_hr),\n", " 'hrv_rmssd': np.sqrt(np.mean(hr_diff**2)),\n", " 'hrv_sdnn': np.std(window_hr),\n", " 'hrv_pnn50': np.sum(np.abs(hr_diff) > 50) / len(hr_diff) * 100\n", " }\n", " \n", " features.append({**accel_features, **hrv_features, 'Stage': labels[i]})\n", " \n", " return pd.DataFrame(features)\n", "\n", "# Generate data\n", "data = generate_synthetic_data(2000)\n", "data.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Model Training and Evaluation\n", "\n", "After generating and preprocessing our synthetic sleep stage data, we now move on to training our model and evaluating its performance. This section covers the following steps:\n", "\n", "1. **Data Splitting**: We separate our features (X) and labels (y), then split them into training and testing sets.\n", "\n", "2. **Model Training**: We use a Decision Tree classifier to train on our data.\n", "\n", "3. **Prediction**: We use our trained model to make predictions on the test set.\n", "\n", "4. **Visualization**: We create a heatmap to visualize the confusion matrix, providing an intuitive representation of our model's performance.\n", "\n", "These steps allow us to assess how well our model distinguishes between Wakefulness, REM, and NREM sleep stages based on the synthetic accelerometer and heart rate data we generated.\n", "\n", "The confusion matrix will show us:\n", "- How many instances of each sleep stage were correctly classified (diagonal elements)\n", "- Where misclassifications occurred (off-diagonal elements)\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Overall Accuracy: 0.773\n", "Confusion Matrix:\n", "[[280 37 0]\n", " [ 33 98 29]\n", " [ 2 35 86]]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Split data into features (X) and labels (y)\n", "X = data.drop('Stage', axis=1)\n", "y = data['Stage']\n", "\n", "# Split into training and testing sets\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n", "\n", "# Train a Decision Tree classifier\n", "clf = DecisionTreeClassifier(random_state=42)\n", "clf.fit(X_train, y_train)\n", "\n", "# Make predictions\n", "y_pred = clf.predict(X_test)\n", "\n", "# Generate confusion matrix\n", "cm = confusion_matrix(y_test, y_pred, labels=['Wakefulness', 'REM', 'NREM'])\n", "\n", "# Calculate accuracy\n", "accuracy = accuracy_score(y_test, y_pred)\n", "\n", "# Calculate precision, recall, and F1 score\n", "precision, recall, f1, _ = precision_recall_fscore_support(y_test, y_pred, average=None, labels=['Wakefulness', 'REM', 'NREM'])\n", "\n", "# Display results\n", "print(f\"\\nOverall Accuracy: {accuracy:.3f}\")\n", "\n", "# Print the confusion matrix\n", "print(\"Confusion Matrix:\")\n", "print(cm)\n", "\n", "# Visualize the confusion matrix\n", "plt.figure(figsize=(5, 4))\n", "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', \n", " xticklabels=['Wakefulness', 'REM', 'NREM'],\n", " yticklabels=['Wakefulness', 'REM', 'NREM'])\n", "plt.title('Confusion Matrix')\n", "plt.xlabel('Predicted')\n", "plt.ylabel('Actual')\n", "plt.show()\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Precision, Recall and F1 score\n", "\n", "The precision, recall, and F1 scores provide additional insights into the model's performance for each sleep stage:\n", "- Precision: The proportion of correct positive predictions.\n", "- Recall: The proportion of actual positive cases that were correctly identified.\n", "- F1 Score: The harmonic mean of precision and recall, providing a balanced measure of the model's performance.\n", "\n", "Let's proceed with the code to perform these steps and evaluate our sleep stage classifier." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Precision, Recall, and F1 Score:\n", "╒═════════════╤═════════════╤══════════╤════════════╕\n", "│ │ Precision │ Recall │ F1 Score │\n", "╞═════════════╪═════════════╪══════════╪════════════╡\n", "│ Wakefulness │ 0.889 │ 0.883 │ 0.886 │\n", "├─────────────┼─────────────┼──────────┼────────────┤\n", "│ REM │ 0.576 │ 0.613 │ 0.594 │\n", "├─────────────┼─────────────┼──────────┼────────────┤\n", "│ NREM │ 0.748 │ 0.699 │ 0.723 │\n", "╘═════════════╧═════════════╧══════════╧════════════╛\n" ] } ], "source": [ "from tabulate import tabulate\n", "\n", "# Create a DataFrame for precision, recall, and F1 score\n", "results_df = pd.DataFrame({\n", " 'Precision': precision,\n", " 'Recall': recall,\n", " 'F1 Score': f1\n", "}, index=['Wakefulness', 'REM', 'NREM'])\n", "\n", "# Format the DataFrame as a pretty table\n", "table = tabulate(results_df, headers='keys', tablefmt='fancy_grid', floatfmt='.3f')\n", "\n", "# Display results as a table\n", "print(\"\\nPrecision, Recall, and F1 Score:\")\n", "print(table)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Feature Importance Analysis\n", "\n", "After training our Decision Tree classifier and evaluating its performance, we now turn our attention to understanding which features contribute most significantly to the model's decision-making process. This analysis is crucial for several reasons:\n", "\n", "1. **Model Interpretability**: It helps us understand which aspects of the accelerometer and heart rate data are most influential in distinguishing between sleep stages.\n", "\n", "2. **Feature Selection**: Identifying the most important features can guide future data collection efforts and potentially simplify the model.\n", "\n", "We'll use the Decision Tree's built-in feature importance metric, which measures the average reduction in entropy when a particular feature is used for splitting.\n", "\n", "The following code will:\n", "\n", "1. Extract feature importances from the trained model.\n", "2. Sort these importances in descending order.\n", "3. Visualize the importances using a horizontal bar chart.\n", "4. Print out the numerical values of feature importances.\n", "\n", "The horizontal bar chart provides a visual representation of the relative importance of each feature, while the printed values give us precise numerical data." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Feature Importances:\n", "--hr_mean: 0.6134\n", "--accel_mean: 0.0720\n", "--hr_max: 0.0443\n", "--accel_std: 0.0435\n", "--hrv_rmssd: 0.0423\n", "--hr_min: 0.0415\n", "--accel_dominant_freq: 0.0270\n", "--accel_min: 0.0265\n", "--hrv_sdnn: 0.0261\n", "--accel_median: 0.0259\n", "--accel_max: 0.0231\n", "--hr_std: 0.0145\n", "--hrv_pnn50: 0.0000\n" ] } ], "source": [ "# Feature importance\n", "importances = clf.feature_importances_\n", "feature_names = X.columns\n", "\n", "# Sort feature importances in descending order\n", "sorted_idx = np.argsort(importances)\n", "sorted_importances = importances[sorted_idx]\n", "sorted_feature_names = feature_names[sorted_idx]\n", "\n", "# Plot feature importances as a horizontal bar graph\n", "plt.figure(figsize=(8, 4))\n", "y_pos = np.arange(len(sorted_feature_names))\n", "plt.barh(y_pos, sorted_importances)\n", "plt.yticks(y_pos, sorted_feature_names)\n", "plt.xlabel('Importance')\n", "plt.title('Feature Importance')\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "# Print feature importances\n", "print(\"\\nFeature Importances:\")\n", "for name, importance in sorted(zip(feature_names, importances), key=lambda x: x[1], reverse=True):\n", " print(\"--\"+f\"{name}: {importance:.4f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Imbalanced Data and the Limitations of Accuracy\n", "\n", "In many real-world scenarios, we encounter datasets where the distribution of classes is not equal. This is known as class imbalance. For example, in medical diagnosis, the number of healthy patients might vastly outnumber those with a rare condition. In our sleep stage classification, we're simulating a scenario where \"Wakefulness\" is much more common than \"REM\" or \"NREM\" stages.\n", "\n", "### Why Accuracy Can Be Misleading\n", "\n", "When dealing with imbalanced datasets, overall accuracy can be a misleading metric. Here's why:\n", "\n", "1. **Majority Class Bias**: A model can achieve high accuracy simply by always predicting the majority class. For instance, if 95% of our data is \"Wakefulness\", a model that always predicts \"Wakefulness\" would be 95% accurate, despite being utterly useless for identifying the other sleep stages.\n", "\n", "2. **Overlooking Minority Classes**: Accuracy gives equal weight to all predictions. In an imbalanced dataset, the performance on minority classes has little impact on the overall accuracy. A model could perform poorly on important but rare classes while maintaining high overall accuracy.\n", "\n", "3. **False Sense of Performance**: High accuracy might lead us to believe our model is performing well across all classes, when in reality it might be failing to identify critical minority cases.\n", "\n", "### Balanced Accuracy: A Better Metric for Imbalanced Data\n", "\n", "Balanced accuracy addresses these issues by giving equal weight to each class, regardless of its frequency in the dataset. Here's how it works:\n", "\n", "1. **Definition**: Balanced accuracy is the average of recall obtained on each class.\n", "\n", "2. **Calculation**: For each class, calculate the proportion of correct predictions (recall). Then, take the average of these recall values.\n", "\n", "3. **Interpretation**: A balanced accuracy of 0.5 for binary classification (or 1/n for n classes) represents the performance of random guessing. Any value above this indicates better-than-random performance across all classes.\n", "\n", "In the following example, we'll compare regular accuracy with balanced accuracy for both balanced and imbalanced (skewed) datasets. This comparison will highlight how balanced accuracy provides a more realistic assessment of our model's performance, especially when dealing with class imbalance." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "--- Skewed Data Case ---\n", "\n", "Confusion Matrix (Skewed Data):\n", "[[559 11 2]\n", " [ 8 5 5]\n", " [ 0 1 9]]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Precision, Recall, and F1 Score (Skewed Data):\n", "╒═════════════╤═════════════╤══════════╤════════════╕\n", "│ │ Precision │ Recall │ F1 Score │\n", "╞═════════════╪═════════════╪══════════╪════════════╡\n", "│ Wakefulness │ 0.986 │ 0.977 │ 0.982 │\n", "├─────────────┼─────────────┼──────────┼────────────┤\n", "│ REM │ 0.294 │ 0.278 │ 0.286 │\n", "├─────────────┼─────────────┼──────────┼────────────┤\n", "│ NREM │ 0.562 │ 0.900 │ 0.692 │\n", "╘═════════════╧═════════════╧══════════╧════════════╛\n", "\n", "Class Distribution in Test Set (Skewed Data):\n", "Stage\n", "Wakefulness 0.953333\n", "REM 0.030000\n", "NREM 0.016667\n", "Name: proportion, dtype: float64\n", "\n", "Naive Classifier Accuracy (always predicting Wakefulness): 0.953\n", "\n", "Overall Accuracy (Skewed Data): 0.955\n", "Balanced Accuracy (Skewed Data): 0.718\n", "Naive Classifier Balanced Accuracy: 0.333\n" ] } ], "source": [ "print(\"\\n--- Skewed Data Case ---\\n\")\n", "\n", "# Generate skewed data\n", "skewed_data = generate_synthetic_data(2000, class_distribution=[0.95, 0.03, 0.02])\n", "\n", "# Split data into features (X) and labels (y)\n", "X_skewed = skewed_data.drop('Stage', axis=1)\n", "y_skewed = skewed_data['Stage']\n", "\n", "# Split into training and testing sets\n", "X_train_skewed, X_test_skewed, y_train_skewed, y_test_skewed = train_test_split(X_skewed, y_skewed, test_size=0.3, random_state=42)\n", "\n", "# Train a Decision Tree classifier\n", "clf_skewed = DecisionTreeClassifier(random_state=42)\n", "clf_skewed.fit(X_train_skewed, y_train_skewed)\n", "\n", "# Make predictions\n", "y_pred_skewed = clf_skewed.predict(X_test_skewed)\n", "\n", "# Generate confusion matrix\n", "cm_skewed = confusion_matrix(y_test_skewed, y_pred_skewed, labels=['Wakefulness', 'REM', 'NREM'])\n", "\n", "# Calculate precision, recall, and F1 score\n", "precision_skewed, recall_skewed, f1_skewed, _ = precision_recall_fscore_support(y_test_skewed, y_pred_skewed, average=None, labels=['Wakefulness', 'REM', 'NREM'])\n", "\n", "# Display results\n", "print(\"Confusion Matrix (Skewed Data):\")\n", "print(cm_skewed)\n", "\n", "# Visualize the confusion matrix\n", "plt.figure(figsize=(5, 4))\n", "sns.heatmap(cm_skewed, annot=True, fmt='d', cmap='Blues', \n", " xticklabels=['Wakefulness', 'REM', 'NREM'],\n", " yticklabels=['Wakefulness', 'REM', 'NREM'])\n", "plt.title('Confusion Matrix (Skewed Data)')\n", "plt.xlabel('Predicted')\n", "plt.ylabel('Actual')\n", "plt.show()\n", "\n", "# Create a DataFrame for precision, recall, and F1 score\n", "results_df_skewed = pd.DataFrame({\n", " 'Precision': precision_skewed,\n", " 'Recall': recall_skewed,\n", " 'F1 Score': f1_skewed\n", "}, index=['Wakefulness', 'REM', 'NREM'])\n", "\n", "# Format the DataFrame as a pretty table\n", "table_skewed = tabulate(results_df_skewed, headers='keys', tablefmt='fancy_grid', floatfmt='.3f')\n", "\n", "# Display results as a table\n", "print(\"\\nPrecision, Recall, and F1 Score (Skewed Data):\")\n", "print(table_skewed)\n", "\n", "# Calculate and display class distribution\n", "class_distribution_skewed = y_test_skewed.value_counts(normalize=True)\n", "print(\"\\nClass Distribution in Test Set (Skewed Data):\")\n", "print(class_distribution_skewed)\n", "\n", "# Naive classifier that always predicts the majority class\n", "naive_pred_skewed = np.full_like(y_test_skewed, 'Wakefulness')\n", "naive_accuracy_skewed = accuracy_score(y_test_skewed, naive_pred_skewed)\n", "print(f\"\\nNaive Classifier Accuracy (always predicting Wakefulness): {naive_accuracy_skewed:.3f}\")\n", "\n", "# Calculate overall accuracy for the skewed case\n", "accuracy_skewed = accuracy_score(y_test_skewed, y_pred_skewed)\n", "print(f\"\\nOverall Accuracy (Skewed Data): {accuracy_skewed:.3f}\")\n", "\n", "# In the skewed data section, add this after calculating the overall accuracy\n", "balanced_accuracy_skewed = balanced_accuracy_score(y_test_skewed, y_pred_skewed)\n", "print(f\"Balanced Accuracy (Skewed Data): {balanced_accuracy_skewed:.3f}\")\n", "\n", "# Balanced accuracy for the naive classifier\n", "naive_balanced_accuracy_skewed = balanced_accuracy_score(y_test_skewed, naive_pred_skewed)\n", "print(f\"Naive Classifier Balanced Accuracy: {naive_balanced_accuracy_skewed:.3f}\")\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.12.2" } }, "nbformat": 4, "nbformat_minor": 2 }