notebooks/Train_Supervised_Classification_Models.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "nQm5xYpYA_AG",
        "CHBHqduRHyLG",
        "iapakC9TDg5e",
        "jAPF-urD-921",
        "7cw997Pmg91J",
        "DtdlgcMcfeWN",
        "wWtBtq1ohVSC",
        "MiKtEaiDh-0a",
        "9134-x_Q217_",
        "usUy0VXQfvfW",
        "LV-cpA-2gTuN",
        "AjnDfyDahbkt",
        "B5w4emxSjQc4",
        "__UNFDkg3Ba6",
        "EIxstjDofyfm",
        "z4DZ4M5-hhG2",
        "5HdjUBDMjSET",
        "1xEFnIBb3H_i",
        "sCePKRs4fz8Z",
        "Cp7mIJS2hicQ",
        "tXnaJpmmjTPr",
        "B08_mVfE3K54",
        "lpdbnEOff1aa",
        "H-wQ6OaWhju7",
        "-5qEyCc-jU0s",
        "d6zWcQ9C3NlN",
        "3eUeVVkof3Ag",
        "5OcxKOOkhk_9",
        "ru2mIlEZjWQH",
        "o7p3pLV53PEZ",
        "R8h6gHGrf4Vs",
        "cOhJqTKkhmJO",
        "rg-yzT0JjXqm",
        "eaTYVxwW3QYb",
        "kMMNYf9lf5uh",
        "fbZGAlyEhnMj",
        "Gkcc3T5ijZNw",
        "y6vfsIh_3RzZ",
        "tRReuxfdf7Fy",
        "6qRYTDOqhpD4",
        "BBd9bW0_jajw",
        "MX-OiIrZ3TBQ",
        "io5TC5Ghf8ng",
        "DtIdE4MahrXi",
        "SGoYuVFrjdPF",
        "DwU7bMG83ULG",
        "os8g08Kmf92V",
        "fYmBtvJQhspp",
        "zf4zKUb4jgCy",
        "0zczXysZ3Vfq",
        "g6Okun5Tf_Dp",
        "4t2-6jEwht5c",
        "bSR_f8SGjhlp",
        "cmhZx1tG3Wmk",
        "DEhk4AitgASL",
        "4x0rt61ChvV0",
        "ghipLehsjiwz",
        "JoQx5Vto3YXS",
        "x4JNRLlKgBiU",
        "jXuY3lRchw06",
        "4TsNaJcEjkUj",
        "FSQj-UZR3ZtX",
        "Bwk6pt7YgC8e",
        "ez1tIQawhyWG",
        "9gP-YXTmjl4y",
        "FeYrwKKkDzRe",
        "k6rS0_QuATZ3",
        "7KUemIUwM9h9",
        "jzL2aVWW_Oes",
        "Qeim77P6E1Dz",
        "q3qsB3X2FCou",
        "UNdwpf90IFX-",
        "HGW-DN6DJf0y",
        "bnum8j0mJzYb",
        "RBc8_xDuTXaV",
        "VYy9dJ28Tt3J",
        "VrKtxekTiNpE",
        "CdEA5LPwlUse",
        "bCJ8kLLFizn_",
        "Nlz3HPbfjF4s",
        "XIIsh7b8jeYw",
        "d7mgX5ySj_c-",
        "yVPt5wJ7kkNy",
        "CQpgZ5q4ky1P"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Classification Models Tutorial Notebook\n",
        "Welcome to this comprehensive tutorial on classification models using Python and scikit-learn.\n",
        "\n",
        "This notebook is designed to guide you through the fundamentals of classification, explore various classification algorithms (for both binary and multi-class tasks), and demonstrate how to implement them using both pre-defined scripts and custom code.\n",
        "\n",
        "Whether you're new to machine learning or an experienced practitioner, this tutorial offers valuable insights and practical examples to enhance your understanding and application of classification techniques."
      ],
      "metadata": {
        "id": "UDCUN4Bp9CKP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Table of Contents\n",
        "\n",
        "1. [Introduction](#introduction)\n",
        "2. [Simple Use](#simple-use)\n",
        "   - [Prerequisites](#prerequisites)\n",
        "   - [Gradio Interface](#gradio-interface)\n",
        "   - [Running the Models](#running-models)\n",
        "     - [Logistic Regression](#logistic-regression)\n",
        "     - [Decision Tree Classifier](#decision-tree-classifier)\n",
        "     - [Random Forest Classifier (Bagging)](#random-forest-classifier)\n",
        "     - [Extra Trees Classifier](#extra-trees-classifier)\n",
        "     - [Gradient Boosting Classifier (Boosting)](#gradient-boosting-classifier)\n",
        "     - [AdaBoost Classifier (Boosting)](#adaboost-classifier)\n",
        "     - [XGBoost Classifier (Boosting)](#xgboost-classifier)\n",
        "     - [LightGBM Classifier (Boosting)](#lightgbm-classifier)\n",
        "     - [CatBoost Classifier (Boosting)](#catboost-classifier)\n",
        "     - [Support Vector Classifier (SVC)](#support-vector-classifier)\n",
        "     - [K-Nearest Neighbors (KNN) Classifier](#knn-classifier)\n",
        "     - [Multilayer Perceptron (MLP) Classifier](#mlp-classifier)\n",
        "     - [GaussianNB (Naive Bayes)](#gaussiannb-naive-bayes)\n",
        "     - [Linear Discriminant Analysis (LDA)](#linear-discriminant-analysis)\n",
        "     - [Quadratic Discriminant Analysis (QDA)](#quadratic-discriminant-analysis)\n",
        "3. [Code Breakdown](#code-breakdown)\n",
        "   - [Setting Up the Dataset](#setting-up-the-dataset)\n",
        "   - [Hyperparameter Tuning and Model Training](#hyperparameter-tuning-and-model-training)\n",
        "4. [Conclusion](#conclusion)"
      ],
      "metadata": {
        "id": "F42V9r5S9MWJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 1. Introduction\n",
        "<a id=\"introduction\"></a>"
      ],
      "metadata": {
        "id": "cjh4km3T-mGW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Welcome to this comprehensive tutorial on classification models. In this notebook, you'll learn about classification—predicting discrete class labels—using Python and scikit-learn. We will cover both binary classification (e.g., spam vs. not spam) and multi-class classification (e.g., assigning images to one of several categories).\n",
        "\n",
        "## Purpose of the Notebook\n",
        "The primary objectives are:\n",
        "- **Understand Classification Analysis**: Learn the fundamentals and importance of classification in machine learning.\n",
        "- **Explore Various Algorithms**: Dive into different classification algorithms, from linear models like Logistic Regression to advanced ensemble methods like XGBoost and LightGBM.\n",
        "- **Hands-On Implementation**: Offer practical examples using predefined scripts for quick execution, as well as full code for deeper customization.\n",
        "- **Interact with a GUI**: Use a Gradio interface for easy data input, model selection, and real-time evaluation without writing code.\n",
        "\n",
        "## What is Classification?\n",
        "Classification is a supervised learning approach where the model predicts a discrete label or class for an observation. For example, deciding if an email is \"spam\" or \"not spam\" (binary classification) or categorizing an image among multiple classes (multi-class classification).\n",
        "\n",
        "### Importance of Classification in Machine Learning\n",
        "- **Decision Making**: Classification models help in making decisions (e.g., whether to approve a loan, diagnose a disease, or detect fraud).\n",
        "- **Automation**: Used in automating processes like email filtering, image recognition, and sentiment analysis.\n",
        "- **Insight**: Provides understanding of which features influence the categorization process.\n",
        "\n",
        "## Overview of Machine Learning for Classification\n",
        "Machine learning classification models learn from labeled data. You provide examples of features (`X`) and known labels (`y`), and the model learns how to predict `y` for new, unseen examples.\n",
        "\n",
        "### Binary vs. Multi-class Classification\n",
        "- **Binary Classification**: Two possible classes (e.g., `0` or `1`).\n",
        "- **Multi-class Classification**: More than two classes (e.g., Class_1, Class_2, Class_3, ...).\n",
        "\n",
        "## Introduction to scikit-learn\n",
        "[Scikit-learn](https://scikit-learn.org/stable/) is a powerful library that offers an extensive set of tools for classification tasks, including built-in models, pipelines, hyperparameter tuning methods, and evaluation metrics like accuracy, precision, recall, and F1-score.\n",
        "\n",
        "## Getting the Most Out of This Notebook\n",
        "### Who Is This Notebook For?\n",
        "- **Beginners**: Individuals new to classification who want a quick start.\n",
        "- **Intermediate Users**: Those with some experience who want to customize models and parameters.\n",
        "- **Advanced Users**: Practitioners interested in full code implementations and extensive modifications.\n",
        "\n",
        "### How to Use This Notebook\n",
        "- **Simple Use**: Start with predefined scripts to quickly run classification algorithms.\n",
        "- **Interactive Interface**: Use the Gradio UI to select models, upload data, and visualize results easily.\n",
        "- **Intermediate and Advanced Use**: Explore parameter tuning, full code implementations, and customization options.\n",
        "\n",
        "## Preparing Your Environment\n",
        "### Prerequisites\n",
        "- **Python 3.7 or Higher**\n",
        "- **Libraries**: Install using `pip install -r requirements.txt`.\n",
        "- **Dataset**: We'll demonstrate on datasets suitable for binary (e.g., Adult Income Dataset) and multi-class (e.g., Otto Group Dataset) classification. You can use any dataset of your choice.\n",
        "- **Kaggle API Key**: Required if you want to download datasets directly from Kaggle.\n",
        "\n",
        "### Project Structure\n",
        "Your project directory should look like:\n",
        "\n",
        "<pre>\n",
        "project_root/\n",
        "├── data/\n",
        "│   ├── raw/\n",
        "│   └── datasets/\n",
        "│       └── kaggle_data.py\n",
        "├── interfaces/\n",
        "│   └── gradio/\n",
        "│       └── train_classificator_gradio.py\n",
        "├── models/\n",
        "│   └── supervised/\n",
        "│       └── classification/\n",
        "│           ├── logistic_regression.py\n",
        "│           ├── decision_tree_classifier.py\n",
        "│           ├── random_forest_classifier.py\n",
        "│           ├── extra_trees_classifier.py\n",
        "│           ├── gradient_boosting_classifier.py\n",
        "│           ├── adaboost_classifier.py\n",
        "│           ├── xgboost_classifier.py\n",
        "│           ├── lightgbm_classifier.py\n",
        "│           ├── catboost_classifier.py\n",
        "│           ├── svc.py\n",
        "│           ├── knn_classifier.py\n",
        "│           ├── mlp_classifier.py\n",
        "│           ├── gaussian_nb.py\n",
        "│           ├── linear_discriminant_analysis.py\n",
        "│           └── quadratic_discriminant_analysis.py\n",
        "├── scripts/\n",
        "│   └── supervised/\n",
        "│       └── train_classification_model.py\n",
        "├── utils/\n",
        "│   └── supervised_hyperparameter_tuning.py\n",
        "├── saved_models/\n",
        "├── results/\n",
        "├── requirements.txt\n",
        "└── README.md\n",
        "</pre>\n",
        "\n",
        "## Next Steps\n",
        "In the next section, **Simple Use**, we'll explore how to run various classification algorithms using predefined scripts and show how to interactively train models using the Gradio interface. This approach will give you a hands-on experience before diving into deeper code explorations and customizations.\n",
        "\n",
        "Let's begin!"
      ],
      "metadata": {
        "id": "Fl3F7OeSHds1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2. Simple Use (self-contained section)\n",
        "<a id=\"simple-use\"></a>"
      ],
      "metadata": {
        "id": "nQm5xYpYA_AG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this section, we'll explore various classification algorithms and demonstrate how to quickly execute them using pre-defined scripts. Each algorithm will be accompanied by a broad explanation to help you understand its fundamentals."
      ],
      "metadata": {
        "id": "Kgvd-VN5Faul"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.1 Prerequisites\n",
        "<a id=\"prerequisites\"></a>"
      ],
      "metadata": {
        "id": "CHBHqduRHyLG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Prerequisites**\n",
        "* **Python Environment**: Ensure you have Python 3.7 or higher installed. If you're using Google Colab, most required libraries come pre-installed.\n",
        "* **Clone the GitHub Repository**: Clone the repository to your local machine or cloud environment:\n",
        "```bash\n",
        "git clone https://github.com/mboukabous/AI-Algorithms-Made-Easy.git\n",
        "cd AI-Algorithms-Made-Easy\n",
        "```\n",
        "* **Required Libraries**: Install the necessary libraries by running:\n",
        "```bash\n",
        "pip install -r requirements.txt\n",
        "```"
      ],
      "metadata": {
        "id": "7UiFH0uUH7Vc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "# Clone the GitHub repository\n",
        "!git clone https://github.com/mboukabous/AI-Algorithms-Made-Easy.git\n",
        "\n",
        "# Change the working directory to the cloned repository\n",
        "os.chdir(\"AI-Algorithms-Made-Easy\")\n",
        "\n",
        "# Verify the current working directory\n",
        "print(f\"Current working directory: {os.getcwd()}\")\n",
        "\n",
        "# Install the required libraries with reduced output for cleaner logs (with -q)\n",
        "!pip install -q -r \"requirements.txt\"\n",
        "print(\"✅ Installation completed. All required libraries are installed.\") # Print a confirmation message"
      ],
      "metadata": {
        "id": "kTEPNB4IH9Jq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b3b16c2f-8d6e-4da7-8970-183f1a53e160"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'AI-Algorithms-Made-Easy'...\n",
            "remote: Enumerating objects: 719, done.\u001b[K\n",
            "remote: Counting objects: 100% (125/125), done.\u001b[K\n",
            "remote: Compressing objects: 100% (83/83), done.\u001b[K\n",
            "remote: Total 719 (delta 68), reused 58 (delta 40), pack-reused 594 (from 1)\u001b[K\n",
            "Receiving objects: 100% (719/719), 3.33 MiB | 18.85 MiB/s, done.\n",
            "Resolving deltas: 100% (362/362), done.\n",
            "Current working directory: /content/AI-Algorithms-Made-Easy\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m75.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m98.7/98.7 MB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m153.9/153.9 MB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.1/57.1 MB\u001b[0m \u001b[31m11.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m88.8/88.8 kB\u001b[0m \u001b[31m6.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m320.1/320.1 kB\u001b[0m \u001b[31m19.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m243.2/243.2 kB\u001b[0m \u001b[31m16.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m94.8/94.8 kB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.9/56.9 kB\u001b[0m \u001b[31m3.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m11.3/11.3 MB\u001b[0m \u001b[31m96.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m73.2/73.2 kB\u001b[0m \u001b[31m5.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.3/62.3 kB\u001b[0m \u001b[31m4.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m130.2/130.2 kB\u001b[0m \u001b[31m7.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "google-genai 0.3.0 requires websockets<15.0dev,>=13.0, but you have websockets 12.0 which is incompatible.\u001b[0m\u001b[31m\n",
            "\u001b[0m✅ Installation completed. All required libraries are installed.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this section, we'll demonstrate how to download both a binary and a multi-class classification dataset from Kaggle using the `get_kaggle_data` utility. This allows us to seamlessly switch between binary and multi-class classification tasks and illustrate how the same pipeline and code logic handle both scenarios.\n",
        "\n",
        "We'll be using:\n",
        "\n",
        "- **Binary Classification Dataset**: The [Adult Income Dataset](https://www.kaggle.com/datasets/wenruliu/adult-income-dataset) for predicting whether an individual's income exceeds a certain threshold.\n",
        "- **Multi-class Classification Dataset**: The [Otto Group Product Classification Challenge](https://www.kaggle.com/c/otto-group-product-classification-challenge) for predicting product categories.\n",
        "\n",
        "**Prerequisites**:\n",
        "- A Kaggle account and API credentials (`kaggle.json`).\n",
        "- The `get_kaggle_data` function located in `data/datasets/kaggle_data.py`.\n",
        "\n",
        "**Note**:\n",
        "- If you prefer not to use the Kaggle API, simply replace `binary_data_path` and `multiclass_data_path` with the paths to your own local datasets.\n",
        "- The rest of the notebook and scripts will work the same way, as long as you provide a valid `--data_path` argument when running the training scripts."
      ],
      "metadata": {
        "id": "5c7DqG35IA-T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import the get_kaggle_data function to handle dataset downloads\n",
        "from data.datasets.kaggle_data import get_kaggle_data\n",
        "\n",
        "# Define the path to your kaggle.json file for authentication\n",
        "JSON_KAGGLE_PATH = \"/content/kaggle.json\"  # Update this path with the location of your kaggle.json file\n",
        "\n",
        "# Binary Classification Dataset\n",
        "# Define the Kaggle dataset name for binary classification\n",
        "BINARY_DATA_NAME = \"wenruliu/adult-income-dataset\"\n",
        "\n",
        "# Download the binary classification dataset and get its local path\n",
        "binary_data_path = get_kaggle_data(JSON_KAGGLE_PATH, BINARY_DATA_NAME, is_competition=False)\n",
        "print(f\"Binary Classification Dataset is available at: {binary_data_path}\")\n",
        "\n",
        "# Multi-class Classification Dataset\n",
        "# Define the Kaggle dataset name for multi-class classification\n",
        "MULTICLASS_DATA_NAME = \"otto-group-product-classification-challenge\"\n",
        "\n",
        "# Download the multi-class classification dataset and get its local path\n",
        "multiclass_data_path = get_kaggle_data(JSON_KAGGLE_PATH, MULTICLASS_DATA_NAME, is_competition=True)\n",
        "print(f\"Multi-class Classification Dataset is available at: {multiclass_data_path}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I5bDySlSYSAX",
        "outputId": "11ae5659-ecfc-40bd-885b-1eb97b80f6f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Setting up Kaggle API credentials for Colab environment.\n",
            "Downloading dataset: wenruliu/adult-income-dataset\n",
            "Extracted: adult-income-dataset.zip\n",
            "Binary Classification Dataset is available at: data/raw/adult-income-dataset\n",
            "Setting up Kaggle API credentials for Colab environment.\n",
            "Downloading competition data: otto-group-product-classification-challenge\n",
            "Extracted: otto-group-product-classification-challenge.zip\n",
            "Multi-class Classification Dataset is available at: data/raw/otto-group-product-classification-challenge\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.2 Gradio Interface\n",
        "<a id=\"gradio-interface\"></a>"
      ],
      "metadata": {
        "id": "iapakC9TDg5e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Gradio provides an easy way to create web-based interfaces for your machine learning models, allowing you to interactively train your models without needing to write additional front-end code.\n",
        "\n",
        "In this section, we'll use An interface that will allow us to upload data and train a classification model interactively - https://huggingface.co/spaces/mboukabous/train_classificator\n",
        "\n",
        "![train_classificator_gradio.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "Nszdm0crF666"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!python interfaces/gradio/train_classificator_gradio.py"
      ],
      "metadata": {
        "id": "81985b_hIQIH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2.3 Running the Models\n",
        "<a id=\"running-models\"></a>"
      ],
      "metadata": {
        "id": "jAPF-urD-921"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We'll use the script `scripts/supervised/train_classification_model.py` to train and evaluate each model for classification tasks.\n",
        "\n",
        "**Full Command-Line Arguments**:\n",
        "```bash\n",
        "python scripts/supervised/train_classification_model.py \\\n",
        "    --model_module '<model_name>' \\\n",
        "    --data_path 'data/raw/<dataset_name>/<train_data_name.csv>' \\\n",
        "    --target_variable '<y_variable_name>' \\\n",
        "    --drop_columns '<columns,to,drop>' \\\n",
        "    --test_size 0.2 \\\n",
        "    --random_state 42 \\\n",
        "    --cv_folds 5 \\\n",
        "    --scoring_metric '<metric>' \\\n",
        "    --model_path 'saved_models/<ModelName>' \\\n",
        "    --results_path 'results/<ModelName>' \\\n",
        "    --visualize\n",
        "```\n",
        "\n",
        "**Required Command-Line Arguments:**\n",
        "- `--model_module`: Name of the classification model module to import (e.g., `logistic_regression`).\n",
        "- `--data_path`: Path to the dataset directory, including the data file name.\n",
        "- `--target_variable`: Name of the target variable in your dataset (categorical).\n",
        "\n",
        "**Optional Command-Line Arguments:**\n",
        "- `--test_size`: Proportion of the dataset to include in the test split (default: `0.2`).\n",
        "- `--random_state`: Random seed for reproducibility (default: `42`).\n",
        "- `--cv_folds`: Number of cross-validation folds (default: `5`).\n",
        "- `--scoring_metric`: Metric for model evaluation (e.g., `accuracy`, `f1`, `f1_macro`, `roc_auc`).\n",
        "- `--model_path`: Path to save the trained model (e.g., `saved_models/LogisticRegression`).\n",
        "- `--results_path`: Path to save results and metrics (e.g., `results/LogisticRegression`).\n",
        "- `--visualize`: Generate and save visualizations (classification metrics chart and confusion matrix).\n",
        "- `--drop_columns`: Comma-separated column names to drop from the dataset (optional).\n",
        "\n",
        "Now, let's run each model with the full command-line example and provide a broad explanation of each algorithm."
      ],
      "metadata": {
        "id": "BBtPsy42HHQd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Logistic Regression\n"
      ],
      "metadata": {
        "id": "7cw997Pmg91J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "Logistic Regression models the probability of a binary outcome using a logistic (sigmoid) function. It can also handle multi-class classification (e.g., OvR scheme).\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Interpretable Coefficients**: Coefficients can show how each feature influences the log-odds of a particular class.  \n",
        "- **Requires Scaling**: Numerical features should be scaled or normalized for best results.  \n",
        "- **Baseline Model**: Often a good baseline due to simplicity and interpretability.  \n",
        "- **Convergence Warnings**: Increasing `max_iter` or trying different solvers may be needed if it fails to converge."
      ],
      "metadata": {
        "id": "JkFpa8A2eVKc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "DtdlgcMcfeWN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/logistic_regression.py\n",
        "\n",
        "\"\"\"\n",
        "This module sets up a Logistic Regression classifier for hyperparameter tuning.\n",
        "\n",
        "Features:\n",
        "- Uses `LogisticRegression` from scikit-learn.\n",
        "- Defines a hyperparameter grid for both preprocessing and model parameters.\n",
        "- Suitable for binary and multi-class classification (LogisticRegression uses OvR/One-vs-Rest by default).\n",
        "- Default scoring: 'accuracy', which works well for both binary and multi-class tasks.\n",
        "\n",
        "Considerations:\n",
        "- Adjusting `C` controls regularization strength.\n",
        "- `penalty='l2'` is commonly used.\n",
        "- One can add more solvers or penalties as needed.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "# Define the estimator\n",
        "estimator = LogisticRegression()\n",
        "\n",
        "# Define the hyperparameter grid\n",
        "param_grid = {\n",
        "    # Model parameters\n",
        "    'model__C': [0.01, 0.1, 1.0, 10.0],  # Regularization strength\n",
        "    'model__penalty': ['l2'],            # Only L2 regularization supported in LogisticRegression(solver='lbfgs')\n",
        "    'model__solver': ['lbfgs'],  # Efficient solver for large datasets\n",
        "    'model__max_iter': [1000] # Control convergence\n",
        "    # Preprocessing parameters for numerical features\n",
        "    #'preprocessor__num__imputer__strategy': ['mean', 'median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True, False],\n",
        "    #'preprocessor__num__scaler__with_std': [True, False],\n",
        "}\n",
        "\n",
        "# Optional: Default scoring metric for classification\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-l6o0IS3hNID",
        "outputId": "e5647986-cd44-41c7-b2b2-41ed68dc3883"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting models/supervised/classification/logistic_regression.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "_7rRmItWgK7o"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "wWtBtq1ohVSC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Logistic Regression - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'logistic_regression' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9d0bAbSAgS16",
        "outputId": "80fd0419-7618-4e3f-f38e-b77fa0726357"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for LogisticRegression:\n",
            "model__C: 1.0\n",
            "model__max_iter: 1000\n",
            "model__penalty: l2\n",
            "model__solver: lbfgs\n",
            "\n",
            "LogisticRegression Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8570\n",
            "- Precision: 0.8509\n",
            "- Recall: 0.8570\n",
            "- F1 Score: 0.8520\n",
            "- Training Time: 17.5811 seconds\n",
            "Trained model saved to saved_models/LogisticRegression/best_model.pkl\n",
            "\n",
            "Metrics saved to results/LogisticRegression/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/LogisticRegression/classification_metrics.png\n",
            "Figure(1000x800)\n",
            "Confusion matrix saved to results/LogisticRegression/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "MiKtEaiDh-0a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Logistic Regression - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'logistic_regression' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V7MNmFz7gK5_",
        "outputId": "eafc7ede-9b98-465b-9e08-b3935a6c506c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for LogisticRegression:\n",
            "model__C: 10.0\n",
            "model__max_iter: 1000\n",
            "model__penalty: l2\n",
            "model__solver: lbfgs\n",
            "\n",
            "LogisticRegression Classification Metrics on Test Set:\n",
            "- Accuracy: 0.7640\n",
            "- Precision: 0.7583\n",
            "- Recall: 0.7640\n",
            "- F1 Score: 0.7466\n",
            "- Training Time: 109.1226 seconds\n",
            "Trained model saved to saved_models/LogisticRegression/best_model.pkl\n",
            "\n",
            "Metrics saved to results/LogisticRegression/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/LogisticRegression/classification_metrics.png\n",
            "Figure(1000x800)\n",
            "Confusion matrix saved to results/LogisticRegression/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Decision Tree Classifier"
      ],
      "metadata": {
        "id": "9134-x_Q217_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "Decision Trees use a sequence of if-else rules based on feature splits to classify samples. The tree grows branches until leaf nodes represent class decisions.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Easy to Interpret**: The flowchart-like structure is straightforward to understand.  \n",
        "- **Can Overfit**: Prone to memorizing data if hyperparameters (e.g., `max_depth`) are not constrained.  \n",
        "- **No Need for Feature Scaling**: Works fine with different feature scales and types.  \n",
        "- **Handles Mixed Data**: Naturally deals with numerical and categorical features."
      ],
      "metadata": {
        "id": "nU1TbjHiellR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "usUy0VXQfvfW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/decision_tree_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "This module sets up a Decision Tree Classifier for hyperparameter tuning.\n",
        "\n",
        "Features:\n",
        "- Uses `DecisionTreeClassifier` from scikit-learn.\n",
        "- Defines a parameter grid suitable for both binary and multi-class classification.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Considerations:\n",
        "- `criterion`, `max_depth`, `min_samples_split`, and `min_samples_leaf` are common parameters to tune.\n",
        "- Ordinal encoding will be used for tree-based models if implemented, but the pipeline code decides that.\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "\n",
        "estimator = DecisionTreeClassifier(random_state=42)\n",
        "\n",
        "param_grid = {\n",
        "    'model__criterion': ['gini', 'entropy'],\n",
        "    'model__max_depth': [None, 5, 10],\n",
        "    'model__min_samples_split': [2, 5],\n",
        "    'model__min_samples_leaf': [1, 2],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean', 'median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True, False],\n",
        "    #'preprocessor__num__scaler__with_std': [True, False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WJ9tBY_h3bFg",
        "outputId": "39fd0f8a-7363-44a5-f171-01a5dc7de2d1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/decision_tree_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "LV-cpA-2gTuN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "AjnDfyDahbkt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Decision Tree Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'decision_tree_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MsVvj1HD4OEG",
        "outputId": "885627a3-00bf-4499-bcc5-72721ddd2b60"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for DecisionTreeClassifier:\n",
            "model__criterion: entropy\n",
            "model__max_depth: 10\n",
            "model__min_samples_leaf: 2\n",
            "model__min_samples_split: 5\n",
            "\n",
            "DecisionTreeClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8618\n",
            "- Precision: 0.8561\n",
            "- Recall: 0.8618\n",
            "- F1 Score: 0.8525\n",
            "- Training Time: 37.6116 seconds\n",
            "Trained model saved to saved_models/DecisionTreeClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/DecisionTreeClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/DecisionTreeClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/DecisionTreeClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "B5w4emxSjQc4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Decision Tree Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'decision_tree_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Br1BYcY4OLw",
        "outputId": "0bfae465-7b54-46de-be48-9b710ca68d67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for DecisionTreeClassifier:\n",
            "model__criterion: gini\n",
            "model__max_depth: None\n",
            "model__min_samples_leaf: 2\n",
            "model__min_samples_split: 2\n",
            "\n",
            "DecisionTreeClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.7135\n",
            "- Precision: 0.7153\n",
            "- Recall: 0.7135\n",
            "- F1 Score: 0.7134\n",
            "- Training Time: 131.6476 seconds\n",
            "Trained model saved to saved_models/DecisionTreeClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/DecisionTreeClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/DecisionTreeClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/DecisionTreeClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Random Forest Classifier (Bagging)"
      ],
      "metadata": {
        "id": "__UNFDkg3Ba6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "Random Forest is an ensemble of multiple Decision Trees trained on bootstrapped samples of data and randomized subsets of features, then aggregated by voting.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Robust Performance**: Tends to reduce overfitting compared to a single Decision Tree.  \n",
        "- **Parallelizable**: Each tree can train independently, speeding up computation.  \n",
        "- **Less Interpretable**: More challenging to interpret than a single tree.  \n",
        "- **Handles High-Dimensional Data**: Often still effective when many features exist."
      ],
      "metadata": {
        "id": "xNLovxR9es76"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "EIxstjDofyfm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/random_forest_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "Random Forest Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `RandomForestClassifier` from scikit-learn.\n",
        "- Good general-purpose model for binary and multi-class tasks.\n",
        "- Default scoring: 'accuracy'.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "\n",
        "estimator = RandomForestClassifier(random_state=42)\n",
        "\n",
        "param_grid = {\n",
        "    'model__n_estimators': [100],\n",
        "    'model__max_depth': [None, 10],\n",
        "    'model__min_samples_split': [2, 5],\n",
        "    'model__min_samples_leaf': [1],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean', 'median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True, False],\n",
        "    #'preprocessor__num__scaler__with_std': [True, False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ofZI6DhK3bcp",
        "outputId": "bdc060ba-74f8-4097-a533-dc049c6e311d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/random_forest_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "-Au6F2zZgVwf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "z4DZ4M5-hhG2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Random Forest Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'random_forest_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RTrFgKZW4Omy",
        "outputId": "163de8e8-c5e5-4611-c0c9-f826e39c45c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for RandomForestClassifier:\n",
            "model__max_depth: None\n",
            "model__min_samples_leaf: 1\n",
            "model__min_samples_split: 5\n",
            "model__n_estimators: 100\n",
            "\n",
            "RandomForestClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8674\n",
            "- Precision: 0.8624\n",
            "- Recall: 0.8674\n",
            "- F1 Score: 0.8634\n",
            "- Training Time: 69.8531 seconds\n",
            "Trained model saved to saved_models/RandomForestClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/RandomForestClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/RandomForestClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/RandomForestClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "5HdjUBDMjSET"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Random Forest Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'random_forest_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ABUEqwJz4OpB",
        "outputId": "44dc43df-974e-41dd-8746-b7b7f09f36af"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for RandomForestClassifier:\n",
            "model__max_depth: None\n",
            "model__min_samples_leaf: 1\n",
            "model__min_samples_split: 2\n",
            "model__n_estimators: 100\n",
            "\n",
            "RandomForestClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8099\n",
            "- Precision: 0.8093\n",
            "- Recall: 0.8099\n",
            "- F1 Score: 0.8001\n",
            "- Training Time: 174.7659 seconds\n",
            "Trained model saved to saved_models/RandomForestClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/RandomForestClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/RandomForestClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/RandomForestClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Extra Trees Classifier"
      ],
      "metadata": {
        "id": "1xEFnIBb3H_i"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "Extra Trees (Extremely Randomized Trees) is an ensemble similar to Random Forest but selects split thresholds at random, introducing more variance reduction.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Increased Randomness**: May improve generalization in some cases.  \n",
        "- **Often Faster**: Random thresholds can shorten training time.  \n",
        "- **Ensemble Method**: Like Random Forest, but with more randomness in splits.  \n",
        "- **Comparable or Better Accuracy**: Can sometimes outperform Random Forest on certain data."
      ],
      "metadata": {
        "id": "4ikqcTxNev6g"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "sCePKRs4fz8Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/extra_trees_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "Extra Trees Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `ExtraTreesClassifier`.\n",
        "- Similar to RandomForest but with more randomness in splits.\n",
        "- Works well for both binary and multi-class.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.ensemble import ExtraTreesClassifier\n",
        "\n",
        "estimator = ExtraTreesClassifier(random_state=42)\n",
        "\n",
        "param_grid = {\n",
        "    'model__n_estimators': [100],\n",
        "    'model__max_depth': [None, 10],\n",
        "    'model__min_samples_split': [2, 5],\n",
        "    'model__min_samples_leaf': [1],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean','median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True,False],\n",
        "    #'preprocessor__num__scaler__with_std': [True,False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kj1hkSbW3b0s",
        "outputId": "06e7b30f-ae5a-46cc-f569-3e358e46e599"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/extra_trees_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "Dkft8UdagYEx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "Cp7mIJS2hicQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Extra Trees Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'extra_trees_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MY5X3LJR4PM3",
        "outputId": "3bfbedda-674c-4b14-f0b7-8522a0b540b9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for ExtraTreesClassifier:\n",
            "model__max_depth: None\n",
            "model__min_samples_leaf: 1\n",
            "model__min_samples_split: 5\n",
            "model__n_estimators: 100\n",
            "\n",
            "ExtraTreesClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8561\n",
            "- Precision: 0.8506\n",
            "- Recall: 0.8561\n",
            "- F1 Score: 0.8521\n",
            "- Training Time: 50.2072 seconds\n",
            "Trained model saved to saved_models/ExtraTreesClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/ExtraTreesClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/ExtraTreesClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/ExtraTreesClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "tXnaJpmmjTPr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Extra Trees Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'extra_trees_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tj5ebm_A4PPs",
        "outputId": "b72f1b49-5499-4451-dde3-17f41659c2ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for ExtraTreesClassifier:\n",
            "model__max_depth: None\n",
            "model__min_samples_leaf: 1\n",
            "model__min_samples_split: 2\n",
            "model__n_estimators: 100\n",
            "\n",
            "ExtraTreesClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8125\n",
            "- Precision: 0.8154\n",
            "- Recall: 0.8125\n",
            "- F1 Score: 0.8017\n",
            "- Training Time: 206.2284 seconds\n",
            "Trained model saved to saved_models/ExtraTreesClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/ExtraTreesClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/ExtraTreesClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/ExtraTreesClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Gradient Boosting Classifier (Boosting)"
      ],
      "metadata": {
        "id": "B08_mVfE3K54"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "Gradient Boosting iteratively builds an ensemble of weak learners (Decision Trees) where each new tree focuses on correcting errors from previous trees.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **High Accuracy**: Often used in winning Kaggle solutions.  \n",
        "- **Sequential Training**: New learners added one after another; can be slower.  \n",
        "- **Key Hyperparameters**: `learning_rate`, `n_estimators`, and `max_depth` are crucial to performance.  \n",
        "- **Susceptible to Overfitting**: Needs careful tuning and sometimes early stopping."
      ],
      "metadata": {
        "id": "wo3YjPi0ex6W"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "lpdbnEOff1aa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/gradient_boosting_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "Gradient Boosting Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `GradientBoostingClassifier`.\n",
        "- Great for binary and multi-class tasks.\n",
        "- Default scoring: 'accuracy'.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.ensemble import GradientBoostingClassifier\n",
        "\n",
        "estimator = GradientBoostingClassifier(random_state=42)\n",
        "\n",
        "param_grid = {\n",
        "    'model__n_estimators': [100],\n",
        "    'model__learning_rate': [0.01, 0.1],\n",
        "    'model__max_depth': [3],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean','median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True,False],\n",
        "    #'preprocessor__num__scaler__with_std': [True,False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K3JSYzXH3cN2",
        "outputId": "281ca7b5-e116-48cb-a447-7402b2235dea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/gradient_boosting_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "T0AIHa8cgaMw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "H-wQ6OaWhju7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Gradient Boosting Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'gradient_boosting_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A0-tRfj64PvT",
        "outputId": "ae8cbc3f-3b24-4815-d0b6-ad67f9667f8e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for GradientBoostingClassifier:\n",
            "model__learning_rate: 0.1\n",
            "model__max_depth: 3\n",
            "model__n_estimators: 100\n",
            "\n",
            "GradientBoostingClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8736\n",
            "- Precision: 0.8687\n",
            "- Recall: 0.8736\n",
            "- F1 Score: 0.8676\n",
            "- Training Time: 49.1128 seconds\n",
            "Trained model saved to saved_models/GradientBoostingClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/GradientBoostingClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/GradientBoostingClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/GradientBoostingClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "-5qEyCc-jU0s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Gradient Boosting Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'gradient_boosting_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i3-rvnDU4Pxm",
        "outputId": "83ebddf3-c09d-4906-a219-ba2b39b38df5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for GradientBoostingClassifier:\n",
            "model__learning_rate: 0.1\n",
            "model__max_depth: 3\n",
            "model__n_estimators: 100\n",
            "\n",
            "GradientBoostingClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.7842\n",
            "- Precision: 0.7813\n",
            "- Recall: 0.7842\n",
            "- F1 Score: 0.7746\n",
            "- Training Time: 1400.3094 seconds\n",
            "Trained model saved to saved_models/GradientBoostingClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/GradientBoostingClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/GradientBoostingClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/GradientBoostingClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### AdaBoost Classifier (Boosting)"
      ],
      "metadata": {
        "id": "d6zWcQ9C3NlN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "AdaBoost (Adaptive Boosting) assigns higher weights to misclassified samples so subsequent trees pay more attention to them.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Focuses on Hard Examples**: Iteratively improves on errors.  \n",
        "- **Often Uses Stumps**: By default, small Decision Trees (`max_depth=1`) are used.  \n",
        "- **Sensitive to Outliers**: Misclassified outliers can overly influence the model.  \n",
        "- **Simple Yet Effective**: Can yield good results with minimal tuning."
      ],
      "metadata": {
        "id": "CcmXJAbze24M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "3eUeVVkof3Ag"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/adaboost_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "AdaBoost Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `AdaBoostClassifier` wrapping a weak learner (by default DecisionTreeClassifier).\n",
        "- Suitable for binary and multi-class tasks (OvR approach).\n",
        "- Default scoring: 'accuracy'.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.ensemble import AdaBoostClassifier\n",
        "\n",
        "estimator = AdaBoostClassifier(random_state=42)\n",
        "\n",
        "param_grid = {\n",
        "    'model__n_estimators': [100],\n",
        "    'model__learning_rate': [0.5, 1.0],\n",
        "    'model__algorithm': ['SAMME'],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean','median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True,False],\n",
        "    #'preprocessor__num__scaler__with_std': [True,False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T8h1PIiF3cmZ",
        "outputId": "0a520b89-4901-485f-bc91-a10aec98f759"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/adaboost_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "tVivjaxSgcGR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "5OcxKOOkhk_9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# AdaBoost Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'adaboost_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8OYEKF6o4QdZ",
        "outputId": "7e4cccbf-d39d-40ba-91a9-1f79ef7edbbf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for AdaBoostClassifier:\n",
            "model__algorithm: SAMME\n",
            "model__learning_rate: 1.0\n",
            "model__n_estimators: 100\n",
            "\n",
            "AdaBoostClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8616\n",
            "- Precision: 0.8553\n",
            "- Recall: 0.8616\n",
            "- F1 Score: 0.8547\n",
            "- Training Time: 80.9111 seconds\n",
            "Trained model saved to saved_models/AdaBoostClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/AdaBoostClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/AdaBoostClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/AdaBoostClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "ru2mIlEZjWQH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# AdaBoost Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'adaboost_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1T1OaJym4QgD",
        "outputId": "37dc9556-3bdc-4079-9a88-843825814490"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for AdaBoostClassifier:\n",
            "model__algorithm: SAMME\n",
            "model__learning_rate: 1.0\n",
            "model__n_estimators: 100\n",
            "\n",
            "AdaBoostClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.6686\n",
            "- Precision: 0.6675\n",
            "- Recall: 0.6686\n",
            "- F1 Score: 0.6322\n",
            "- Training Time: 78.2631 seconds\n",
            "Trained model saved to saved_models/AdaBoostClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/AdaBoostClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/AdaBoostClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/AdaBoostClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### XGBoost Classifier (Boosting)"
      ],
      "metadata": {
        "id": "o7p3pLV53PEZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "XGBoost (Extreme Gradient Boosting) is an optimized gradient boosting library known for high performance and robust features.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Highly Optimized**: Implements fast tree boosting in C++.  \n",
        "- **Feature Importance**: Offers advanced measures for ranking features.  \n",
        "- **Regularization**: L1/L2 regularization to control overfitting.  \n",
        "- **Popular in Competitions**: Often achieves top results on structured data."
      ],
      "metadata": {
        "id": "1wQA9z77e7c9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "R8h6gHGrf4Vs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/xgboost_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "XGBoost Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `XGBClassifier` from xgboost library.\n",
        "- Excellent performance for binary and multi-class tasks.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Note: Ensure `xgboost` is installed.\n",
        "\"\"\"\n",
        "\n",
        "from xgboost import XGBClassifier\n",
        "\n",
        "estimator = XGBClassifier(eval_metric='logloss', random_state=42)\n",
        "\n",
        "param_grid = {\n",
        "    'model__n_estimators': [100],\n",
        "    'model__max_depth': [3, 5],\n",
        "    'model__learning_rate': [0.01, 0.1],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean','median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True,False],\n",
        "    #'preprocessor__num__scaler__with_std': [True,False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "id": "zet-nMOd3dDC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf9b0f45-7015-4447-bda6-c0aee2b25254"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting models/supervised/classification/xgboost_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "jEOxx4k2gfHj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "cOhJqTKkhmJO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# XGBoost Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'xgboost_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "abMQEzTV4RKl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89cef56c-18e5-4c87-dd51-12afd880143e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for XGBClassifier:\n",
            "model__learning_rate: 0.1\n",
            "model__max_depth: 5\n",
            "model__n_estimators: 100\n",
            "\n",
            "XGBClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8800\n",
            "- Precision: 0.8757\n",
            "- Recall: 0.8800\n",
            "- F1 Score: 0.8758\n",
            "- Training Time: 11.8432 seconds\n",
            "Trained model saved to saved_models/XGBClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/XGBClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/XGBClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/XGBClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "rg-yzT0JjXqm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# XGBoost Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'xgboost_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "2kVaYgQN4RM_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2d080f03-e2e1-4ac5-859a-4abf03466cf2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for XGBClassifier:\n",
            "model__learning_rate: 0.1\n",
            "model__max_depth: 5\n",
            "model__n_estimators: 100\n",
            "\n",
            "XGBClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.7951\n",
            "- Precision: 0.7930\n",
            "- Recall: 0.7951\n",
            "- F1 Score: 0.7856\n",
            "- Training Time: 187.8835 seconds\n",
            "Trained model saved to saved_models/XGBClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/XGBClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/XGBClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/XGBClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### LightGBM Classifier (Boosting)"
      ],
      "metadata": {
        "id": "eaTYVxwW3QYb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "LightGBM (Light Gradient Boosting Machine) grows trees leaf-wise with advanced optimizations, offering a fast and memory-efficient boosting framework.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Leaf-Wise Growth**: Splits the leaf that yields the largest loss reduction.  \n",
        "- **Highly Efficient**: Often faster and less memory-intensive than other GBMs.  \n",
        "- **Feature Binning**: Speeds up training by discretizing continuous features.  \n",
        "- **Risk of Overfitting**: Leaf-wise approach can overfit if not carefully regularized."
      ],
      "metadata": {
        "id": "VLLdhlF5e-y6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "kMMNYf9lf5uh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/lightgbm_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "LightGBM Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `LGBMClassifier`.\n",
        "- Fast and efficient for binary and multi-class tasks.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Requires `lightgbm` installed.\n",
        "\"\"\"\n",
        "\n",
        "from lightgbm import LGBMClassifier\n",
        "\n",
        "estimator = LGBMClassifier(verbose=-1, random_state=42)\n",
        "\n",
        "param_grid = {\n",
        "    'model__n_estimators': [100],\n",
        "    'model__num_leaves': [31, 63],\n",
        "    'model__learning_rate': [0.01, 0.1],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean','median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True,False],\n",
        "    #'preprocessor__num__scaler__with_std': [True,False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "id": "6F13DHGw3day",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "915c80a9-aef4-404e-9324-3f3087ae896b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/lightgbm_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "KtJVl5fCgg8U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "fbZGAlyEhnMj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# LightGBM Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'lightgbm_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "FbG7X_-M4R3t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a0b8ff24-b29d-42dd-feae-2756a0b01ac7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for LGBMClassifier:\n",
            "model__learning_rate: 0.1\n",
            "model__n_estimators: 100\n",
            "model__num_leaves: 31\n",
            "\n",
            "LGBMClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8804\n",
            "- Precision: 0.8766\n",
            "- Recall: 0.8804\n",
            "- F1 Score: 0.8773\n",
            "- Training Time: 18.6669 seconds\n",
            "Trained model saved to saved_models/LGBMClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/LGBMClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/LGBMClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/LGBMClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "Gkcc3T5ijZNw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# LightGBM Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'lightgbm_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "bBNEyQc84R6P",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f40848f9-1a50-4208-b537-44e5bd97d82b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for LGBMClassifier:\n",
            "model__learning_rate: 0.1\n",
            "model__n_estimators: 100\n",
            "model__num_leaves: 63\n",
            "\n",
            "LGBMClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8178\n",
            "- Precision: 0.8150\n",
            "- Recall: 0.8178\n",
            "- F1 Score: 0.8134\n",
            "- Training Time: 244.3851 seconds\n",
            "Trained model saved to saved_models/LGBMClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/LGBMClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/LGBMClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/LGBMClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### CatBoost Classifier (Boosting)"
      ],
      "metadata": {
        "id": "y6vfsIh_3RzZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "CatBoost natively handles categorical features and reduces overfitting by introducing permutations during training to randomize data ordering.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Handles Categorical Features**: Often no manual one-hot encoding required.  \n",
        "- **Generally Fast**: Competitively fast training and good accuracy.  \n",
        "- **Minimal Feature Engineering**: Can automatically transform categorical data.  \n",
        "- **Permutation-Based**: More robust training process can reduce overfitting."
      ],
      "metadata": {
        "id": "gdUsztGnfB0q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "tRReuxfdf7Fy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/catboost_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "CatBoost Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `CatBoostClassifier`.\n",
        "- Handles categorical features natively but we still rely on pipeline encoding.\n",
        "- Good for both binary and multi-class.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Requires `catboost` installed.\n",
        "\"\"\"\n",
        "\n",
        "from catboost import CatBoostClassifier\n",
        "\n",
        "estimator = CatBoostClassifier(verbose=0, random_state=42)\n",
        "\n",
        "param_grid = {\n",
        "    'model__iterations': [100],\n",
        "    'model__depth': [3, 5],\n",
        "    'model__learning_rate': [0.01, 0.1],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean','median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True,False],\n",
        "    #'preprocessor__num__scaler__with_std': [True,False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "id": "Y03YGKtG3d0h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3cfdcca6-ec10-436c-c92c-11a0d3fd5836"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/catboost_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "q8_9DDmSgjEY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "6qRYTDOqhpD4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# CatBoost Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'catboost_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "SnAUhC314S7t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d8cc874a-5b91-4f80-f4b4-df185101c006"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for CatBoostClassifier:\n",
            "model__depth: 5\n",
            "model__iterations: 100\n",
            "model__learning_rate: 0.1\n",
            "\n",
            "CatBoostClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8705\n",
            "- Precision: 0.8652\n",
            "- Recall: 0.8705\n",
            "- F1 Score: 0.8646\n",
            "- Training Time: 27.5453 seconds\n",
            "Trained model saved to saved_models/CatBoostClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/CatBoostClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/CatBoostClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/CatBoostClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "BBd9bW0_jajw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# CatBoost Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'catboost_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "X0ui7utD4S9-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "49edb1d1-c660-439f-bc47-30832b243834"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "/usr/local/lib/python3.10/dist-packages/numpy/ma/core.py:2820: RuntimeWarning: invalid value encountered in cast\n",
            "  _data = np.array(data, dtype=dtype, copy=copy,\n",
            "Best Hyperparameters for CatBoostClassifier:\n",
            "model__depth: 5\n",
            "model__iterations: 100\n",
            "model__learning_rate: 0.1\n",
            "\n",
            "CatBoostClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.7530\n",
            "- Precision: 0.7540\n",
            "- Recall: 0.7530\n",
            "- F1 Score: 0.7256\n",
            "- Training Time: 301.7503 seconds\n",
            "Trained model saved to saved_models/CatBoostClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/CatBoostClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/CatBoostClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/CatBoostClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Support Vector Classifier (SVC)"
      ],
      "metadata": {
        "id": "MX-OiIrZ3TBQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "Support Vector Classifier aims to find a hyperplane (or set of hyperplanes) that separate classes with the largest margin. Various kernels allow for flexible decision boundaries.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Kernel Trick**: Use `rbf`, `linear`, or polynomial kernels for complex boundaries.  \n",
        "- **High-Dimensional Spaces**: Works well where feature dimensionality is large.  \n",
        "- **Slower on Large Datasets**: Training time can scale poorly with dataset size.  \n",
        "- **Requires Scaling**: Sensitive to the scale of features."
      ],
      "metadata": {
        "id": "tW5XbG_ufEmF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "io5TC5Ghf8ng"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/svc.py\n",
        "\n",
        "\"\"\"\n",
        "Support Vector Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `SVC` from scikit-learn.\n",
        "- Handles binary classification naturally, and multi-class via OvR by default.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Considerations:\n",
        "- `C` and `kernel` are key parameters.\n",
        "- If `kernel='rbf'`, also tune `gamma`.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.svm import SVC\n",
        "\n",
        "estimator = SVC(random_state=42)\n",
        "\n",
        "param_grid = {\n",
        "    'model__C': [0.1, 1.0],  # Reduced the range\n",
        "    'model__kernel': ['linear'],  # Focused on linear kernel\n",
        "    'model__gamma': ['scale'],  # Fixed the gamma to one option\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True],\n",
        "    #'preprocessor__num__scaler__with_std': [True],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "id": "qob2bWal3eML",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c2238c5-4d3e-4573-d9ac-77c5213988a9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/svc.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "VUdmulD3glFS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "DtIdE4MahrXi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Support Vector Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'svc' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "ZOV1nL5a4TnH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3001ee7b-1c31-4184-ebdb-1b29a7130422"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for SVC:\n",
            "model__C: 0.1\n",
            "model__gamma: scale\n",
            "model__kernel: linear\n",
            "\n",
            "SVC Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8569\n",
            "- Precision: 0.8502\n",
            "- Recall: 0.8569\n",
            "- F1 Score: 0.8506\n",
            "- Training Time: 762.7666 seconds\n",
            "Trained model saved to saved_models/SVC/best_model.pkl\n",
            "\n",
            "Metrics saved to results/SVC/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/SVC/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/SVC/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "SGoYuVFrjdPF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Support Vector Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'svc' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "UAJe05k54TpY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "83b865a3-7f51-47bf-ff5b-5a37f485fc53"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for SVC:\n",
            "model__C: 1.0\n",
            "model__gamma: scale\n",
            "model__kernel: linear\n",
            "\n",
            "SVC Classification Metrics on Test Set:\n",
            "- Accuracy: 0.7686\n",
            "- Precision: 0.7691\n",
            "- Recall: 0.7686\n",
            "- F1 Score: 0.7429\n",
            "- Training Time: 1387.5251 seconds\n",
            "Trained model saved to saved_models/SVC/best_model.pkl\n",
            "\n",
            "Metrics saved to results/SVC/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/SVC/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/SVC/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### K-Nearest Neighbors (KNN) Classifier"
      ],
      "metadata": {
        "id": "DwU7bMG83ULG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "KNN classifies a sample based on the majority label among its `k` nearest neighbors in feature space.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **No Training Phase**: Predictions are made by distance-based lookup.  \n",
        "- **Sensitive to Feature Scaling**: Must scale features to have a meaningful distance metric.  \n",
        "- **High Memory Usage**: Must store all data points.  \n",
        "- **Slower Inference**: Predictions require computing distances to many points."
      ],
      "metadata": {
        "id": "RX1JozXpfHg4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "os8g08Kmf92V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/knn_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "K-Nearest Neighbors Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `KNeighborsClassifier`.\n",
        "- Works for binary and multi-class tasks.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Considerations:\n",
        "- `n_neighbors`, `weights`, and `p` (Minkowski distance) are common parameters to tune.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "\n",
        "estimator = KNeighborsClassifier()\n",
        "\n",
        "param_grid = {\n",
        "    'model__n_neighbors': [3, 5],  # Reduced to two neighbor options\n",
        "    'model__weights': ['uniform'],  # Focused on one weighting strategy\n",
        "    'model__p': [2],  # Fixed to Euclidean distance\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True],\n",
        "    #'preprocessor__num__scaler__with_std': [True],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "id": "y8d8vozk3emH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c724ad10-03fb-46f9-8fd4-a0d70eb7aba6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting models/supervised/classification/knn_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "xhrQZNezgm1C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "fYmBtvJQhspp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# K-Nearest Neighbors Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'knn_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "Y0LQhIhR4USG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a670c9fd-67b5-48e3-ec85-8032c913e527"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for KNeighborsClassifier:\n",
            "model__n_neighbors: 5\n",
            "model__p: 2\n",
            "model__weights: uniform\n",
            "\n",
            "KNeighborsClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8386\n",
            "- Precision: 0.8347\n",
            "- Recall: 0.8386\n",
            "- F1 Score: 0.8363\n",
            "- Training Time: 34.8833 seconds\n",
            "Trained model saved to saved_models/KNeighborsClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/KNeighborsClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/KNeighborsClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/KNeighborsClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "zf4zKUb4jgCy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# K-Nearest Neighbors Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'knn_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "yn0I0yQG4UUR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cb15c035-8f5d-45f3-e6cf-4c0fe308b960"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for KNeighborsClassifier:\n",
            "model__n_neighbors: 5\n",
            "model__p: 2\n",
            "model__weights: uniform\n",
            "\n",
            "KNeighborsClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.7721\n",
            "- Precision: 0.7705\n",
            "- Recall: 0.7721\n",
            "- F1 Score: 0.7659\n",
            "- Training Time: 57.5733 seconds\n",
            "Trained model saved to saved_models/KNeighborsClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/KNeighborsClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/KNeighborsClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/KNeighborsClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Multilayer Perceptron (MLP) Classifier"
      ],
      "metadata": {
        "id": "0zczXysZ3Vfq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "An MLP is a feed-forward neural network trained with backpropagation to capture complex non-linear relationships in data.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Flexible**: Learns intricate patterns with enough layers/neurons.  \n",
        "- **Hyperparameter Intensive**: Hidden layer sizes, learning rate, and regularization matter greatly.  \n",
        "- **Potential Convergence Warnings**: Might need higher `max_iter` or better initialization.  \n",
        "- **Feature Scaling**: Usually crucial for stable training."
      ],
      "metadata": {
        "id": "EmHCymmxfKYZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "g6Okun5Tf_Dp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/mlp_classifier.py\n",
        "\n",
        "\"\"\"\n",
        "MLP Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `MLPClassifier`.\n",
        "- Suitable for binary and multi-class classification.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Considerations:\n",
        "- `hidden_layer_sizes`, `alpha` (L2 regularization), and `learning_rate_init` are common parameters.\n",
        "- Increase `max_iter` if convergence warnings appear.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.neural_network import MLPClassifier\n",
        "\n",
        "# Define the estimator\n",
        "estimator = MLPClassifier(max_iter=200, random_state=42)\n",
        "\n",
        "# Define the hyperparameter grid\n",
        "param_grid = {\n",
        "    'model__hidden_layer_sizes': [(50,)],  # Reduced size of hidden layers for faster training\n",
        "    'model__alpha': [0.001],  # Retained commonly effective value\n",
        "    'model__learning_rate_init': [0.001],  # Focused on a single typical value for faster tuning\n",
        "    # Uncomment and customize preprocessing params if needed\n",
        "    #'preprocessor__num__imputer__strategy': ['mean'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True],\n",
        "    #'preprocessor__num__scaler__with_std': [True],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "id": "c5zA7S7e3e9N",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ab53e37-4118-4e0f-e1c2-bc315dd572ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting models/supervised/classification/mlp_classifier.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "kdUydoh4gox_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "4t2-6jEwht5c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# MLP Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'mlp_classifier' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "Kkca2jZ74U78",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "162e0970-42d8-4236-81b4-6727587caca4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "Best Hyperparameters for MLPClassifier:\n",
            "model__alpha: 0.001\n",
            "model__hidden_layer_sizes: (50,)\n",
            "model__learning_rate_init: 0.001\n",
            "\n",
            "MLPClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8501\n",
            "- Precision: 0.8481\n",
            "- Recall: 0.8501\n",
            "- F1 Score: 0.8490\n",
            "- Training Time: 200.8484 seconds\n",
            "Trained model saved to saved_models/MLPClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/MLPClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/MLPClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/MLPClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "bSR_f8SGjhlp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# MLP Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'mlp_classifier' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "cH3itnrj4U-N",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a88d8267-2f0c-485f-af59-50f77e27eaba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
            "  warnings.warn(\n",
            "Best Hyperparameters for MLPClassifier:\n",
            "model__alpha: 0.001\n",
            "model__hidden_layer_sizes: (50,)\n",
            "model__learning_rate_init: 0.001\n",
            "\n",
            "MLPClassifier Classification Metrics on Test Set:\n",
            "- Accuracy: 0.7914\n",
            "- Precision: 0.7858\n",
            "- Recall: 0.7914\n",
            "- F1 Score: 0.7852\n",
            "- Training Time: 324.9547 seconds\n",
            "Trained model saved to saved_models/MLPClassifier/best_model.pkl\n",
            "\n",
            "Metrics saved to results/MLPClassifier/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/MLPClassifier/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/MLPClassifier/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### GaussianNB (Naive Bayes Classifier)"
      ],
      "metadata": {
        "id": "cmhZx1tG3Wmk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "Gaussian Naive Bayes applies Bayes’ theorem under the assumption that features are conditionally independent and normally distributed for each class.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Fast and Simple**: A good baseline or quick check for classification tasks.  \n",
        "- **Works Best**: When the normality assumption is somewhat valid or data is well distributed.  \n",
        "- **Zero Division**: Some classes might not appear in splits (use `zero_division=0` for safe metrics).  \n",
        "- **No Parameter Tuning**: Very few hyperparameters to tweak."
      ],
      "metadata": {
        "id": "faaN-2mifPNb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "DEhk4AitgASL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/gaussian_nb.py\n",
        "\n",
        "\"\"\"\n",
        "Gaussian Naive Bayes Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `GaussianNB`.\n",
        "- Suitable for binary and multi-class.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Considerations:\n",
        "- `var_smoothing` is often the only parameter to tune.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.naive_bayes import GaussianNB\n",
        "\n",
        "estimator = GaussianNB()\n",
        "\n",
        "param_grid = {\n",
        "    'model__var_smoothing': [1e-1, 1e-3, 1e-5, 1e-7, 1e-9],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean','median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True,False],\n",
        "    #'preprocessor__num__scaler__with_std': [True,False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "id": "KlFfdm933fU2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ebe4210-4f1b-4a41-ff88-ba77aedb296d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/gaussian_nb.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "CJOk1yWygq1J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "4x0rt61ChvV0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Gaussian Naive Bayes Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'gaussian_nb' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "mFDrke3C4Vlu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b3a50869-42f0-4855-a614-57dc64aa707c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for GaussianNB:\n",
            "model__var_smoothing: 0.1\n",
            "\n",
            "GaussianNB Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8081\n",
            "- Precision: 0.8445\n",
            "- Recall: 0.8081\n",
            "- F1 Score: 0.8182\n",
            "- Training Time: 9.8001 seconds\n",
            "Trained model saved to saved_models/GaussianNB/best_model.pkl\n",
            "\n",
            "Metrics saved to results/GaussianNB/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/GaussianNB/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/GaussianNB/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "ghipLehsjiwz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Gaussian Naive Bayes Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'gaussian_nb' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "QhRPXk384Vn9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4765cc99-196c-4f81-ed4d-54f46dde1e7e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for GaussianNB:\n",
            "model__var_smoothing: 0.001\n",
            "\n",
            "GaussianNB Classification Metrics on Test Set:\n",
            "- Accuracy: 0.6203\n",
            "- Precision: 0.6717\n",
            "- Recall: 0.6203\n",
            "- F1 Score: 0.6278\n",
            "- Training Time: 16.6488 seconds\n",
            "Trained model saved to saved_models/GaussianNB/best_model.pkl\n",
            "\n",
            "Metrics saved to results/GaussianNB/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/GaussianNB/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/GaussianNB/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Linear Discriminant Analysis (LDA)"
      ],
      "metadata": {
        "id": "JoQx5Vto3YXS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "LDA projects data into a lower-dimensional space maximizing class separability under the assumption of normally distributed classes with shared covariance.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Computationally Simple**: Learns linear boundaries with simple matrix operations.  \n",
        "- **Dimensionality Reduction**: Reduces data to at most `n_classes - 1` dimensions.  \n",
        "- **Sensitive to Class Imbalance**: Classes with more samples can dominate.  \n",
        "- **Linear Boundaries**: Good if classes are roughly linearly separable."
      ],
      "metadata": {
        "id": "gmQTvGw0fSV8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "x4JNRLlKgBiU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/linear_discriminant_analysis.py\n",
        "\n",
        "\"\"\"\n",
        "Linear Discriminant Analysis (LDA) Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `LinearDiscriminantAnalysis`.\n",
        "- Works for binary and multi-class tasks.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Considerations:\n",
        "- `solver` can be tuned.\n",
        "- Some solvers allow `shrinkage` parameter.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
        "\n",
        "estimator = LinearDiscriminantAnalysis()\n",
        "\n",
        "param_grid = {\n",
        "    'model__solver': ['svd', 'lsqr'],\n",
        "    # If solver='lsqr', can tune shrinkage parameter if needed\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean','median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True,False],\n",
        "    #'preprocessor__num__scaler__with_std': [True,False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "id": "C_vUdMrc3frD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "08ede958-f522-4fff-f2ae-3f96af87720b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/linear_discriminant_analysis.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "R0Mei8CvgsrM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "jXuY3lRchw06"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Linear Discriminant Analysis (LDA) Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'linear_discriminant_analysis' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "RR8uyjSA4WTl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "10b8be9d-09b8-4e3c-9878-91dc2b4a4332"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "Best Hyperparameters for LinearDiscriminantAnalysis:\n",
            "model__solver: svd\n",
            "\n",
            "LinearDiscriminantAnalysis Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8475\n",
            "- Precision: 0.8399\n",
            "- Recall: 0.8475\n",
            "- F1 Score: 0.8410\n",
            "- Training Time: 10.3749 seconds\n",
            "Trained model saved to saved_models/LinearDiscriminantAnalysis/best_model.pkl\n",
            "\n",
            "Metrics saved to results/LinearDiscriminantAnalysis/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/LinearDiscriminantAnalysis/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/LinearDiscriminantAnalysis/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "4TsNaJcEjkUj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Linear Discriminant Analysis (LDA) Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'linear_discriminant_analysis' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "o9HWrwz94WWX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c093062f-3a68-4c25-9037-4f4a45dda36e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for LinearDiscriminantAnalysis:\n",
            "model__solver: lsqr\n",
            "\n",
            "LinearDiscriminantAnalysis Classification Metrics on Test Set:\n",
            "- Accuracy: 0.7067\n",
            "- Precision: 0.7294\n",
            "- Recall: 0.7067\n",
            "- F1 Score: 0.6993\n",
            "- Training Time: 10.8391 seconds\n",
            "Trained model saved to saved_models/LinearDiscriminantAnalysis/best_model.pkl\n",
            "\n",
            "Metrics saved to results/LinearDiscriminantAnalysis/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/LinearDiscriminantAnalysis/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/LinearDiscriminantAnalysis/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Quadratic Discriminant Analysis (QDA)"
      ],
      "metadata": {
        "id": "FSQj-UZR3ZtX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Description**:  \n",
        "QDA generalizes LDA by allowing each class to have its own covariance matrix, yielding quadratic decision boundaries.\n",
        "\n",
        "**Key Characteristics**:  \n",
        "- **Curved Boundaries**: More flexible than LDA.  \n",
        "- **Collinearity Sensitivity**: Warnings if features are nearly collinear.  \n",
        "- **Multi-Class**: Naturally extends to multiple classes.  \n",
        "- **Assumption**: Each class covariance is distinct but still requires normality."
      ],
      "metadata": {
        "id": "xqun8h1qfVF_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Define the model (optional)"
      ],
      "metadata": {
        "id": "Bwk6pt7YgC8e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile models/supervised/classification/quadratic_discriminant_analysis.py\n",
        "\n",
        "\"\"\"\n",
        "Quadratic Discriminant Analysis (QDA) Classifier setup.\n",
        "\n",
        "Features:\n",
        "- Uses `QuadraticDiscriminantAnalysis`.\n",
        "- Works for binary and multi-class tasks.\n",
        "- Default scoring: 'accuracy'.\n",
        "\n",
        "Considerations:\n",
        "- `reg_param` can be tuned to control regularization.\n",
        "\"\"\"\n",
        "\n",
        "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n",
        "\n",
        "estimator = QuadraticDiscriminantAnalysis()\n",
        "\n",
        "param_grid = {\n",
        "    'model__reg_param': [0.0, 0.1, 0.5],\n",
        "    # Preprocessing params\n",
        "    #'preprocessor__num__imputer__strategy': ['mean','median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True,False],\n",
        "    #'preprocessor__num__scaler__with_std': [True,False],\n",
        "}\n",
        "\n",
        "default_scoring = 'accuracy'"
      ],
      "metadata": {
        "id": "ocCOeV_U3gBk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "285d6892-2c4d-4266-835d-8188f5baa00e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing models/supervised/classification/quadratic_discriminant_analysis.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Execute the model"
      ],
      "metadata": {
        "id": "M5g9DTASgzZ-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Binary classification"
      ],
      "metadata": {
        "id": "ez1tIQawhyWG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Quadratic Discriminant Analysis (QDA) Classifier - Binary classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'quadratic_discriminant_analysis' \\\n",
        "  --data_path 'data/raw/adult-income-dataset/adult.csv' \\\n",
        "  --target_variable 'income' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "WRjylWgp4XDq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c16ca41c-2c9d-4f6f-fa21-d67e2f4084eb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/discriminant_analysis.py:947: UserWarning: Variables are collinear\n",
            "  warnings.warn(\"Variables are collinear\")\n",
            "Best Hyperparameters for QuadraticDiscriminantAnalysis:\n",
            "model__reg_param: 0.1\n",
            "\n",
            "QuadraticDiscriminantAnalysis Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8395\n",
            "- Precision: 0.8480\n",
            "- Recall: 0.8395\n",
            "- F1 Score: 0.8428\n",
            "- Training Time: 16.6090 seconds\n",
            "Trained model saved to saved_models/QuadraticDiscriminantAnalysis/best_model.pkl\n",
            "\n",
            "Metrics saved to results/QuadraticDiscriminantAnalysis/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/QuadraticDiscriminantAnalysis/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/QuadraticDiscriminantAnalysis/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Multi-class classification"
      ],
      "metadata": {
        "id": "9gP-YXTmjl4y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Quadratic Discriminant Analysis (QDA) Classifier - Multi-class classification - Command-Line (only necessary arguments)\n",
        "!python scripts/supervised/train_classification_model.py \\\n",
        "  --model_module 'quadratic_discriminant_analysis' \\\n",
        "  --data_path 'data/raw/otto-group-product-classification-challenge/train.csv' \\\n",
        "  --target_variable 'target' \\\n",
        "  --drop_columns 'id' \\\n",
        "  --visualize"
      ],
      "metadata": {
        "id": "g45TYlyO4XF1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf01120b-28e8-4d9c-a2ef-0c721da98685"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['Class_1' 'Class_2' 'Class_3' 'Class_4' 'Class_5' 'Class_6' 'Class_7'\n",
            " 'Class_8' 'Class_9']\n",
            "Best Hyperparameters for QuadraticDiscriminantAnalysis:\n",
            "model__reg_param: 0.0\n",
            "\n",
            "QuadraticDiscriminantAnalysis Classification Metrics on Test Set:\n",
            "- Accuracy: 0.6740\n",
            "- Precision: 0.7007\n",
            "- Recall: 0.6740\n",
            "- F1 Score: 0.6754\n",
            "- Training Time: 18.3388 seconds\n",
            "Trained model saved to saved_models/QuadraticDiscriminantAnalysis/best_model.pkl\n",
            "\n",
            "Metrics saved to results/QuadraticDiscriminantAnalysis/metrics.csv\n",
            "Figure(800x600)\n",
            "Visualization saved to results/QuadraticDiscriminantAnalysis/classification_metrics.png\n",
            "Figure(640x480)\n",
            "Confusion matrix saved to results/QuadraticDiscriminantAnalysis/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##   \n",
        "\n",
        "**Congratulations**! You've successfully run various classification models and used an interactive interface using Gradio. This \"Simple Use\" section allows you to quickly experiment with different algorithms and get immediate results.\n",
        "\n",
        "**Next Steps**\n",
        "\n",
        "In the next section, [Code Breakdown](#code-breakdown), we’ll break down the complete workflow, including downloading data, hyperparameter tuning, training classification algorithms, and saving metrics and visualizations. This in-depth exploration will provide clarity on each step, helping you better understand the underlying processes."
      ],
      "metadata": {
        "id": "jhC6UGJcDtMy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3. Code Breakdown (self-contained section)\n",
        "<a id=\"code-breakdown\"></a>"
      ],
      "metadata": {
        "id": "FeYrwKKkDzRe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this section, we will provide a detailed breakdown of the entire workflow for training classification models. Each subsection delves into specific components of the process, starting from downloading the dataset to implementing hyperparameter tuning and training the models. By the end of this section, you'll gain a comprehensive understanding of the code and its functionality, enabling you to customize and extend the pipeline as needed."
      ],
      "metadata": {
        "id": "7BWxnYddVKsG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.1 Setting Up the Dataset\n",
        "<a id=\"setup-dataset\"></a>"
      ],
      "metadata": {
        "id": "k6rS0_QuATZ3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this section, we'll download two Kaggle datasets directly in Colab—one for **binary classification** (Adult Income) and another for **multi-class classification** (Otto Group)—step by step, **without** using complex functions. This approach ensures the process is straightforward and accessible for beginners. If you already have an existing dataset (either binary or multi-class), you can skip the download steps and directly set the `training_data_path` variable to the path of your dataset file. This variable will be used in later sections when we train our classification models."
      ],
      "metadata": {
        "id": "9B-teugF-zQF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the training data file path (user-defined or generated by download)\n",
        "training_data_path = None\n",
        "\n",
        "# If you have an existing dataset, set the file path here (skip to the next section):\n",
        "# Example:\n",
        "# training_data_path = \"/content/data/raw/my_existing_dataset/train.csv\"\n",
        "# Uncomment and set manually if skipping download:\n",
        "# training_data_path = \"/content/my_local_data/train.csv\""
      ],
      "metadata": {
        "id": "QrivGaLk--CS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 1: Install the Kaggle API"
      ],
      "metadata": {
        "id": "7KUemIUwM9h9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "First, we install the `Kaggle API`, which allows us to interact with Kaggle datasets."
      ],
      "metadata": {
        "id": "81N9rqsONE6K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Install Kaggle API to enable downloading datasets\n",
        "!pip install kaggle -q"
      ],
      "metadata": {
        "id": "HJ2n23GdNH4y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 2: Define the Hyperparameters for the Dataset(s) Download"
      ],
      "metadata": {
        "id": "jzL2aVWW_Oes"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Below, we define the required parameters for downloading either a **binary** classification dataset or a **multi-class** dataset from Kaggle. You can choose which one(s) to actually download."
      ],
      "metadata": {
        "id": "wnQiu9eO_ffm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Path to your Kaggle JSON file\n",
        "kaggle_json_path = \"/content/kaggle.json\"  # Replace with your file path\n",
        "\n",
        "# Option 1 (Binary Classification): The Adult Income dataset from Kaggle\n",
        "binary_data_name = \"wenruliu/adult-income-dataset\"  # is_competition=False\n",
        "is_competition_binary = False\n",
        "\n",
        "# Option 2 (Multi-Class): Otto Group Product Classification Challenge\n",
        "multiclass_data_name = \"otto-group-product-classification-challenge\"  # is_competition=True\n",
        "is_competition_multiclass = True\n",
        "\n",
        "# Folder where the data will be saved\n",
        "output_dir = \"data/raw\"  # Adjust the output folder if needed"
      ],
      "metadata": {
        "id": "lapBWkpk92Ok"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 3: Configure Kaggle API Credentials"
      ],
      "metadata": {
        "id": "Qeim77P6E1Dz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Kaggle requires an API key stored in a `kaggle.json` file. Below, we set up this file in the correct location for Colab."
      ],
      "metadata": {
        "id": "IY33Ql6WE8qk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import shutil\n",
        "\n",
        "try:\n",
        "    # Create the Kaggle API configuration folder in Colab\n",
        "    config_dir = \"/root/.config/kaggle\"\n",
        "    os.makedirs(config_dir, exist_ok=True)\n",
        "\n",
        "    # Copy your Kaggle JSON file to the Colab configuration folder\n",
        "    shutil.copy(kaggle_json_path, os.path.join(config_dir, \"kaggle.json\"))\n",
        "\n",
        "    # Set appropriate permissions for the Kaggle JSON file\n",
        "    os.chmod(os.path.join(config_dir, \"kaggle.json\"), 0o600)\n",
        "\n",
        "    print(\"Kaggle API credentials have been set up.\")\n",
        "except Exception as e:\n",
        "    raise OSError(f\"Could not set up Kaggle API credentials: {e}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H28Fs-HI929k",
        "outputId": "6d7b8094-b11d-468d-db0c-8475d4a9dec5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Kaggle API credentials have been set up.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 4: Download the Dataset(s)"
      ],
      "metadata": {
        "id": "q3qsB3X2FCou"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use the Kaggle API to download the datasets. We’ll demonstrate how to download **both** the binary and multi-class datasets. You can choose to download only one if you’re focusing on a single classification scenario."
      ],
      "metadata": {
        "id": "NlOO1ST2FGLX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def download_kaggle_data(data_name, is_competition):\n",
        "    \"\"\"\n",
        "    Downloads a Kaggle dataset or competition data using the specified name and competition flag.\n",
        "    \"\"\"\n",
        "    dataset_dir = os.path.join(output_dir, data_name.split('/')[-1])\n",
        "    os.makedirs(dataset_dir, exist_ok=True)\n",
        "\n",
        "    original_dir = os.getcwd()\n",
        "    os.chdir(dataset_dir)\n",
        "\n",
        "    try:\n",
        "        if is_competition:\n",
        "            print(f\"Downloading competition data: {data_name}\")\n",
        "            cmd = f\"kaggle competitions download -c {data_name}\"\n",
        "        else:\n",
        "            print(f\"Downloading dataset: {data_name}\")\n",
        "            cmd = f\"kaggle datasets download -d {data_name}\"\n",
        "        os.system(cmd)\n",
        "    except Exception as e:\n",
        "        print(f\"Error during download: {e}\")\n",
        "    finally:\n",
        "        os.chdir(original_dir)\n",
        "    return dataset_dir"
      ],
      "metadata": {
        "id": "JcicL7poF6Wd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Download the binary classification dataset (Adult Income)\n",
        "binary_dataset_dir = download_kaggle_data(binary_data_name, is_competition_binary)\n",
        "print(f\"Binary dataset directory: {binary_dataset_dir}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ww9EJwh22JKS",
        "outputId": "f077dca0-81bd-4478-919c-f2c8027a5f65"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading dataset: wenruliu/adult-income-dataset\n",
            "Binary dataset directory: data/raw/adult-income-dataset\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Download the multi-class classification dataset (Otto Group)\n",
        "multiclass_dataset_dir = download_kaggle_data(multiclass_data_name, is_competition_multiclass)\n",
        "print(f\"Multi-class dataset directory: {multiclass_dataset_dir}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3nxwxkYx2KOr",
        "outputId": "550eef89-98e8-4ecb-96aa-8fa6723dce0e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading competition data: otto-group-product-classification-challenge\n",
            "Multi-class dataset directory: data/raw/otto-group-product-classification-challenge\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 5: Extract the Dataset(s)"
      ],
      "metadata": {
        "id": "UNdwpf90IFX-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "After downloading, extract all the `.zip` files in each dataset directory."
      ],
      "metadata": {
        "id": "wVDZVP0eILNo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import zipfile\n",
        "\n",
        "def extract_dataset(dataset_dir):\n",
        "    # Navigate to the dataset directory\n",
        "    original_dir = os.getcwd()\n",
        "    os.chdir(dataset_dir)\n",
        "\n",
        "    zip_files = [f for f in os.listdir() if f.endswith(\".zip\")]\n",
        "    if not zip_files:\n",
        "        print(\"No zip files found. Please check the dataset or competition name.\")\n",
        "        os.chdir(original_dir)\n",
        "        return\n",
        "\n",
        "    for zip_file in zip_files:\n",
        "        try:\n",
        "            with zipfile.ZipFile(zip_file, \"r\") as zip_ref:\n",
        "                zip_ref.extractall()\n",
        "            print(f\"Extracting: {zip_file}...\")\n",
        "            os.remove(zip_file)\n",
        "        except Exception as e:\n",
        "            print(f\"Error extracting {zip_file}: {e}\")\n",
        "    os.chdir(original_dir)\n",
        "    print(f\"Dataset extracted: {dataset_dir}\")"
      ],
      "metadata": {
        "id": "cSn3zAQc-Agw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Extract the binary classification dataset (Adult Income)\n",
        "extract_dataset(binary_dataset_dir)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WUgcAY0j2dUB",
        "outputId": "c861e077-8827-4ab1-b74e-171a9a596842"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting: adult-income-dataset.zip...\n",
            "Dataset extracted: data/raw/adult-income-dataset\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Extract the multi-class classification dataset (Otto Group)\n",
        "extract_dataset(multiclass_dataset_dir)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "knI-pIgf2eJq",
        "outputId": "1e8826a5-e196-47bd-f0d6-4dafc16dcc3c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting: otto-group-product-classification-challenge.zip...\n",
            "Dataset extracted: data/raw/otto-group-product-classification-challenge\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 6: Verify the Dataset(s)"
      ],
      "metadata": {
        "id": "HGW-DN6DJf0y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "After extraction, verify the contents of each dataset directory."
      ],
      "metadata": {
        "id": "v_m461DBJi2O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def verify_dataset(dataset_dir):\n",
        "    print(f\"Contents of {dataset_dir}:\")\n",
        "    for root, dirs, files in os.walk(dataset_dir):\n",
        "        for file in files:\n",
        "            print(os.path.join(root, file))"
      ],
      "metadata": {
        "id": "0Emgsf5a-HYp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Verify the binary classification dataset (Adult Income)\n",
        "verify_dataset(binary_dataset_dir)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5DsgPY0t23SC",
        "outputId": "66edf0b0-466d-4222-a789-21375e5482f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Contents of data/raw/adult-income-dataset:\n",
            "data/raw/adult-income-dataset/adult.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Verify the multi-class classification dataset (Otto Group)\n",
        "verify_dataset(multiclass_dataset_dir)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WWjlPoWM250v",
        "outputId": "02a10c46-7fe4-4b15-82f7-2789be2cf698"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Contents of data/raw/otto-group-product-classification-challenge:\n",
            "data/raw/otto-group-product-classification-challenge/test.csv\n",
            "data/raw/otto-group-product-classification-challenge/sampleSubmission.csv\n",
            "data/raw/otto-group-product-classification-challenge/train.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 7: Specify the Path to the Training Data"
      ],
      "metadata": {
        "id": "bnum8j0mJzYb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Choose which dataset (binary or multi-class) you’ll use by setting the `training_data_path` accordingly. For example, if the Adult Income dataset has a file named `adult.csv` after extraction, you can set:"
      ],
      "metadata": {
        "id": "AX5mS6GtLSPz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# For binary classification (Adult Income)\n",
        "train_file_name_binary = \"adult.csv\"  # Check the actual name after extraction\n",
        "training_data_path = os.path.join(binary_dataset_dir, train_file_name_binary)\n",
        "\n",
        "print(f\"Training data path set to: {training_data_path}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3KfvVuOOKtLz",
        "outputId": "2b53bc2f-2eed-47d0-df61-9c39e36b307b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training data path set to: data/raw/adult-income-dataset/adult.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# For multi-class classification (Otto Group) - Uncomment if you want to test this dataset\n",
        "# train_file_name_multiclass = \"train.csv\"\n",
        "# training_data_path = os.path.join(multiclass_dataset_dir, train_file_name_multiclass)\n",
        "# print(f\"Training data path set to: {training_data_path}\")"
      ],
      "metadata": {
        "id": "UWRJeNMs3ukp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.2 Hyperparameter Tuning and Model Training\n",
        "<a id=\"model_training\"></a>"
      ],
      "metadata": {
        "id": "RBc8_xDuTXaV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 0: Installing Required Packages"
      ],
      "metadata": {
        "id": "VYy9dJ28Tt3J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "First, we ensure that all the necessary libraries are installed. We will do this to minimize any missing dependency issues later on."
      ],
      "metadata": {
        "id": "8meFNeP8h0-k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Install required packages quietly to minimize output\n",
        "!pip install -q pandas==2.2.2 numpy==1.26.4 matplotlib==3.8.0 seaborn==0.13.2 \\\n",
        "kaggle==1.6.17 scikit-learn==1.5.2 catboost==1.2.7 dask[dataframe]==2024.10.0 \\\n",
        "xgboost==2.1.2 lightgbm==4.5.0 joblib==1.4.2 gradio==5.7.1\n",
        "print(\"✅ Installation completed. All required libraries are installed.\") # Print a confirmation message"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aavMo-JliG-6",
        "outputId": "c428bda5-b15b-457d-bacc-1c337b089e89"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m65.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m98.7/98.7 MB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m153.9/153.9 MB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.1/57.1 MB\u001b[0m \u001b[31m11.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m320.1/320.1 kB\u001b[0m \u001b[31m29.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m243.2/243.2 kB\u001b[0m \u001b[31m19.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m94.8/94.8 kB\u001b[0m \u001b[31m9.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m11.3/11.3 MB\u001b[0m \u001b[31m127.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m73.2/73.2 kB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.3/62.3 kB\u001b[0m \u001b[31m5.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m130.2/130.2 kB\u001b[0m \u001b[31m12.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "google-genai 0.3.0 requires websockets<15.0dev,>=13.0, but you have websockets 12.0 which is incompatible.\u001b[0m\u001b[31m\n",
            "\u001b[0m✅ Installation completed. All required libraries are installed.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 1: Importing Core Libraries and Setting Initial Parameters"
      ],
      "metadata": {
        "id": "VrKtxekTiNpE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we import the core Python libraries needed for data handling, visualization, and model training. We also set initial parameters related to the modeling process, such as the target variable name, test size, random state, and other configurations.\n",
        "\n",
        "**Key Points:**\n",
        "- `TARGET_VARIABLE`: The column we aim to predict.\n",
        "- `TEST_SIZE`: The ratio of data used for testing.\n",
        "- `RANDOM_STATE`: Seed for reproducibility.\n",
        "- `CV_FOLDS`: Number of cross-validation folds.\n",
        "- `SCORING_METRIC`: Metric to evaluate model performance.\n",
        "- `MODEL_PATH` and `RESULTS_PATH`: Where to save model artifacts and results.\n",
        "- `DROP_COLUMN_NAMES`: Columns to drop from the dataset."
      ],
      "metadata": {
        "id": "puFog-VbiUUO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import sys\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import joblib\n",
        "from timeit import default_timer as timer\n",
        "\n",
        "# Parameters\n",
        "TARGET_VARIABLE = 'income'\n",
        "TEST_SIZE = 0.2\n",
        "RANDOM_STATE = 42\n",
        "CV_FOLDS = 5\n",
        "SCORING_METRIC = 'accuracy'\n",
        "MODEL_PATH = 'saved_models'\n",
        "RESULTS_PATH = 'results'\n",
        "DROP_COLUMN_NAMES = []\n",
        "\n",
        "# Ensure directories exist\n",
        "os.makedirs(MODEL_PATH, exist_ok=True)\n",
        "os.makedirs(RESULTS_PATH, exist_ok=True)\n",
        "\n",
        "print(\"Core libraries imported and parameters set.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VqUfq5F1irK7",
        "outputId": "b0c0ff3b-984c-4d45-8407-cbb931c0c900"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Core libraries imported and parameters set.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 2: Defining the Model (Estimator and Parameters Grid)"
      ],
      "metadata": {
        "id": "CdEA5LPwlUse"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this step, we select the estimator we want to train (e.g., `LogisticRegression`) and define a parameter grid that `GridSearchCV` will use for hyperparameter tuning. We will also set the `MODEL_NAME` for clarity."
      ],
      "metadata": {
        "id": "G07nFFo0lWdo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "# Define the estimator (e.g., LogisticRegression)\n",
        "ESTIMATOR = LogisticRegression()\n",
        "\n",
        "# Define the hyperparameter grid for the chosen model and preprocessing steps\n",
        "PARAM_GRID = {\n",
        "    # Model parameters\n",
        "    'model__C': [0.01, 0.1, 1.0, 10.0],  # Regularization strength\n",
        "    'model__penalty': ['l2'],            # Only L2 regularization supported in LogisticRegression(solver='lbfgs')\n",
        "    'model__solver': ['lbfgs'],  # Efficient solver for large datasets\n",
        "    'model__max_iter': [1000] # Control convergence\n",
        "    # Preprocessing parameters for numerical features\n",
        "    #'preprocessor__num__imputer__strategy': ['mean', 'median'],\n",
        "    #'preprocessor__num__scaler__with_mean': [True, False],\n",
        "    #'preprocessor__num__scaler__with_std': [True, False],\n",
        "}\n",
        "\n",
        "# Derive the model name from the estimator class\n",
        "MODEL_NAME = ESTIMATOR.__class__.__name__\n",
        "\n",
        "print(f\"Estimator set to {MODEL_NAME} and PARAM_GRID defined.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hUZGQDH5ldN3",
        "outputId": "e0120205-452b-4837-f0b0-d795b83f73e2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estimator set to LogisticRegression and PARAM_GRID defined.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 3: Loading and Preparing the Dataset"
      ],
      "metadata": {
        "id": "bCJ8kLLFizn_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We assume that the dataset has already been downloaded in Section 3.1 and that we have a variable `training_data_path` pointing to the training CSV file (e.g., `data/raw/adult-income-dataset/adult.csv`).\n",
        "\n",
        "Steps:\n",
        "- Load the dataset into a DataFrame.\n",
        "- Drop any unnecessary columns (like 'id').\n",
        "- Separate features (X) and target (y).\n",
        "- Verify that the target is numeric (necessary for regression tasks)."
      ],
      "metadata": {
        "id": "s0VfM6iKi08I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assume training_data_path is defined in previous steps or sections (like in 3.1)\n",
        "# For example:\n",
        "# training_data_path = 'data/raw/adult-income-dataset/adult.csv'\n",
        "\n",
        "df = pd.read_csv(training_data_path)\n",
        "\n",
        "# Drop unnecessary columns\n",
        "if DROP_COLUMN_NAMES != \"\":\n",
        "    df = df.drop(columns=DROP_COLUMN_NAMES)\n",
        "\n",
        "X = df.drop(columns=[TARGET_VARIABLE])\n",
        "y = df[TARGET_VARIABLE]\n",
        "\n",
        "print(f\"Data loaded successfully. X shape: {X.shape}, y shape: {y.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pXWjKFCZi7d6",
        "outputId": "a6d66b01-8fd6-4258-8d8e-96cb3443a20c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data loaded successfully. X shape: (48842, 14), y shape: (48842,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ensure target variable is not numeric (or at least, is categorical)\n",
        "It's fine if it's numeric labels for classes, but typically classification is categorical. We'll just run as is and rely on the estimator to handle it."
      ],
      "metadata": {
        "id": "q3ZAP3xM78q4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# If needed, we can print a note:\n",
        "if np.issubdtype(y.dtype, np.number) and len(np.unique(y)) > 20:\n",
        "    # Large number of unique values might indicate a regression-like problem\n",
        "    print(f\"Warning: The target variable '{TARGET_VARIABLE}' seems to have many unique numeric values. Ensure it's truly a classification problem.\")\n",
        "\n",
        "# Encode target variable if not numeric\n",
        "if y.dtype == 'object' or not np.issubdtype(y.dtype, np.number):\n",
        "    from sklearn.preprocessing import LabelEncoder\n",
        "    le = LabelEncoder()\n",
        "    y = le.fit_transform(y)\n",
        "\n",
        "    # Save label encoder so that we can interpret predictions later\n",
        "    joblib.dump(le, os.path.join(MODEL_PATH, 'label_encoder.pkl'))\n",
        "    print(\"LabelEncoder applied to target variable. Classes:\", le.classes_)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AMqEV2pB71--",
        "outputId": "64eda95a-b050-4893-b8f9-2263e88ee840"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "LabelEncoder applied to target variable. Classes: ['<=50K' '>50K']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 4: Splitting the Data into Training and Test Sets"
      ],
      "metadata": {
        "id": "Nlz3HPbfjF4s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We split the dataset so that we have a training set (for model fitting and hyperparameter tuning) and a test set (for final evaluation)."
      ],
      "metadata": {
        "id": "29G-iMK1jIpp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=TEST_SIZE, random_state=RANDOM_STATE)\n",
        "print(\"Data split into training and test sets.\")\n",
        "print(f\"X_train: {X_train.shape}, y_train: {y_train.shape}\")\n",
        "print(f\"X_test: {X_test.shape}, y_test: {y_test.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7yk84LENjL--",
        "outputId": "0cc85bc6-001c-4a0d-d702-9714529474e4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data split into training and test sets.\n",
            "X_train: (39073, 14), y_train: (39073,)\n",
            "X_test: (9769, 14), y_test: (9769,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 5: Hyperparameter Tuning Setup"
      ],
      "metadata": {
        "id": "XIIsh7b8jeYw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To tune hyperparameters, we need to:\n",
        "- Identify numerical and categorical features.\n",
        "- Define preprocessing pipelines.\n",
        "- Create a pipeline that first preprocesses data and then fits the estimator.\n",
        "- Use a parameter grid to search over possible hyperparameters.\n",
        "- Use cross-validation (CV) to evaluate combinations.\n",
        "\n",
        "We'll work with a **LogisticRegression** model as example and a predefined `PARAM_GRID` for it."
      ],
      "metadata": {
        "id": "edSfbhejjhuZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler\n",
        "from sklearn.model_selection import GridSearchCV, KFold\n",
        "\n",
        "# Identify numerical and categorical columns\n",
        "numerical_cols = X_train.select_dtypes(include=['int64', 'float64']).columns.tolist()\n",
        "categorical_cols = X_train.select_dtypes(include=['object', 'category']).columns.tolist()\n",
        "\n",
        "print(\"Numerical columns:\", numerical_cols)\n",
        "print(\"Categorical columns:\", categorical_cols)\n",
        "\n",
        "# Preprocessing for numerical data\n",
        "numerical_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='median')),\n",
        "    ('scaler', StandardScaler())\n",
        "])\n",
        "\n",
        "# Preprocessing for categorical data\n",
        "# Determine encoding strategy based on model type (tree-based vs. others)\n",
        "tree_based_classifiers = [\n",
        "    'DecisionTreeClassifier', 'RandomForestClassifier', 'ExtraTreesClassifier',\n",
        "    'GradientBoostingClassifier', 'XGBClassifier', 'LGBMClassifier', 'CatBoostClassifier'\n",
        "]\n",
        "\n",
        "if MODEL_NAME in tree_based_classifiers:\n",
        "    categorical_transformer = Pipeline(steps=[\n",
        "        ('imputer', SimpleImputer(strategy='constant', fill_value='Missing')),\n",
        "        ('ordinal_encoder', OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1))\n",
        "    ])\n",
        "else:\n",
        "    categorical_transformer = Pipeline(steps=[\n",
        "        ('imputer', SimpleImputer(strategy='constant', fill_value='Missing')),\n",
        "        ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))\n",
        "    ])\n",
        "\n",
        "# Create preprocessing pipeline\n",
        "preprocessor = ColumnTransformer(transformers=[\n",
        "    ('num', numerical_transformer, numerical_cols),\n",
        "    ('cat', categorical_transformer, categorical_cols)\n",
        "])\n",
        "\n",
        "print(\"Preprocessing pipeline defined.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wnqG3AibjqrP",
        "outputId": "e25a8398-bc91-49dc-e451-d07a17e3ae67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Numerical columns: ['age', 'fnlwgt', 'educational-num', 'capital-gain', 'capital-loss', 'hours-per-week']\n",
            "Categorical columns: ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'gender', 'native-country']\n",
            "Preprocessing pipeline defined.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 6: Creating the Pipeline and Running Hyperparameter Tuning"
      ],
      "metadata": {
        "id": "d7mgX5ySj_c-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We will:\n",
        "- Create a pipeline that includes preprocessing and the estimator.\n",
        "- Run `GridSearchCV` with the parameter grid, cross-validation folds, and the chosen scoring metric.\n",
        "- Measure the time taken for hyperparameter tuning."
      ],
      "metadata": {
        "id": "h4JitbgbkCU2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the pipeline with preprocessor and estimator\n",
        "pipeline = Pipeline(steps=[\n",
        "    ('preprocessor', preprocessor),\n",
        "    ('model', ESTIMATOR)\n",
        "])\n",
        "\n",
        "# Define cross-validation strategy\n",
        "if isinstance(CV_FOLDS, int):\n",
        "    CV_FOLDS = KFold(n_splits=CV_FOLDS, shuffle=True, random_state=RANDOM_STATE)\n",
        "\n",
        "grid_search = GridSearchCV(\n",
        "    estimator=pipeline,\n",
        "    param_grid=PARAM_GRID,\n",
        "    cv=CV_FOLDS,\n",
        "    scoring=SCORING_METRIC,\n",
        "    n_jobs=-1\n",
        ")\n",
        "\n",
        "# Time the training\n",
        "start_time = timer()\n",
        "grid_search.fit(X_train, y_train)\n",
        "end_time = timer()\n",
        "train_time = end_time - start_time\n",
        "\n",
        "best_model = grid_search.best_estimator_\n",
        "best_params = grid_search.best_params_\n",
        "\n",
        "print(f\"Best Hyperparameters for {MODEL_NAME}:\")\n",
        "for param_name in sorted(best_params.keys()):\n",
        "    print(f\"{param_name}: {best_params[param_name]}\")\n",
        "\n",
        "print(f\"Hyperparameter tuning completed in {train_time:.2f} seconds.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "frMc-h7ykEXI",
        "outputId": "e75e63c6-ca24-4116-b2ed-d0f8bc7ade81"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best Hyperparameters for LogisticRegression:\n",
            "model__C: 1.0\n",
            "model__max_iter: 1000\n",
            "model__penalty: l2\n",
            "model__solver: lbfgs\n",
            "Hyperparameter tuning completed in 17.17 seconds.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 7: Model Evaluation"
      ],
      "metadata": {
        "id": "yVPt5wJ7kkNy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "With the best model found, we evaluate it on the test set:\n",
        "- Predict on `X_test`.\n",
        "- Calculate metrics: Accuracy, Precision, Recall, F1-Score.\n",
        "- Print and save these metrics."
      ],
      "metadata": {
        "id": "Fu_0_XiwknKQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
        "# Predict on test set\n",
        "y_pred = best_model.predict(X_test)\n",
        "\n",
        "# Calculate classification metrics\n",
        "accuracy = accuracy_score(y_test, y_pred)\n",
        "precision = precision_score(y_test, y_pred, average='weighted', zero_division=0)\n",
        "recall = recall_score(y_test, y_pred, average='weighted', zero_division=0)\n",
        "f1 = f1_score(y_test, y_pred, average='weighted', zero_division=0)\n",
        "\n",
        "print(f\"\\n{MODEL_NAME} Classification Metrics on Test Set:\")\n",
        "print(f\"- Accuracy: {accuracy:.4f}\")\n",
        "print(f\"- Precision: {precision:.4f}\")\n",
        "print(f\"- Recall: {recall:.4f}\")\n",
        "print(f\"- F1 Score: {f1:.4f}\")\n",
        "print(f\"- Training Time: {train_time:.4f} seconds\")\n",
        "\n",
        "metrics = {\n",
        "    'Accuracy': [accuracy],\n",
        "    'Precision': [precision],\n",
        "    'Recall': [recall],\n",
        "    'F1 Score': [f1],\n",
        "    'train_time': [train_time]\n",
        "}\n",
        "\n",
        "results_df = pd.DataFrame(metrics)\n",
        "results_df.to_csv(os.path.join(RESULTS_PATH, 'metrics.csv'), index=False)\n",
        "print(f\"\\nMetrics saved to {os.path.join(RESULTS_PATH, 'metrics.csv')}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QZjB-TDwkpB_",
        "outputId": "8876b735-5101-494b-e650-ca6697402a95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "LogisticRegression Classification Metrics on Test Set:\n",
            "- Accuracy: 0.8570\n",
            "- Precision: 0.8509\n",
            "- Recall: 0.8570\n",
            "- F1 Score: 0.8520\n",
            "- Training Time: 17.1726 seconds\n",
            "\n",
            "Metrics saved to results/metrics.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Step 8: Visualization and Saving the Model"
      ],
      "metadata": {
        "id": "CQpgZ5q4ky1P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Plot and save the classification metrics and confusion matrix to visualize how well the model performs.\n",
        "- Save the trained model using `joblib` for future use without re-training."
      ],
      "metadata": {
        "id": "EDKLKRenk2SF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot Classification Metrics\n",
        "plt.figure(figsize=(8, 6))\n",
        "metric_names = list(metrics.keys())\n",
        "metric_values = [value[0] for value in metrics.values() if value[0] is not None and isinstance(value[0], (int,float))]\n",
        "plt.bar(metric_names[:-1], metric_values[:-1], color='skyblue', alpha=0.8)  # exclude train_time from plotting\n",
        "plt.ylim(0, 1)\n",
        "plt.xlabel('Metrics')\n",
        "plt.ylabel('Scores')\n",
        "plt.title('Classification Metrics')\n",
        "plt.savefig(os.path.join(RESULTS_PATH, 'classification_metrics.png'))\n",
        "plt.show()\n",
        "print(f\"Visualization saved to {os.path.join(RESULTS_PATH, 'classification_metrics.png')}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 581
        },
        "id": "3lmrkDzdBg-b",
        "outputId": "9a75ed7d-fab2-4991-caa5-55af1b01070b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Visualization saved to results/classification_metrics.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Display and save the confusion matrix\n",
        "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
        "\n",
        "# Load the label encoder (if it exists)\n",
        "label_encoder_path = os.path.join(MODEL_PATH, \"label_encoder.pkl\")\n",
        "if os.path.exists(label_encoder_path):\n",
        "    label_encoder = joblib.load(label_encoder_path)\n",
        "    # Decode the predicted and true labels\n",
        "    y_test_decoded = label_encoder.inverse_transform(y_test)\n",
        "    y_pred_decoded = label_encoder.inverse_transform(y_pred)\n",
        "    display_labels = label_encoder.classes_\n",
        "else:\n",
        "    # If no encoder, use the original numeric labels\n",
        "    y_test_decoded = y_test\n",
        "    y_pred_decoded = y_pred\n",
        "    display_labels = None  # Numeric labels will be used by default\n",
        "\n",
        "# Save confusion matrix\n",
        "conf_mat = confusion_matrix(y_test_decoded, y_pred_decoded)\n",
        "plt.figure(figsize=(10, 8))  # Increased figure size for better spacing\n",
        "disp = ConfusionMatrixDisplay(conf_mat, display_labels=display_labels)\n",
        "\n",
        "# Customize the plot\n",
        "disp.plot(cmap=\"Blues\", values_format=\"d\", ax=plt.gca())\n",
        "plt.title(\"Confusion Matrix\", fontsize=16, pad=20)  # Increased font size and added padding\n",
        "plt.xticks(rotation=45, ha=\"right\", fontsize=12)  # Rotated x-axis labels and increased font size\n",
        "plt.yticks(fontsize=12)  # Increased font size for y-axis labels\n",
        "plt.xlabel(\"Predicted Label\", fontsize=14)  # Added font size for x-axis label\n",
        "plt.ylabel(\"True Label\", fontsize=14)  # Added font size for y-axis label\n",
        "\n",
        "# Save the improved plot\n",
        "cm_path = os.path.join(RESULTS_PATH, \"confusion_matrix.png\")\n",
        "plt.savefig(cm_path, bbox_inches=\"tight\")  # Ensures no clipping of labels\n",
        "plt.show()\n",
        "\n",
        "print(f\"Confusion matrix saved to {cm_path}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 803
        },
        "id": "M7Hxq8EaBiPq",
        "outputId": "fa4f3a88-6962-40e4-a816-a903034d756f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x800 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Confusion matrix saved to results/confusion_matrix.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Save the trained model\n",
        "model_output_path = os.path.join(MODEL_PATH, 'best_model.pkl')\n",
        "joblib.dump(best_model, model_output_path)\n",
        "print(f\"Trained model saved to {model_output_path}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Xd4yqs2k3oo",
        "outputId": "ce8a0f90-42ff-4db6-cf04-b77a9be0c1a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Trained model saved to saved_models/best_model.pkl\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 4. Conclusion\n",
        "<a id=\"Conclusion\"></a>"
      ],
      "metadata": {
        "id": "dsgu8HVtDzga"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this notebook, we explored the full lifecycle of training classification models—from initial data setup to interactive, UI-driven training and evaluation. We demonstrated how to:\n",
        "\n",
        "- **Execute Classification Models:** Quickly run a variety of classifiers (logistic regression, tree-based methods, ensemble models, SVMs, neural networks, etc.) with either default settings or custom hyperparameters.\n",
        "- **Manage Datasets:** Upload your own CSV files, provide data paths, or even download datasets directly from Kaggle.\n",
        "- **Preprocess Data Automatically:** Utilize preprocessing pipelines that handle missing values, scaling, and encoding categorical features, ensuring models receive well-prepared inputs.\n",
        "- **Tune Hyperparameters:** Use `GridSearchCV` to systematically find the best configuration of model and preprocessing parameters for optimal performance.\n",
        "- **Evaluate and Visualize Results:** Assess models using metrics like accuracy, precision, recall, and F1-score, and visualize outcomes through confusion matrices and metric bar charts.\n",
        "- **Interact Through a Gradio Interface:** Train models interactively without code adjustments, making it accessible for users of all skill levels.\n",
        "\n",
        "By combining theoretical understanding with hands-on implementation, this notebook provides a versatile foundation for classification problems. Whether you're just beginning to learn about classification algorithms or you're an experienced practitioner fine-tuning complex ensembles, the workflows here can be adapted to various datasets and objectives.\n",
        "\n",
        "Feel free to modify, extend, and build upon the examples shown. With the tools and insights gained, you're well-equipped to tackle a wide range of classification challenges in your machine learning projects.\n",
        "\n",
        "Thank you for using this guide!"
      ],
      "metadata": {
        "id": "DdK3Z6FqVdUl"
      }
    }
  ]
}