Day_1_Lab_2_Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/DrKenReid/Introductory-Data-Science/blob/main/Day_1_Lab_2_Classification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Problem Description/Dataset:\n",
        "The “Breast Cancer Wisconsin (Diagnostic)” dataset is publicly available and can be loaded directly from the Scikit-learn library. The dataset contains 569 instances, each with 30 features and a binary target variable indicating whether the tumor is benign (0) or malignant (1). The features include various measurements and characteristics of the cell nuclei present in the digitized images.\n",
        "\n",
        "## Key Features:\n",
        "*   radius (mean of distances from center to points on the perimeter)\n",
        "*   texture (standard deviation of gray-scale values)\n",
        "*   perimeter\n",
        "*   area\n",
        "*   smoothness (local variation in radius lengths)\n",
        "*   compactness (perimeter^2 / area - 1.0)\n",
        "*   concavity (severity of concave portions of the contour)\n",
        "*   concave points (number of concave portions of the contour)\n",
        "*   symmetry\n",
        "*   fractal dimension (“coastline approximation” - 1)"
      ],
      "metadata": {
        "id": "9mjezoD7akon"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "glKWjxiikphu"
      },
      "outputs": [],
      "source": [
        "# Import necessary libraries\n",
        "from sklearn.datasets import load_breast_cancer\n",
        "from sklearn.model_selection import train_test_split, GridSearchCV\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import pandas as pd\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the Breast Cancer Wisconsin (Diagnostic) dataset\n",
        "data = load_breast_cancer()\n",
        "X = data.data\n",
        "y = data.target"
      ],
      "metadata": {
        "id": "s1GWvrS7kuyE"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "The number 42 is often chosen as the random seed in examples and tutorials because it is a reference to \"[The Hitchhiker's Guide to the Galaxy](https://en.wikipedia.org/wiki/Phrases_from_The_Hitchhiker%27s_Guide_to_the_Galaxy#Answer_to_the_Ultimate_Question_of_Life,_the_Universe,_and_Everything_(42))\" by Douglas Adams, where 42 is humorously described as \"the answer to the ultimate question of life, the universe, and everything.\" It has since become a popular, whimsical choice for a random seed in many coding contexts."
      ],
      "metadata": {
        "id": "n1aKMhgBVnpE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Split the data into training and testing sets\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n"
      ],
      "metadata": {
        "id": "BreScQ41kvwL"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Scale the features using StandardScaler\n",
        "scaler = StandardScaler()\n",
        "X_train_scaled = scaler.fit_transform(X_train)\n",
        "X_test_scaled = scaler.transform(X_test)\n"
      ],
      "metadata": {
        "id": "oWS-q476kw67"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Logistic Regression\n",
        "\n",
        "**Description:**  \n",
        "Logistic regression is a statistical method used for binary classification. It models the probability of a binary outcome using a logistic function. The output of logistic regression is a probability value that can be mapped to two distinct classes. It is especially useful for understanding the relationship between a dependent binary variable and one or more independent variables by fitting data to a logistic curve.\n",
        "\n",
        "**Question:** What is logistic regression used for?  \n",
        "**Answer:** Binary classification.\n",
        "\n",
        "**Question:** How does logistic regression model probabilities?  \n",
        "**Answer:** Using a logistic function.\n",
        "\n",
        "**Question:** What is the output of logistic regression?  \n",
        "**Answer:** A probability value.\n",
        "\n",
        "**Question:** Can logistic regression handle multiple independent variables?  \n",
        "**Answer:** Yes.\n",
        "\n",
        "**Question:** What kind of relationship does logistic regression help understand?  \n",
        "**Answer:** The relationship between a dependent binary variable and independent variables.\n",
        "\n",
        "## Decision Tree\n",
        "\n",
        "**Description:**  \n",
        "A decision tree is a non-parametric supervised learning method used for both classification and regression tasks. It splits the dataset into subsets based on the most significant attribute at each node, creating a tree-like model of decisions. The model predicts the target value by learning simple decision rules inferred from the data features. Decision trees are easy to interpret and visualize but can be prone to overfitting.\n",
        "\n",
        "**Question:** What type of learning method is a decision tree?  \n",
        "**Answer:** Non-parametric supervised learning.\n",
        "\n",
        "**Question:** What tasks can decision trees be used for?  \n",
        "**Answer:** Classification and regression.\n",
        "\n",
        "**Question:** How does a decision tree make predictions?  \n",
        "**Answer:** By learning simple decision rules from data features.\n",
        "\n",
        "**Question:** Are decision trees easy to interpret?  \n",
        "**Answer:** Yes.\n",
        "\n",
        "**Question:** What is a common issue with decision trees?  \n",
        "**Answer:** Overfitting.\n",
        "\n",
        "## Random Forest\n",
        "\n",
        "**Description:**  \n",
        "Random forest is an ensemble learning method used for classification, regression, and other tasks. It operates by constructing multiple decision trees during training and outputting the mode of the classes (classification) or mean prediction (regression) of the individual trees. Random forests correct the habit of decision trees to overfit to their training set by averaging multiple decision trees trained on different parts of the same dataset.\n",
        "\n",
        "**Question:** What type of method is a random forest?  \n",
        "**Answer:** Ensemble learning method.\n",
        "\n",
        "**Question:** How does random forest operate?  \n",
        "**Answer:** By constructing multiple decision trees.\n",
        "\n",
        "**Question:** What is the output of a random forest for classification?  \n",
        "**Answer:** The mode of the classes.\n",
        "\n",
        "**Question:** How does random forest handle overfitting?  \n",
        "**Answer:** By averaging multiple decision trees.\n",
        "\n",
        "**Question:** What tasks can random forest be used for?  \n",
        "**Answer:** Classification and regression.\n",
        "\n",
        "## Support Vector Machine (SVM)\n",
        "\n",
        "**Description:**  \n",
        "Support Vector Machine (SVM) is a supervised machine learning algorithm that can be used for both classification and regression challenges. It works by finding the hyperplane that best divides a dataset into classes. SVM aims to maximize the margin between the data points of different classes, which helps in achieving better generalization. The kernel trick allows SVM to solve non-linear classification problems by mapping data into higher dimensions where a hyperplane can be used to separate the classes.\n",
        "\n",
        "**Question:** What can SVM be used for?  \n",
        "**Answer:** Classification and regression.\n",
        "\n",
        "**Question:** How does SVM find the best hyperplane?  \n",
        "**Answer:** By maximizing the margin between data points of different classes.\n",
        "\n",
        "**Question:** What is the purpose of the kernel trick in SVM?  \n",
        "**Answer:** To solve non-linear classification problems.\n",
        "\n",
        "**Question:** What does SVM aim to achieve?  \n",
        "**Answer:** Better generalization.\n",
        "\n",
        "**Question:** What does SVM use to separate classes in higher dimensions?  \n",
        "**Answer:** A hyperplane."
      ],
      "metadata": {
        "id": "WxgkJY_ydigH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## logistic regression parameters\n",
        "# [the following penalties will be introduced in more detail in lab3]:\n",
        "# L1 penalty: lasso (feature elimination); L2 penalty: ridge (handling multicollinearity; reducing overfitting)\n",
        "lr_params = {'C': [0.1, 1, 10], 'penalty': ['l1', 'l2'], 'solver': ['liblinear']}\n",
        "\n",
        "## decision tree parameters\n",
        "# max_depth: maximum depth of the tree, which leads to simple or complex models\n",
        "# min_samples_split: the minimum number of samples required in a node to be considered for splitting\n",
        "dt_params = {'max_depth': [3, 5, 7], 'min_samples_split': [2, 5, 10]}\n",
        "\n",
        "## random forest parameters\n",
        "# n_estimators: the number of trees in the forest; larger value leads to a more accurate model\n",
        "# max_depth: number of splits for each decision tree in the forest\n",
        "rf_params = {'n_estimators': [50, 100, 200], 'max_depth': [3, 5, 7]}\n",
        "\n",
        "## support vector machine parameters\n",
        "# C: regularization parameter, which controls overfitting; larger value leads to high variance and low bias\n",
        "# kernel: transforms the input data into a higher dimensional space\n",
        "svc_params = {'C': [0.1, 1, 10], 'kernel': ['linear', 'rbf']}"
      ],
      "metadata": {
        "id": "F_O9gQwCk34p"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Hyperparameter tuning\n",
        "\n",
        "**Description:**  \n",
        "Hyperparameter tuning is the process of selecting the optimal set of hyperparameters for a machine learning model. Hyperparameters are the external parameters that govern the training process and model architecture, such as learning rate, number of trees in a random forest, or the regularization parameter in logistic regression. Tuning these parameters helps improve the model's performance by finding the best combination that minimizes the loss function and maximizes predictive accuracy.\n",
        "\n",
        "## Questions and Answers\n",
        "\n",
        "**Question:** What are hyperparameters?  \n",
        "**Answer:** External parameters that govern the training process and model architecture.\n",
        "\n",
        "**Question:** Why is hyperparameter tuning important?  \n",
        "**Answer:** To improve model performance.\n",
        "\n",
        "**Question:** Give an example of a hyperparameter.  \n",
        "**Answer:** Learning rate.\n",
        "\n",
        "**Question:** How does hyperparameter tuning affect model accuracy?  \n",
        "**Answer:** It finds the best combination of hyperparameters to maximize predictive accuracy.\n",
        "\n",
        "**Question:** What method can be used for hyperparameter tuning?  \n",
        "**Answer:** Grid search or random search."
      ],
      "metadata": {
        "id": "kJvgynU2dlzd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a dictionary to store the models and their hyperparameter grids\n",
        "models = {\n",
        "    'Logistic Regression': (LogisticRegression(random_state=42), lr_params),\n",
        "    'Decision Tree': (DecisionTreeClassifier(random_state=42), dt_params),\n",
        "    'Random Forest': (RandomForestClassifier(random_state=42), rf_params),\n",
        "    'SVC': (SVC(random_state=42), svc_params)\n",
        "}"
      ],
      "metadata": {
        "id": "Txpwf-7wk5UF"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Reasoning:**\n",
        "\n",
        "**Why Grid Search is Good as an Introductory Method:**\n",
        "- **Simplicity:** Grid search is straightforward to understand and implement. It systematically evaluates a predefined set of hyperparameters, making it accessible for beginners.\n",
        "- **Comprehensive Coverage:** If exhaustive, by searching through all possible combinations of specified hyperparameters, it ensures that the best parameter set within the grid is identified. If not, then you need to decide how long you will let it run for.\n",
        "- **Baseline Understanding:** Learning grid search provides a solid foundation for understanding hyperparameter tuning and the impact of different hyperparameters on model performance.\n",
        "\n",
        "**Why Grid Search Isn't Good for Most Parameter Tuning Problems:**\n",
        "- **Computationally Expensive:** Grid search can be very time-consuming and computationally intensive, especially with large datasets and complex models, as it evaluates all possible combinations in the grid.\n",
        "- **Inefficient with Large Grids:** When the number of hyperparameters and their possible values increase, the number of combinations grows exponentially, making grid search impractical for extensive searches.\n",
        "- **Lack of Flexibility:** Grid search does not adapt based on intermediate results, potentially wasting resources on evaluating poor combinations that could have been avoided with more adaptive methods.\n",
        "- **Suboptimal for High-Dimensional Spaces:** In high-dimensional hyperparameter spaces, grid search may miss the optimal region due to its rigid structure, whereas more advanced methods like random search or Bayesian optimization can explore the space more effectively."
      ],
      "metadata": {
        "id": "vyL18p49XvrO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform hyperparameter tuning and evaluate each model\n",
        "performance_metrics = []\n",
        "for model_name, (model, params) in models.items():\n",
        "    grid_search = GridSearchCV(model, params, cv=5, scoring='accuracy')\n",
        "    grid_search.fit(X_train_scaled, y_train)\n",
        "    best_model = grid_search.best_estimator_\n",
        "    y_pred = best_model.predict(X_test_scaled)\n",
        "\n",
        "    # Collect performance metrics\n",
        "    metrics = {\n",
        "        'Model': model_name,\n",
        "        'Accuracy': accuracy_score(y_test, y_pred),\n",
        "        'Precision': precision_score(y_test, y_pred),\n",
        "        'Recall': recall_score(y_test, y_pred),\n",
        "        'F1 Score': f1_score(y_test, y_pred),\n",
        "        'ROC AUC': roc_auc_score(y_test, y_pred)\n",
        "    }\n",
        "    performance_metrics.append(metrics)"
      ],
      "metadata": {
        "id": "yX3P4UGfk-Td"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Model evaluation"
      ],
      "metadata": {
        "id": "E8jIA9FDdrCA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# to print it cleanly, we'll use tabulate\n",
        "from tabulate import tabulate\n",
        "\n",
        "# Convert the list of dictionaries to a pandas DataFrame\n",
        "df = pd.DataFrame(performance_metrics)\n",
        "\n",
        "# Reorder columns to put 'Model' first\n",
        "columns = ['Model', 'Accuracy', 'Precision', 'Recall', 'F1 Score', 'ROC AUC']\n",
        "df = df[columns]\n",
        "\n",
        "# Format numeric columns to display 4 decimal places\n",
        "numeric_columns = ['Accuracy', 'Precision', 'Recall', 'F1 Score', 'ROC AUC']\n",
        "for col in numeric_columns:\n",
        "    df[col] = df[col].apply(lambda x: f'{x:.4f}')\n",
        "\n",
        "# Create a formatted table\n",
        "table = tabulate(df, headers='keys', tablefmt='pretty', showindex=False)\n",
        "\n",
        "print(table)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NWRaZzOOYm75",
        "outputId": "e46d8b79-f5b8-4d84-8a55-a80fbb272e08"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "+---------------------+----------+-----------+--------+----------+---------+\n",
            "|        Model        | Accuracy | Precision | Recall | F1 Score | ROC AUC |\n",
            "+---------------------+----------+-----------+--------+----------+---------+\n",
            "| Logistic Regression |  0.9912  |  0.9861   | 1.0000 |  0.9930  | 0.9884  |\n",
            "|    Decision Tree    |  0.9474  |  0.9452   | 0.9718 |  0.9583  | 0.9394  |\n",
            "|    Random Forest    |  0.9649  |  0.9589   | 0.9859 |  0.9722  | 0.9581  |\n",
            "|         SVC         |  0.9825  |  0.9726   | 1.0000 |  0.9861  | 0.9767  |\n",
            "+---------------------+----------+-----------+--------+----------+---------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualization:\n",
        "\n",
        "performance_df = pd.DataFrame(performance_metrics)\n",
        "\n",
        "# prepare data for seaborn\n",
        "melted_df = performance_df.melt(id_vars=\"Model\", var_name=\"Metric\", value_name=\"Value\")\n",
        "sns.set(style=\"whitegrid\", palette=\"muted\")\n",
        "\n",
        "plt.figure(figsize=(14, 8))\n",
        "barplot = sns.barplot(data=melted_df, x='Metric', y='Value', hue='Model')\n",
        "plt.title('Model Performance Comparison Across Different Metrics')\n",
        "plt.ylabel('Score')\n",
        "plt.xlabel('Performance Metrics')\n",
        "plt.legend(title='Model', loc='upper left', bbox_to_anchor=(1, 1))\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "k4tkNtV2k-kp",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 727
        },
        "outputId": "e9023b33-7a97-4547-e099-83cb18dcc810"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1400x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Machine Learning Metrics\n",
        "\n",
        "### Accuracy\n",
        "**Description:**  \n",
        "Accuracy is the ratio of correctly predicted instances to the total instances. It is a commonly used metric for classification problems, indicating the overall correctness of the model.\n",
        "\n",
        "**Formula:**  \n",
        "Accuracy = (True Positives + True Negatives) / Total Number of Instances\n",
        "\n",
        "### Precision\n",
        "**Description:**  \n",
        "Precision is the ratio of correctly predicted positive instances to the total predicted positive instances. It measures the accuracy of positive predictions.\n",
        "\n",
        "**Formula:**  \n",
        "Precision = True Positives / (True Positives + False Positives)\n",
        "\n",
        "### Recall\n",
        "**Description:**  \n",
        "Recall (or Sensitivity) is the ratio of correctly predicted positive instances to all actual positive instances. It measures the model's ability to identify positive instances.\n",
        "\n",
        "**Formula:**  \n",
        "Recall = True Positives / (True Positives + False Negatives)\n",
        "\n",
        "### F1 Score\n",
        "**Description:**  \n",
        "The F1 Score is the harmonic mean of precision and recall. It provides a single metric that balances both the concerns of precision and recall, making it useful when you need a balance between the two.\n",
        "\n",
        "**Formula:**  \n",
        "F1 Score = 2 * (Precision * Recall) / (Precision + Recall)\n",
        "\n",
        "### ROC AUC\n",
        "**Description:**  \n",
        "ROC AUC (Receiver Operating Characteristic - Area Under Curve) measures the performance of a classification model by plotting the true positive rate (TPR) against the false positive rate (FPR) at various threshold settings. The AUC represents the degree of separability, indicating how well the model distinguishes between classes. A higher AUC value indicates better model performance.\n",
        "\n",
        "**Formulas:**\n",
        "\n",
        "1. **Trapezoidal Rule:**\n",
        "AUC = Σ [(x_{i+1} - x_i) * (y_{i+1} + y_i) / 2]\n",
        "   where x_i and y_i are the coordinates of the ROC curve points.\n",
        "\n",
        "2. **Mann–Whitney U Statistic:**\n",
        "AUC = (Σ R_{+} - (n_{+} * (n_{+} + 1) / 2)) / (n_{+} * n_{-})\n",
        "   where R_{+} is the sum of the ranks for the positive class, n_{+} is the number of positive instances, and n_{-} is the number of negative instances."
      ],
      "metadata": {
        "id": "s-GJlcITaMtc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conclusion\n",
        "\n",
        "Congratulations! You've reached the end of this lab on classification. Throughout this exercise, you've successfully:\n",
        "\n",
        "1. Loaded the Breast Cancer Wisconsin (Diagnostic) dataset\n",
        "2. Split the data into training and testing sets\n",
        "3. Scaled the features using StandardScaler\n",
        "4. Implemented and tuned four different classification models:\n",
        "   - Logistic Regression\n",
        "   - Decision Tree\n",
        "   - Random Forest\n",
        "   - Support Vector Machine (SVM)\n",
        "5. Performed hyperparameter tuning using GridSearchCV\n",
        "6. Evaluated each model using multiple performance metrics:\n",
        "   - Accuracy\n",
        "   - Precision\n",
        "   - Recall\n",
        "   - F1 Score\n",
        "   - ROC AUC\n",
        "7. Visualized the performance comparison across different metrics and models\n",
        "\n",
        "This lab has provided you with hands-on experience in implementing and comparing various classification algorithms, as well as understanding different evaluation metrics for machine learning models."
      ],
      "metadata": {
        "id": "3FUdJ8AQ_kZO"
      }
    }
  ]
}