loan_defaults_013_feature_engineering_pipeline_debug.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyN8Mypg6wsMjumJ3Jli+mvE",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/micah-shull/ML_Classification_Loan_Defaults/blob/main/loan_defaults_013_feature_engineering_pipeline_debug.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Data Description\n",
        "\n",
        "This dataset contains information on clients' credit card behavior, provided by a financial institution in Taiwan. The target variable is `default_payment_next_month`, which indicates whether the client defaulted on their credit card payment the next month.\n",
        "\n",
        "url = https://archive.ics.uci.edu/dataset/350/default+of+credit+card+clients\n",
        "\n",
        "#### Variables:\n",
        "\n",
        "- **ID**: ID of each client.\n",
        "- **LIMIT_BAL**: Amount of given credit in NT dollars (includes individual and family/supplementary credit).\n",
        "- **SEX**: Gender (1 = male, 2 = female).\n",
        "- **EDUCATION**: Education level (1 = graduate school, 2 = university, 3 = high school, 4 = others, 5 = unknown, 6 = unknown).\n",
        "- **MARRIAGE**: Marital status (1 = married, 2 = single, 3 = others).\n",
        "- **AGE**: Age in years.\n",
        "\n",
        "#### Payment History (PAY_X):\n",
        "- **PAY_0**: Repayment status in September 2005 (-1 = pay duly, 1 = payment delay for one month, 2 = payment delay for two months, ... 8 = payment delay for eight months, 9 = payment delay for nine months and above).\n",
        "- **PAY_2**: Repayment status in August 2005.\n",
        "- **PAY_3**: Repayment status in July 2005.\n",
        "- **PAY_4**: Repayment status in June 2005.\n",
        "- **PAY_5**: Repayment status in May 2005.\n",
        "- **PAY_6**: Repayment status in April 2005.\n",
        "\n",
        "#### Bill Statement Amount (BILL_AMT_X):\n",
        "- **BILL_AMT1**: Amount of bill statement in September 2005 (NT dollars).\n",
        "- **BILL_AMT2**: Amount of bill statement in August 2005 (NT dollars).\n",
        "- **BILL_AMT3**: Amount of bill statement in July 2005 (NT dollars).\n",
        "- **BILL_AMT4**: Amount of bill statement in June 2005 (NT dollars).\n",
        "- **BILL_AMT5**: Amount of bill statement in May 2005 (NT dollars).\n",
        "- **BILL_AMT6**: Amount of bill statement in April 2005 (NT dollars).\n",
        "\n",
        "#### Previous Payment Amount (PAY_AMT_X):\n",
        "- **PAY_AMT1**: Amount of previous payment in September 2005 (NT dollars).\n",
        "- **PAY_AMT2**: Amount of previous payment in August 2005 (NT dollars).\n",
        "- **PAY_AMT3**: Amount of previous payment in July 2005 (NT dollars).\n",
        "- **PAY_AMT4**: Amount of previous payment in June 2005 (NT dollars).\n",
        "- **PAY_AMT5**: Amount of previous payment in May 2005 (NT dollars).\n",
        "- **PAY_AMT6**: Amount of previous payment in April 2005 (NT dollars).\n",
        "\n",
        "- **default_payment_next_month**: Default payment indicator (1 = yes, 0 = no).\n",
        "\n",
        "#### Explanation for Feature Reordering:\n",
        "The bill statement and payment amounts are listed in reverse chronological order in the dataset. To ensure that the feature names match the actual sequence of events, we reverse the column names for `BILL_AMT` and `PAY_AMT` features so that they correctly represent the time sequence from April 2005 to September 2005.\n",
        "\n"
      ],
      "metadata": {
        "id": "NjJGNa0zVRt4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Load & Preprocess Data"
      ],
      "metadata": {
        "id": "_vARfjW4_LcJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from loan_data_utils import (load_data_from_url, clean_column_names, remove_id_column, rename_pay_columns, rename_bill_and_payment_columns,\n",
        "                             label_pay_columns, convert_pay_columns_to_ordinal, reorder_columns, convert_education_to_ordinal, process_sex_column, process_sex_column_cat_codes_one_two,\n",
        "                             process_marriage_column, process_default_payment_column, convert_ordinal_to_category, check_column_integrity, validate_data_types,\n",
        "                             check_categorical_order, primary_columns, bill_columns, pay_columns, ordinal_columns, categorical_columns,\n",
        "                             plot_categorical_distributions, plot_ordinal_distributions)\n",
        "from eda_utils import data_overview, plot_univariate_distributions, plot_class_distribution\n",
        "import logging\n",
        "\n",
        "# Define your URL, categorical columns, and target\n",
        "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls\"\n",
        "categorical_columns = ['sex', 'marriage']\n",
        "target = 'default_payment_next_month'\n",
        "\n",
        "# Now, load the data\n",
        "df = load_and_preprocess_data(url, categorical_columns, target)\n",
        "\n",
        "if df is not None:\n",
        "    # Ensure the target column is treated as a categorical variable\n",
        "    df[target] = df[target].astype('category')\n",
        "\n",
        "    # Print data overview\n",
        "    data_overview(df)\n",
        "\n",
        "    # Drop duplicate rows (optional if you didn’t remove them earlier)\n",
        "    df = df.drop_duplicates()\n",
        "\n",
        "    # Confirm the duplicates are removed\n",
        "    print(f\"Number of Duplicate Rows After Dropping: {df.duplicated().sum()}\")\n",
        "\n",
        "    # List of columns to check\n",
        "    pay_cols = [col for col in df.columns if col.startswith('pay_delay')]\n",
        "\n",
        "    # Check the order of categorical columns\n",
        "    check_categorical_order(df, categorical_columns + pay_cols + [target])\n",
        "else:\n",
        "    print(\"Error loading and preprocessing data.\")\n",
        "\n",
        "# visualize the categorical data\n",
        "plot_categorical_distributions(df, categorical_columns)\n",
        "plot_ordinal_distributions(df, ordinal_columns)"
      ],
      "metadata": {
        "id": "6HxbQMjvTcYL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "deedc6a5-e3b5-4c8d-b0a0-70418fa0b29c",
        "collapsed": true
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Missing Values: 0\n",
            "Missing Percentage: 0.0\n",
            "Number of Duplicate Rows: 0\n",
            "\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Index: 29965 entries, 0 to 29999\n",
            "Data columns (total 24 columns):\n",
            " #   Column                      Non-Null Count  Dtype   \n",
            "---  ------                      --------------  -----   \n",
            " 0   limit_bal                   29965 non-null  int64   \n",
            " 1   sex                         29965 non-null  category\n",
            " 2   education                   29965 non-null  category\n",
            " 3   marriage                    29965 non-null  category\n",
            " 4   age                         29965 non-null  int64   \n",
            " 5   bill_amt_4_april            29965 non-null  int64   \n",
            " 6   bill_amt_5_may              29965 non-null  int64   \n",
            " 7   bill_amt_6_june             29965 non-null  int64   \n",
            " 8   bill_amt_7_july             29965 non-null  int64   \n",
            " 9   bill_amt_8_august           29965 non-null  int64   \n",
            " 10  bill_amt_9_september        29965 non-null  int64   \n",
            " 11  pay_amt_4_april             29965 non-null  int64   \n",
            " 12  pay_amt_5_may               29965 non-null  int64   \n",
            " 13  pay_amt_6_june              29965 non-null  int64   \n",
            " 14  pay_amt_7_july              29965 non-null  int64   \n",
            " 15  pay_amt_8_august            29965 non-null  int64   \n",
            " 16  pay_amt_9_september         29965 non-null  int64   \n",
            " 17  pay_delay_4_april           29965 non-null  category\n",
            " 18  pay_delay_5_may             29965 non-null  category\n",
            " 19  pay_delay_6_june            29965 non-null  category\n",
            " 20  pay_delay_7_july            29965 non-null  category\n",
            " 21  pay_delay_8_august          29965 non-null  category\n",
            " 22  pay_delay_9_september       29965 non-null  category\n",
            " 23  default_payment_next_month  29965 non-null  category\n",
            "dtypes: category(10), int64(14)\n",
            "memory usage: 3.7 MB\n",
            "Number of Duplicate Rows After Dropping: 0\n",
            "Column: sex\n",
            "Categories: Index(['Female', 'Male'], dtype='object')\n",
            "Ordered: False\n",
            "\n",
            "Column: marriage\n",
            "Categories: Index(['Married', 'Single', 'Unknown/Others'], dtype='object')\n",
            "Ordered: False\n",
            "\n",
            "Column: pay_delay_4_april\n",
            "Categories: Index(['No consumption', 'Paid in full', 'Revolving credit', '1 month delay',\n",
            "       '2 months delay', '3 months delay', '4 months delay', '5 months delay',\n",
            "       '6 months delay', '7 months delay', '8 months delay',\n",
            "       '9+ months delay'],\n",
            "      dtype='object')\n",
            "Ordered: True\n",
            "\n",
            "Column: pay_delay_5_may\n",
            "Categories: Index(['No consumption', 'Paid in full', 'Revolving credit', '1 month delay',\n",
            "       '2 months delay', '3 months delay', '4 months delay', '5 months delay',\n",
            "       '6 months delay', '7 months delay', '8 months delay',\n",
            "       '9+ months delay'],\n",
            "      dtype='object')\n",
            "Ordered: True\n",
            "\n",
            "Column: pay_delay_6_june\n",
            "Categories: Index(['No consumption', 'Paid in full', 'Revolving credit', '1 month delay',\n",
            "       '2 months delay', '3 months delay', '4 months delay', '5 months delay',\n",
            "       '6 months delay', '7 months delay', '8 months delay',\n",
            "       '9+ months delay'],\n",
            "      dtype='object')\n",
            "Ordered: True\n",
            "\n",
            "Column: pay_delay_7_july\n",
            "Categories: Index(['No consumption', 'Paid in full', 'Revolving credit', '1 month delay',\n",
            "       '2 months delay', '3 months delay', '4 months delay', '5 months delay',\n",
            "       '6 months delay', '7 months delay', '8 months delay',\n",
            "       '9+ months delay'],\n",
            "      dtype='object')\n",
            "Ordered: True\n",
            "\n",
            "Column: pay_delay_8_august\n",
            "Categories: Index(['No consumption', 'Paid in full', 'Revolving credit', '1 month delay',\n",
            "       '2 months delay', '3 months delay', '4 months delay', '5 months delay',\n",
            "       '6 months delay', '7 months delay', '8 months delay',\n",
            "       '9+ months delay'],\n",
            "      dtype='object')\n",
            "Ordered: True\n",
            "\n",
            "Column: pay_delay_9_september\n",
            "Categories: Index(['No consumption', 'Paid in full', 'Revolving credit', '1 month delay',\n",
            "       '2 months delay', '3 months delay', '4 months delay', '5 months delay',\n",
            "       '6 months delay', '7 months delay', '8 months delay',\n",
            "       '9+ months delay'],\n",
            "      dtype='object')\n",
            "Ordered: True\n",
            "\n",
            "Column: default_payment_next_month\n",
            "Categories: Index(['Default', 'No Default'], dtype='object')\n",
            "Ordered: False\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1600x1400 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1600x2500 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Process Categorical Data**\n",
        "\n",
        "#### Pipeline Processing Limitations:\n",
        "When using `OneHotEncoder` with `handle_unknown='ignore'`, any unknown categories in the `sex` or `marriage` columns would be encoded as all zeros. This could inadvertently cause the model to interpret unknown values as \"female\" for `sex` and \"married\" for `marriage`, potentially leading to misclassification.\n",
        "\n",
        "#### Category Code Adjustment:\n",
        "To avoid this, we adjusted the category codes for `sex` and `marriage` to start from `1`, reserving `0` for unknown categories:\n",
        "- **`sex`**: Male is encoded as `1`, Female as `2`, with unknowns as `0`.\n",
        "- **`marriage`**: Single is `1`, Married `2`, and Others `3`, with unknowns as `0`.\n",
        "\n",
        "This adjustment ensures that unknown categories are clearly distinguished from valid categories, improving the robustness of the model.\n",
        "\n",
        "For ordinal columns where order matters (e.g., education levels), we handle unknowns by assigning them a category of `-1`. This approach maintains clarity and prevents misinterpretation during model training.\n",
        "\n",
        "### **Target as Category**\n",
        "\n",
        "### 1. **Compatibility with Machine Learning Models**:\n",
        "Most machine learning algorithms expect numeric inputs, including for the target variable. By converting the categorical target ('Default', 'No Default') into numeric codes (`0` and `1`), we ensure that the models can process the target data correctly without errors or misinterpretations.\n",
        "\n",
        "### 2. **Binary Classification**:\n",
        "In binary classification tasks (like predicting loan defaults), having a target variable in numeric format (`0` for 'Default' and `1` for 'No Default') aligns with standard conventions in machine learning. This format simplifies performance evaluation, especially when calculating metrics such as precision, recall, and F1-score.\n",
        "\n",
        "### 3. **Simplifies Threshold-based Decisions**:\n",
        "When implementing custom thresholds for classification, using numeric values (`0` and `1`) allows the use of continuous probability outputs from models, making it easier to adjust and interpret decision thresholds.\n",
        "\n",
        "### 4. **Avoiding Issues with Category Handling**:\n",
        "Using categories (such as 'Default' and 'No Default') can introduce complexities during model evaluation, especially when using functions like `classification_report` that expect numeric labels. By converting to numeric codes, we avoid any mismatches or errors when calculating metrics.\n",
        "\n",
        "### Conclusion:\n",
        "By converting the categorical target to numeric codes, we ensure better model compatibility, simplify classification tasks, and avoid potential issues during evaluation and threshold adjustment. This step helps to streamline the overall modeling process."
      ],
      "metadata": {
        "id": "k3sNMbht7wEo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Current Cat Codes for Sex:', df['sex'].cat.codes.unique())\n",
        "print('Current Cat Codes for Marriage:', df['marriage'].cat.codes.unique())\n",
        "\n",
        "# Adjust category codes manually by adding 1 to the existing codes\n",
        "df['sex'] = df['sex'].cat.codes + 1\n",
        "df['marriage'] = df['marriage'].cat.codes + 1\n",
        "\n",
        "# Recast the adjusted columns back to 'category' dtype with 0 for unknowns\n",
        "df['sex'] = pd.Categorical(df['sex'], categories=[0, 1, 2], ordered=False)\n",
        "df['marriage'] = pd.Categorical(df['marriage'], categories=[0, 1, 2, 3], ordered=False)\n",
        "\n",
        "# Confirm the unique category codes\n",
        "print('Cat Codes after Recoding - Sex:', df['sex'].cat.codes.unique())  # Output: [1 2]\n",
        "print('Cat Codes after Recoding - Marriage:', df['marriage'].cat.codes.unique())  # Output: [1 2 3]\n",
        "\n",
        "print('Target currently categorical')\n",
        "print(df[target].unique())\n",
        "\n",
        "df[target] = df[target].cat.codes  # Convert to categorical codes (0, 1)\n",
        "\n",
        "# Check the results\n",
        "print('Target converted to numeric')\n",
        "print(df[target].unique())  # Should output [0, 1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5gaFv_JDV7RS",
        "outputId": "1d022865-0808-47d8-f5f3-947af3ce8a05"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Current Cat Codes for Sex: [0 1]\n",
            "Current Cat Codes for Marriage: [0 1 2]\n",
            "Cat Codes after Recoding - Sex: [1 2]\n",
            "Cat Codes after Recoding - Marriage: [1 2 3]\n",
            "Target currently categorical\n",
            "['Default', 'No Default']\n",
            "Categories (2, object): ['Default', 'No Default']\n",
            "Target converted to numeric\n",
            "[0 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Baseline Model - No Resampling, No Threshold"
      ],
      "metadata": {
        "id": "Ujtwmou9gixe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler, OneHotEncoder, OrdinalEncoder\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.metrics import classification_report\n",
        "from sklearn.model_selection import train_test_split\n",
        "from loan_data_utils import ThresholdClassifier, save_classification_reports, save_classification_reports_with_categories\n",
        "from feature_engineering_pipeline_utils import (HighRiskDelayFeatureTransformer, SevereDelayCountTransformer, CumulativeDelayTransformer,\n",
        "                                                SevereDelayPaymentRatioTransformer, AvgPaymentSevereDelaysTransformer, DeferredAndDecreasingPaymentsTransformer,\n",
        "                                                SevereDeferredAndDecreasingPaymentsTransformer, SevereDeferredAndAnyDecreasingPaymentsTransformer,\n",
        "                                                TotalPaymentsTransformer, AvgPaymentTransformer, PaymentStdTransformer, WeightedPaymentSumTransformer,\n",
        "                                                TotalBillsTransformer, DebtToLimitRatioTransformer, EducationMarriageInteractionTransformer, WinsorRobustOutlierRemovalTransformer)\n",
        "\n",
        "# Define the target\n",
        "target = 'default_payment_next_month'\n",
        "\n",
        "# Split the data into features and target\n",
        "X = df.drop(columns=[target])\n",
        "y = df[target]\n",
        "\n",
        "# Perform the train-test split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
        "\n",
        "# Define the columns\n",
        "numeric_features = ['age', 'limit_bal']\n",
        "pay_columns = ['pay_amt_4_april', 'pay_amt_5_may',\n",
        "               'pay_amt_6_june', 'pay_amt_7_july',\n",
        "               'pay_amt_8_august', 'pay_amt_9_september',\n",
        "               'bill_amt_4_april', 'bill_amt_5_may',\n",
        "               'bill_amt_6_june', 'bill_amt_7_july',\n",
        "               'bill_amt_8_august', 'bill_amt_9_september']\n",
        "categorical_features = ['sex', 'marriage']\n",
        "ordinal_features = ['education', 'pay_delay_4_april', 'pay_delay_5_may',\n",
        "                    'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "delay_columns = ['pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "bill_columns = ['bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june', 'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september']\n",
        "\n",
        "# Feature Engineering Pipeline\n",
        "feature_engineering_pipeline = Pipeline(steps=[\n",
        "    ('high_risk_delay', HighRiskDelayFeatureTransformer(delay_columns=delay_columns)),\n",
        "    ('severe_delay_count', SevereDelayCountTransformer(delay_columns=delay_columns)),\n",
        "    ('cumulative_delay', CumulativeDelayTransformer(delay_columns=delay_columns)),\n",
        "    ('severe_delay_payment_ratio', SevereDelayPaymentRatioTransformer(pay_columns=pay_columns)),\n",
        "    ('avg_payment_severe_delays', AvgPaymentSevereDelaysTransformer()),\n",
        "    ('deferred_and_decreasing_payments', DeferredAndDecreasingPaymentsTransformer(delay_columns=delay_columns, pay_columns=pay_columns)),\n",
        "    ('severe_deferred_and_decreasing_payments', SevereDeferredAndDecreasingPaymentsTransformer(delay_columns=delay_columns, pay_columns=pay_columns)),\n",
        "    ('severe_deferred_and_any_decreasing_payments', SevereDeferredAndAnyDecreasingPaymentsTransformer(delay_columns=delay_columns, pay_columns=pay_columns)),\n",
        "    ('total_payments', TotalPaymentsTransformer(pay_columns=pay_columns)),\n",
        "    ('avg_payment', AvgPaymentTransformer()),\n",
        "    ('payment_std', PaymentStdTransformer(pay_columns=pay_columns)),\n",
        "    ('weighted_payment_sum', WeightedPaymentSumTransformer(pay_columns=pay_columns)),\n",
        "    ('total_bills', TotalBillsTransformer(bill_columns=bill_columns)),  # First create total bills\n",
        "    ('debt_to_limit_ratio', DebtToLimitRatioTransformer(total_bills_column='total_bills', limit_bal_column='limit_bal')),  # Then create the ratio\n",
        "    ('education_marriage_interaction', EducationMarriageInteractionTransformer())\n",
        "])\n",
        "\n",
        "# Step 1: Outlier Removal Pipeline\n",
        "outlier_removal_pipeline = Pipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns))\n",
        "])\n",
        "\n",
        "# Step 2: Preprocessing Pipeline\n",
        "numeric_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='mean')),\n",
        "    ('scaler', StandardScaler())\n",
        "])\n",
        "\n",
        "# We use passthrough here since no transformations are applied to pay_columns before feature engineering\n",
        "# pay_transformer = 'passthrough'\n",
        "\n",
        "categorical_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('onehot', OneHotEncoder(handle_unknown='ignore'))\n",
        "])\n",
        "\n",
        "ordinal_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('ordinal', OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1))\n",
        "])\n",
        "\n",
        "preprocessor = ColumnTransformer(\n",
        "    transformers=[\n",
        "        ('num', numeric_transformer, numeric_features),\n",
        "        # ('pay', pay_transformer, pay_columns),  # Pass through pay_columns without transformation\n",
        "        ('cat', categorical_transformer, categorical_features),\n",
        "        ('ord', ordinal_transformer, ordinal_features)\n",
        "    ])\n",
        "\n",
        "# Step 3: Final Pipeline\n",
        "baseline_pipeline = Pipeline(steps=[\n",
        "    ('outlier_removal', outlier_removal_pipeline),         # Step 1: Outlier Removal\n",
        "    ('feature_engineering', feature_engineering_pipeline), # Step 2: Feature Engineering\n",
        "    ('preprocessor', preprocessor),                        # Step 3: Preprocessing\n",
        "    ('classifier', LogisticRegression(max_iter=1000))      # Step 4: Model\n",
        "])\n",
        "\n",
        "# Train the pipeline\n",
        "baseline_pipeline.fit(X_train, y_train)\n",
        "\n",
        "# Predict and evaluate\n",
        "y_pred_baseline = baseline_pipeline.predict(X_test)\n",
        "classification_report_baseline = classification_report(y_test, y_pred_baseline, output_dict=True)  # Get dict for JSON saving\n",
        "print(\"Classification Report (Baseline):\")\n",
        "print(classification_report(y_test, y_pred_baseline))\n",
        "\n",
        "# Step 3: Save the classification report as 'baseline'\n",
        "classification_reports = {'baseline': classification_report_baseline}\n",
        "save_classification_reports(classification_reports, filename='classification_reports.json')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "imTxfk4oghfW",
        "outputId": "08e93db9-af4f-430f-f13d-36c522916a77"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Classification Report (Baseline):\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.63      0.28      0.39      1326\n",
            "           1       0.82      0.95      0.88      4667\n",
            "\n",
            "    accuracy                           0.80      5993\n",
            "   macro avg       0.73      0.62      0.63      5993\n",
            "weighted avg       0.78      0.80      0.77      5993\n",
            "\n",
            "Classification reports saved as classification_reports.json\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## SMOTE Model - Original"
      ],
      "metadata": {
        "id": "tHgTM8zPwKxk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler, OneHotEncoder, OrdinalEncoder\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.metrics import classification_report\n",
        "from imblearn.pipeline import Pipeline as IMBPipeline\n",
        "from imblearn.over_sampling import SMOTE\n",
        "from feature_engineering_pipeline_utils import (HighRiskDelayFeatureTransformer, SevereDelayCountTransformer, CumulativeDelayTransformer,\n",
        "                                                SevereDelayPaymentRatioTransformer, AvgPaymentSevereDelaysTransformer, DeferredAndDecreasingPaymentsTransformer,\n",
        "                                                SevereDeferredAndDecreasingPaymentsTransformer, SevereDeferredAndAnyDecreasingPaymentsTransformer,\n",
        "                                                TotalPaymentsTransformer, AvgPaymentTransformer, PaymentStdTransformer, WeightedPaymentSumTransformer,\n",
        "                                                TotalBillsTransformer, DebtToLimitRatioTransformer, EducationMarriageInteractionTransformer, WinsorRobustOutlierRemovalTransformer,\n",
        "                                                CombinedFeatureEngineeringTransformer)\n",
        "\n",
        "# Define the target\n",
        "target = 'default_payment_next_month'\n",
        "\n",
        "# Split the data into features and target\n",
        "X = df.drop(columns=[target])\n",
        "y = df[target]\n",
        "\n",
        "# Perform the train-test split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
        "\n",
        "# Define the columns\n",
        "numeric_features = ['age', 'limit_bal']\n",
        "pay_columns = ['pay_amt_4_april', 'pay_amt_5_may',\n",
        "               'pay_amt_6_june', 'pay_amt_7_july',\n",
        "               'pay_amt_8_august', 'pay_amt_9_september',\n",
        "               'bill_amt_4_april', 'bill_amt_5_may',\n",
        "               'bill_amt_6_june', 'bill_amt_7_july',\n",
        "               'bill_amt_8_august', 'bill_amt_9_september']\n",
        "categorical_features = ['sex', 'marriage']\n",
        "ordinal_features = ['education', 'pay_delay_4_april', 'pay_delay_5_may',\n",
        "                    'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "delay_columns = ['pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "bill_columns = ['bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june', 'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september']\n",
        "\n",
        "# Step 1: Feature Engineering First\n",
        "feature_engineering_pipeline = CombinedFeatureEngineeringTransformer(delay_columns, pay_columns, bill_columns)\n",
        "\n",
        "# Step 2: Preprocessing Pipeline\n",
        "numeric_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='mean')),\n",
        "    ('scaler', StandardScaler())\n",
        "])\n",
        "\n",
        "categorical_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('onehot', OneHotEncoder(handle_unknown='ignore'))\n",
        "])\n",
        "\n",
        "ordinal_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('ordinal', OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1))\n",
        "])\n",
        "\n",
        "preprocessor = ColumnTransformer(\n",
        "    transformers=[\n",
        "        ('num', numeric_transformer, numeric_features),\n",
        "        ('cat', categorical_transformer, categorical_features),\n",
        "        ('ord', ordinal_transformer, ordinal_features)\n",
        "    ])\n",
        "\n",
        "# Step 3: Pipeline Setup\n",
        "smote_pipeline = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),\n",
        "    ('feature_engineering', feature_engineering_pipeline),\n",
        "    ('preprocessor', preprocessor),\n",
        "    ('smote', SMOTE(random_state=42)),\n",
        "    ('classifier', LogisticRegression(max_iter=1000))\n",
        "])\n",
        "\n",
        "# Step 4: Train the SMOTE pipeline\n",
        "smote_pipeline.fit(X_train, y_train)\n",
        "\n",
        "# Step 5: Predict and generate the SMOTE classification report\n",
        "y_pred_smote = smote_pipeline.predict(X_test)\n",
        "classification_report_smote = classification_report(y_test, y_pred_smote, output_dict=True)\n",
        "print(\"Classification Report (SMOTE):\")\n",
        "print(classification_report(y_test, y_pred_smote))\n",
        "\n",
        "# Step 6: Append the SMOTE report to the existing baseline report\n",
        "with open('classification_reports.json', 'r') as json_file:\n",
        "    classification_reports = json.load(json_file)\n",
        "\n",
        "# Add SMOTE report\n",
        "classification_reports['smote'] = classification_report_smote\n",
        "\n",
        "# Save the updated reports\n",
        "save_classification_reports(classification_reports, filename='classification_reports.json')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Swb9jBT9Yx6t",
        "outputId": "c6469165-ab2c-446a-e41b-79812cbb7795"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Classification Report (SMOTE):\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.48      0.59      0.53      1326\n",
            "           1       0.87      0.82      0.84      4667\n",
            "\n",
            "    accuracy                           0.77      5993\n",
            "   macro avg       0.68      0.70      0.69      5993\n",
            "weighted avg       0.79      0.77      0.77      5993\n",
            "\n",
            "Classification reports saved as classification_reports.json\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Preprocessing Pipeline Debug"
      ],
      "metadata": {
        "id": "eZHFBIwZRZCU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler, OneHotEncoder, OrdinalEncoder\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.metrics import classification_report\n",
        "from imblearn.pipeline import Pipeline as IMBPipeline\n",
        "from imblearn.over_sampling import SMOTE\n",
        "from feature_engineering_pipeline_utils import (HighRiskDelayFeatureTransformer, SevereDelayCountTransformer, CumulativeDelayTransformer,\n",
        "                                                SevereDelayPaymentRatioTransformer, AvgPaymentSevereDelaysTransformer, DeferredAndDecreasingPaymentsTransformer,\n",
        "                                                SevereDeferredAndDecreasingPaymentsTransformer, SevereDeferredAndAnyDecreasingPaymentsTransformer,\n",
        "                                                TotalPaymentsTransformer, AvgPaymentTransformer, PaymentStdTransformer, WeightedPaymentSumTransformer,\n",
        "                                                TotalBillsTransformer, DebtToLimitRatioTransformer, EducationMarriageInteractionTransformer, WinsorRobustOutlierRemovalTransformer,\n",
        "                                                CombinedFeatureEngineeringTransformer)\n",
        "\n",
        "# Define the target\n",
        "target = 'default_payment_next_month'\n",
        "\n",
        "# Split the data into features and target\n",
        "X = df.drop(columns=[target])\n",
        "y = df[target]\n",
        "\n",
        "# Perform the train-test split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
        "\n",
        "# Define the columns\n",
        "numeric_features = ['age', 'limit_bal']\n",
        "pay_columns = ['pay_amt_4_april', 'pay_amt_5_may',\n",
        "               'pay_amt_6_june', 'pay_amt_7_july',\n",
        "               'pay_amt_8_august', 'pay_amt_9_september',\n",
        "               'bill_amt_4_april', 'bill_amt_5_may',\n",
        "               'bill_amt_6_june', 'bill_amt_7_july',\n",
        "               'bill_amt_8_august', 'bill_amt_9_september']\n",
        "categorical_features = ['sex', 'marriage']\n",
        "ordinal_features = ['education', 'pay_delay_4_april', 'pay_delay_5_may',\n",
        "                    'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "delay_columns = ['pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "bill_columns = ['bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june', 'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september']\n"
      ],
      "metadata": {
        "id": "wgQKR1CHSCRs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Feature Engineering Pipeline Update"
      ],
      "metadata": {
        "id": "-H8SbkLKSn5A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the target\n",
        "target = 'default_payment_next_month'\n",
        "\n",
        "# Split the data into features and target\n",
        "X = df.drop(columns=[target])\n",
        "y = df[target]\n",
        "\n",
        "# Perform the train-test split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
        "\n",
        "# Define the columns\n",
        "numeric_features = ['age', 'limit_bal']\n",
        "pay_columns = ['pay_amt_4_april', 'pay_amt_5_may',\n",
        "               'pay_amt_6_june', 'pay_amt_7_july',\n",
        "               'pay_amt_8_august', 'pay_amt_9_september',\n",
        "               'bill_amt_4_april', 'bill_amt_5_may',\n",
        "               'bill_amt_6_june', 'bill_amt_7_july',\n",
        "               'bill_amt_8_august', 'bill_amt_9_september']\n",
        "categorical_features = ['sex', 'marriage']\n",
        "ordinal_features = ['education', 'pay_delay_4_april', 'pay_delay_5_may',\n",
        "                    'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "delay_columns = ['pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "bill_columns = ['bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june', 'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september']\n",
        "\n",
        "# Step 1: Simplified pipeline with outlier removal and feature engineering\n",
        "pipeline_outlier_feature_engineering = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal step\n",
        "    ('feature_engineering', CombinedFeatureEngineeringTransformer(delay_columns, pay_columns, bill_columns))  # Combined feature engineering step\n",
        "])\n",
        "\n",
        "# Step 2: Fit the pipeline on X_train and transform X_train\n",
        "pipeline_outlier_feature_engineering.fit(X_train, y_train)\n",
        "X_train_after_feature_engineering = pipeline_outlier_feature_engineering.transform(X_train)\n",
        "\n",
        "# Step 3: Transform X_test using the same fitted pipeline\n",
        "X_test_after_feature_engineering = pipeline_outlier_feature_engineering.transform(X_test)\n",
        "\n",
        "# Step 4: Convert the transformed data into DataFrames for inspection\n",
        "X_train_feature_engineering_df = pd.DataFrame(X_train_after_feature_engineering)\n",
        "X_test_feature_engineering_df = pd.DataFrame(X_test_after_feature_engineering)\n",
        "\n",
        "# Step 5: Inspect the data types after feature engineering\n",
        "print(\"Data types after feature engineering (train):\")\n",
        "print(X_train_feature_engineering_df.dtypes)\n",
        "\n",
        "print(\"Data types after feature engineering (test):\")\n",
        "print(X_test_feature_engineering_df.dtypes)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YJwrwkfmSnUC",
        "outputId": "438a9ead-91ce-4053-c5a5-b621bf9caf1f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data types after feature engineering (train):\n",
            "limit_bal                                         int64\n",
            "sex                                            category\n",
            "education                                      category\n",
            "marriage                                       category\n",
            "age                                               int64\n",
            "bill_amt_4_april                                float64\n",
            "bill_amt_5_may                                  float64\n",
            "bill_amt_6_june                                 float64\n",
            "bill_amt_7_july                                 float64\n",
            "bill_amt_8_august                               float64\n",
            "bill_amt_9_september                            float64\n",
            "pay_amt_4_april                                 float64\n",
            "pay_amt_5_may                                   float64\n",
            "pay_amt_6_june                                  float64\n",
            "pay_amt_7_july                                  float64\n",
            "pay_amt_8_august                                float64\n",
            "pay_amt_9_september                             float64\n",
            "pay_delay_4_april                              category\n",
            "pay_delay_5_may                                category\n",
            "pay_delay_6_june                               category\n",
            "pay_delay_7_july                               category\n",
            "pay_delay_8_august                             category\n",
            "pay_delay_9_september                          category\n",
            "high_risk_delay                                    bool\n",
            "severe_delay_count                                int64\n",
            "cumulative_delay                                  int64\n",
            "severe_delay_payment_ratio                      float64\n",
            "avg_payment_severe_delays                       float64\n",
            "deferred_and_decreasing_payments                   bool\n",
            "severe_deferred_and_decreasing_payments            bool\n",
            "severe_deferred_and_any_decreasing_payments        bool\n",
            "total_payments                                  float64\n",
            "avg_payment                                     float64\n",
            "payment_std                                     float64\n",
            "weighted_payment_sum                            float64\n",
            "total_bills                                     float64\n",
            "debt_to_limit_ratio                             float64\n",
            "education_marriage                               object\n",
            "dtype: object\n",
            "Data types after feature engineering (test):\n",
            "limit_bal                                         int64\n",
            "sex                                            category\n",
            "education                                      category\n",
            "marriage                                       category\n",
            "age                                               int64\n",
            "bill_amt_4_april                                float64\n",
            "bill_amt_5_may                                  float64\n",
            "bill_amt_6_june                                 float64\n",
            "bill_amt_7_july                                 float64\n",
            "bill_amt_8_august                               float64\n",
            "bill_amt_9_september                            float64\n",
            "pay_amt_4_april                                 float64\n",
            "pay_amt_5_may                                   float64\n",
            "pay_amt_6_june                                  float64\n",
            "pay_amt_7_july                                  float64\n",
            "pay_amt_8_august                                float64\n",
            "pay_amt_9_september                             float64\n",
            "pay_delay_4_april                              category\n",
            "pay_delay_5_may                                category\n",
            "pay_delay_6_june                               category\n",
            "pay_delay_7_july                               category\n",
            "pay_delay_8_august                             category\n",
            "pay_delay_9_september                          category\n",
            "high_risk_delay                                    bool\n",
            "severe_delay_count                                int64\n",
            "cumulative_delay                                  int64\n",
            "severe_delay_payment_ratio                      float64\n",
            "avg_payment_severe_delays                       float64\n",
            "deferred_and_decreasing_payments                   bool\n",
            "severe_deferred_and_decreasing_payments            bool\n",
            "severe_deferred_and_any_decreasing_payments        bool\n",
            "total_payments                                  float64\n",
            "avg_payment                                     float64\n",
            "payment_std                                     float64\n",
            "weighted_payment_sum                            float64\n",
            "total_bills                                     float64\n",
            "debt_to_limit_ratio                             float64\n",
            "education_marriage                               object\n",
            "dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 5: Convert 'education_marriage' to categorical in the engineered DataFrames\n",
        "def convert_to_categorical(df, column_list):\n",
        "    for col in column_list:\n",
        "        df[col] = df[col].astype('category')\n",
        "    return df\n",
        "\n",
        "# Convert 'education_marriage' in both training and test sets\n",
        "X_train_feature_engineering_df = convert_to_categorical(X_train_feature_engineering_df, ['education_marriage'])\n",
        "X_test_feature_engineering_df = convert_to_categorical(X_test_feature_engineering_df, ['education_marriage'])\n",
        "\n",
        "# Step 6: Inspect the data types after the conversion\n",
        "print(\"Data types after conversion (train):\")\n",
        "print(X_train_feature_engineering_df.dtypes)\n",
        "\n",
        "print(\"Data types after conversion (test):\")\n",
        "print(X_test_feature_engineering_df.dtypes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mi1wnaw3VBNU",
        "outputId": "08011e6d-e51f-486b-941f-65df94df9965"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data types after conversion (train):\n",
            "limit_bal                                         int64\n",
            "sex                                            category\n",
            "education                                      category\n",
            "marriage                                       category\n",
            "age                                               int64\n",
            "bill_amt_4_april                                float64\n",
            "bill_amt_5_may                                  float64\n",
            "bill_amt_6_june                                 float64\n",
            "bill_amt_7_july                                 float64\n",
            "bill_amt_8_august                               float64\n",
            "bill_amt_9_september                            float64\n",
            "pay_amt_4_april                                 float64\n",
            "pay_amt_5_may                                   float64\n",
            "pay_amt_6_june                                  float64\n",
            "pay_amt_7_july                                  float64\n",
            "pay_amt_8_august                                float64\n",
            "pay_amt_9_september                             float64\n",
            "pay_delay_4_april                              category\n",
            "pay_delay_5_may                                category\n",
            "pay_delay_6_june                               category\n",
            "pay_delay_7_july                               category\n",
            "pay_delay_8_august                             category\n",
            "pay_delay_9_september                          category\n",
            "high_risk_delay                                    bool\n",
            "severe_delay_count                                int64\n",
            "cumulative_delay                                  int64\n",
            "severe_delay_payment_ratio                      float64\n",
            "avg_payment_severe_delays                       float64\n",
            "deferred_and_decreasing_payments                   bool\n",
            "severe_deferred_and_decreasing_payments            bool\n",
            "severe_deferred_and_any_decreasing_payments        bool\n",
            "total_payments                                  float64\n",
            "avg_payment                                     float64\n",
            "payment_std                                     float64\n",
            "weighted_payment_sum                            float64\n",
            "total_bills                                     float64\n",
            "debt_to_limit_ratio                             float64\n",
            "education_marriage                             category\n",
            "dtype: object\n",
            "Data types after conversion (test):\n",
            "limit_bal                                         int64\n",
            "sex                                            category\n",
            "education                                      category\n",
            "marriage                                       category\n",
            "age                                               int64\n",
            "bill_amt_4_april                                float64\n",
            "bill_amt_5_may                                  float64\n",
            "bill_amt_6_june                                 float64\n",
            "bill_amt_7_july                                 float64\n",
            "bill_amt_8_august                               float64\n",
            "bill_amt_9_september                            float64\n",
            "pay_amt_4_april                                 float64\n",
            "pay_amt_5_may                                   float64\n",
            "pay_amt_6_june                                  float64\n",
            "pay_amt_7_july                                  float64\n",
            "pay_amt_8_august                                float64\n",
            "pay_amt_9_september                             float64\n",
            "pay_delay_4_april                              category\n",
            "pay_delay_5_may                                category\n",
            "pay_delay_6_june                               category\n",
            "pay_delay_7_july                               category\n",
            "pay_delay_8_august                             category\n",
            "pay_delay_9_september                          category\n",
            "high_risk_delay                                    bool\n",
            "severe_delay_count                                int64\n",
            "cumulative_delay                                  int64\n",
            "severe_delay_payment_ratio                      float64\n",
            "avg_payment_severe_delays                       float64\n",
            "deferred_and_decreasing_payments                   bool\n",
            "severe_deferred_and_decreasing_payments            bool\n",
            "severe_deferred_and_any_decreasing_payments        bool\n",
            "total_payments                                  float64\n",
            "avg_payment                                     float64\n",
            "payment_std                                     float64\n",
            "weighted_payment_sum                            float64\n",
            "total_bills                                     float64\n",
            "debt_to_limit_ratio                             float64\n",
            "education_marriage                             category\n",
            "dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Preprocessing Pipeline\n",
        "\n",
        "Both **`FunctionTransformer`** and **`ColumnTransformer`** serve different purposes in a machine learning pipeline, but they are often used together to apply specific transformations to subsets of data. Let me explain the difference and when you would choose one over the other.\n",
        "\n",
        "### 1. **FunctionTransformer**:\n",
        "- **Purpose**: Applies a custom transformation function (e.g., a lambda function or a predefined function) to the entire dataset or selected features. It’s a wrapper around a function that allows you to use a simple transformation in the `Pipeline`.\n",
        "- **When to Use**: Use `FunctionTransformer` when you want to apply a specific function to modify your data, such as converting boolean values to integers (e.g., `True`/`False` to `1`/`0`), scaling data in a custom way, or applying any other simple function. This transformation is applied within a step of a `Pipeline`.\n",
        "\n",
        "#### Example of `FunctionTransformer`:\n",
        "```python\n",
        "# Custom transformer to convert boolean features to integers (0 or 1)\n",
        "bool_to_numeric_transformer = FunctionTransformer(lambda x: x.astype(int))\n",
        "```\n",
        "- **Advantages**:\n",
        "  - It allows you to define custom transformations easily.\n",
        "  - You can plug in any custom function into a scikit-learn pipeline.\n",
        "\n",
        "### 2. **ColumnTransformer**:\n",
        "- **Purpose**: Allows you to apply different transformations to specific columns of your dataset. It acts like a \"manager\" that applies different pipelines or transformers to different subsets of columns (e.g., numeric, categorical, boolean).\n",
        "- **When to Use**: Use `ColumnTransformer` when you have a mix of feature types (numeric, categorical, ordinal, boolean, etc.) and you need to apply different transformations to each group of columns. For example, you might want to apply scaling to numeric features, one-hot encoding to categorical features, and ordinal encoding to ordinal features, all within a single `ColumnTransformer`.\n",
        "  \n",
        "#### Example of `ColumnTransformer`:\n",
        "```python\n",
        "preprocessor = ColumnTransformer(\n",
        "    transformers=[\n",
        "        ('num', numeric_transformer, numeric_features),  # Apply scaling to numeric features\n",
        "        ('cat', categorical_transformer, categorical_features),  # One-hot encoding for categorical\n",
        "        ('ord', ordinal_transformer, ordinal_features),  # Ordinal encoding for ordered categories\n",
        "        ('bool', bool_to_numeric_transformer, boolean_features)  # Convert booleans to 0/1\n",
        "    ]\n",
        ")\n",
        "```\n",
        "- **Advantages**:\n",
        "  - Allows you to handle different types of features in a single preprocessing step.\n",
        "  - Keeps your code modular and easy to read when you need to apply many transformations.\n",
        "\n",
        "### **Choosing Between FunctionTransformer and ColumnTransformer**:\n",
        "- **Use `FunctionTransformer`** when you need a custom function to transform data and that transformation is independent of column types. For instance, converting `True/False` to `1/0` across multiple boolean columns.\n",
        "  \n",
        "- **Use `ColumnTransformer`** when you want to apply different transformations to different groups of columns in one step. It allows you to apply pipelines or transformers (including `FunctionTransformer`) to subsets of columns.\n",
        "\n",
        "### How They Work Together:\n",
        "- **FunctionTransformer in ColumnTransformer**: You often use `FunctionTransformer` **inside** a `ColumnTransformer` to apply custom transformations to specific columns. For example, if you have boolean columns that need to be transformed into integers, you can define this custom transformation using `FunctionTransformer` and then apply it to the appropriate columns via `ColumnTransformer`.\n",
        "\n",
        "In the code you provided, you use `ColumnTransformer` to handle different column groups (numeric, categorical, ordinal, boolean), and `FunctionTransformer` is embedded in the pipeline to convert boolean columns to integers.\n",
        "\n",
        "### Why Use Both:\n",
        "- `ColumnTransformer` is necessary when you have heterogeneous data (different column types).\n",
        "- `FunctionTransformer` is useful when applying a specific transformation (like converting booleans) that isn't covered by built-in transformers.\n"
      ],
      "metadata": {
        "id": "W85okndQVy73"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import the necessary libraries\n",
        "from sklearn.preprocessing import FunctionTransformer\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.preprocessing import StandardScaler, OneHotEncoder, OrdinalEncoder\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.pipeline import Pipeline\n",
        "import pandas as pd\n",
        "\n",
        "# Define the updated column categories after feature engineering\n",
        "numeric_features = ['age', 'limit_bal', 'bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june',\n",
        "                    'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september', 'pay_amt_4_april',\n",
        "                    'pay_amt_5_may', 'pay_amt_6_june', 'pay_amt_7_july', 'pay_amt_8_august',\n",
        "                    'pay_amt_9_september', 'severe_delay_count', 'cumulative_delay',\n",
        "                    'severe_delay_payment_ratio', 'avg_payment_severe_delays', 'total_payments',\n",
        "                    'avg_payment', 'payment_std', 'weighted_payment_sum', 'total_bills', 'debt_to_limit_ratio']\n",
        "\n",
        "categorical_features = ['sex', 'marriage', 'education_marriage']\n",
        "\n",
        "ordinal_features = ['education', 'pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june',\n",
        "                    'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "\n",
        "boolean_features = ['high_risk_delay', 'deferred_and_decreasing_payments', 'severe_deferred_and_decreasing_payments',\n",
        "                    'severe_deferred_and_any_decreasing_payments']\n",
        "\n",
        "# Step 1: Preprocessing Pipeline\n",
        "numeric_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='mean')),\n",
        "    ('scaler', StandardScaler())\n",
        "])\n",
        "\n",
        "categorical_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('onehot', OneHotEncoder(handle_unknown='ignore'))\n",
        "])\n",
        "\n",
        "ordinal_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('ordinal', OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1))\n",
        "])\n",
        "\n",
        "# Step 2: Import FunctionTransformer and create a boolean transformer\n",
        "bool_to_numeric_transformer = Pipeline(steps=[\n",
        "    ('convert_bool', FunctionTransformer(lambda x: x.astype(int))),\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent'))  # Handle missing values in boolean features\n",
        "])\n",
        "\n",
        "# Step 3: ColumnTransformer for handling preprocessing\n",
        "preprocessor = ColumnTransformer(\n",
        "    transformers=[\n",
        "        ('num', numeric_transformer, numeric_features),\n",
        "        ('cat', categorical_transformer, categorical_features),\n",
        "        ('ord', ordinal_transformer, ordinal_features),\n",
        "        ('bool', bool_to_numeric_transformer, boolean_features)\n",
        "    ]\n",
        ")\n",
        "\n",
        "# Step 4: Create the full pipeline for preprocessing\n",
        "pipeline_preprocessing = Pipeline(steps=[\n",
        "    ('preprocessor', preprocessor)\n",
        "])\n",
        "\n",
        "# Step 5: Fit the preprocessing pipeline on X_train_feature_engineering_df\n",
        "pipeline_preprocessing.fit(X_train_feature_engineering_df)\n",
        "\n",
        "# Step 6: Transform the training and test data\n",
        "X_train_preprocessed = pipeline_preprocessing.transform(X_train_feature_engineering_df)\n",
        "X_test_preprocessed = pipeline_preprocessing.transform(X_test_feature_engineering_df)\n",
        "\n",
        "# Step 7: Convert the transformed data into DataFrames for easier inspection\n",
        "X_train_preprocessed_df = pd.DataFrame(X_train_preprocessed)\n",
        "X_test_preprocessed_df = pd.DataFrame(X_test_preprocessed)\n",
        "\n",
        "# Step 8: Inspect the preprocessed data types\n",
        "print(\"Data types after preprocessing (train):\")\n",
        "print(X_train_preprocessed_df.dtypes)\n",
        "\n",
        "print(\"Data types after preprocessing (test):\")\n",
        "print(X_test_preprocessed_df.dtypes)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pDP3tuy8VyaS",
        "outputId": "e8f586cd-c78a-4fcf-8be3-8be32224f9fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data types after preprocessing (train):\n",
            "0     float64\n",
            "1     float64\n",
            "2     float64\n",
            "3     float64\n",
            "4     float64\n",
            "5     float64\n",
            "6     float64\n",
            "7     float64\n",
            "8     float64\n",
            "9     float64\n",
            "10    float64\n",
            "11    float64\n",
            "12    float64\n",
            "13    float64\n",
            "14    float64\n",
            "15    float64\n",
            "16    float64\n",
            "17    float64\n",
            "18    float64\n",
            "19    float64\n",
            "20    float64\n",
            "21    float64\n",
            "22    float64\n",
            "23    float64\n",
            "24    float64\n",
            "25    float64\n",
            "26    float64\n",
            "27    float64\n",
            "28    float64\n",
            "29    float64\n",
            "30    float64\n",
            "31    float64\n",
            "32    float64\n",
            "33    float64\n",
            "34    float64\n",
            "35    float64\n",
            "36    float64\n",
            "37    float64\n",
            "38    float64\n",
            "39    float64\n",
            "40    float64\n",
            "41    float64\n",
            "42    float64\n",
            "43    float64\n",
            "44    float64\n",
            "45    float64\n",
            "46    float64\n",
            "47    float64\n",
            "48    float64\n",
            "49    float64\n",
            "50    float64\n",
            "51    float64\n",
            "dtype: object\n",
            "Data types after preprocessing (test):\n",
            "0     float64\n",
            "1     float64\n",
            "2     float64\n",
            "3     float64\n",
            "4     float64\n",
            "5     float64\n",
            "6     float64\n",
            "7     float64\n",
            "8     float64\n",
            "9     float64\n",
            "10    float64\n",
            "11    float64\n",
            "12    float64\n",
            "13    float64\n",
            "14    float64\n",
            "15    float64\n",
            "16    float64\n",
            "17    float64\n",
            "18    float64\n",
            "19    float64\n",
            "20    float64\n",
            "21    float64\n",
            "22    float64\n",
            "23    float64\n",
            "24    float64\n",
            "25    float64\n",
            "26    float64\n",
            "27    float64\n",
            "28    float64\n",
            "29    float64\n",
            "30    float64\n",
            "31    float64\n",
            "32    float64\n",
            "33    float64\n",
            "34    float64\n",
            "35    float64\n",
            "36    float64\n",
            "37    float64\n",
            "38    float64\n",
            "39    float64\n",
            "40    float64\n",
            "41    float64\n",
            "42    float64\n",
            "43    float64\n",
            "44    float64\n",
            "45    float64\n",
            "46    float64\n",
            "47    float64\n",
            "48    float64\n",
            "49    float64\n",
            "50    float64\n",
            "51    float64\n",
            "dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Pipeline with Preprocess SMOTE Data Check"
      ],
      "metadata": {
        "id": "w2I-wp8OY84M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 1: Full pipeline setup with SMOTE and Logistic Regression\n",
        "final_pipeline = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    ('feature_engineering', CombinedFeatureEngineeringTransformer(delay_columns, pay_columns, bill_columns)),  # Feature engineering\n",
        "    ('preprocessor', preprocessor),  # Preprocessing\n",
        "    ('smote', SMOTE(random_state=42)),  # SMOTE for resampling\n",
        "    ('classifier', LogisticRegression(max_iter=1000))  # Logistic Regression classifier\n",
        "])\n",
        "\n",
        "# Step 2: Fit the pipeline up to SMOTE\n",
        "pipeline_up_to_smote = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),\n",
        "    ('feature_engineering', CombinedFeatureEngineeringTransformer(delay_columns, pay_columns, bill_columns)),\n",
        "    ('preprocessor', preprocessor),\n",
        "    ('smote', SMOTE(random_state=42))\n",
        "])\n",
        "\n",
        "# Fit the pipeline up to the SMOTE step and resample the data\n",
        "X_train_after_smote, y_train_after_smote = pipeline_up_to_smote.fit_resample(X_train_feature_engineering_df, y_train)\n",
        "\n",
        "# Step 3: Convert the transformed data to a DataFrame to inspect data types\n",
        "X_train_after_smote_df = pd.DataFrame(X_train_after_smote)\n",
        "\n",
        "# Step 4: Print data types after SMOTE\n",
        "print(\"Data types after SMOTE:\")\n",
        "print(X_train_after_smote_df.dtypes)\n",
        "\n",
        "# Continue with classifier training if everything looks good\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aYCM-evCZcfo",
        "outputId": "4dac4378-4f74-421c-8cda-39daa7ae93dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data types after SMOTE:\n",
            "0     float64\n",
            "1     float64\n",
            "2     float64\n",
            "3     float64\n",
            "4     float64\n",
            "5     float64\n",
            "6     float64\n",
            "7     float64\n",
            "8     float64\n",
            "9     float64\n",
            "10    float64\n",
            "11    float64\n",
            "12    float64\n",
            "13    float64\n",
            "14    float64\n",
            "15    float64\n",
            "16    float64\n",
            "17    float64\n",
            "18    float64\n",
            "19    float64\n",
            "20    float64\n",
            "21    float64\n",
            "22    float64\n",
            "23    float64\n",
            "24    float64\n",
            "25    float64\n",
            "26    float64\n",
            "27    float64\n",
            "28    float64\n",
            "29    float64\n",
            "30    float64\n",
            "31    float64\n",
            "32    float64\n",
            "33    float64\n",
            "34    float64\n",
            "35    float64\n",
            "36    float64\n",
            "37    float64\n",
            "38    float64\n",
            "39    float64\n",
            "40    float64\n",
            "41    float64\n",
            "42    float64\n",
            "43    float64\n",
            "44    float64\n",
            "45    float64\n",
            "46    float64\n",
            "47    float64\n",
            "48    float64\n",
            "49    float64\n",
            "50    float64\n",
            "51    float64\n",
            "dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Pipeline with Preprocess SMOTE Model Training"
      ],
      "metadata": {
        "id": "tNT_kBREZiHv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 1: Full pipeline setup with SMOTE and Logistic Regression\n",
        "final_pipeline = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    ('feature_engineering', CombinedFeatureEngineeringTransformer(delay_columns, pay_columns, bill_columns)),  # Feature engineering\n",
        "    ('preprocessor', preprocessor),  # Preprocessing\n",
        "    ('smote', SMOTE(random_state=42)),  # SMOTE for resampling\n",
        "    ('classifier', LogisticRegression(max_iter=1000))  # Logistic Regression classifier\n",
        "])\n",
        "\n",
        "# Step 2: Train the final pipeline on X_train_feature_engineering_df\n",
        "final_pipeline.fit(X_train_feature_engineering_df, y_train)\n",
        "\n",
        "# Step 3: Predict on the test data\n",
        "y_pred = final_pipeline.predict(X_test_feature_engineering_df)\n",
        "\n",
        "# Step 4: Evaluate the classifier\n",
        "from sklearn.metrics import classification_report\n",
        "print(classification_report(y_test, y_pred))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T6m_wQ9BZC1b",
        "outputId": "fa0088e9-b6e6-4051-cc77-2d250fa0eab3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.48      0.60      0.53      1326\n",
            "           1       0.88      0.82      0.85      4667\n",
            "\n",
            "    accuracy                           0.77      5993\n",
            "   macro avg       0.68      0.71      0.69      5993\n",
            "weighted avg       0.79      0.77      0.78      5993\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Pipeline Clean Up"
      ],
      "metadata": {
        "id": "zwCX28fQagJE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Import the necessary libraries\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler, OneHotEncoder, OrdinalEncoder\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.preprocessing import FunctionTransformer\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.metrics import classification_report\n",
        "from imblearn.pipeline import Pipeline as IMBPipeline\n",
        "from imblearn.over_sampling import SMOTE\n",
        "from feature_engineering_pipeline_utils import (HighRiskDelayFeatureTransformer, SevereDelayCountTransformer, CumulativeDelayTransformer,\n",
        "                                                SevereDelayPaymentRatioTransformer, AvgPaymentSevereDelaysTransformer, DeferredAndDecreasingPaymentsTransformer,\n",
        "                                                SevereDeferredAndDecreasingPaymentsTransformer, SevereDeferredAndAnyDecreasingPaymentsTransformer,\n",
        "                                                TotalPaymentsTransformer, AvgPaymentTransformer, PaymentStdTransformer, WeightedPaymentSumTransformer,\n",
        "                                                TotalBillsTransformer, DebtToLimitRatioTransformer, EducationMarriageInteractionTransformer, WinsorRobustOutlierRemovalTransformer,\n",
        "                                                CombinedFeatureEngineeringTransformer)\n",
        "\n",
        "# Define the target\n",
        "target = 'default_payment_next_month'\n",
        "\n",
        "# Split the data into features and target\n",
        "X = df.drop(columns=[target])\n",
        "y = df[target]\n",
        "\n",
        "# Perform the train-test split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
        "\n",
        "# Define the columns\n",
        "numeric_features = ['age', 'limit_bal']\n",
        "pay_columns = ['pay_amt_4_april', 'pay_amt_5_may',\n",
        "               'pay_amt_6_june', 'pay_amt_7_july',\n",
        "               'pay_amt_8_august', 'pay_amt_9_september',\n",
        "               'bill_amt_4_april', 'bill_amt_5_may',\n",
        "               'bill_amt_6_june', 'bill_amt_7_july',\n",
        "               'bill_amt_8_august', 'bill_amt_9_september']\n",
        "categorical_features = ['sex', 'marriage']\n",
        "ordinal_features = ['education', 'pay_delay_4_april', 'pay_delay_5_may',\n",
        "                    'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "delay_columns = ['pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "bill_columns = ['bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june', 'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september']\n",
        "\n",
        "# Step 1: Simplified pipeline with outlier removal and feature engineering\n",
        "pipeline_outlier_feature_engineering = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal step\n",
        "    ('feature_engineering', CombinedFeatureEngineeringTransformer(delay_columns, pay_columns, bill_columns))  # Combined feature engineering step\n",
        "])\n",
        "\n",
        "# Step 2: Fit the pipeline on X_train and transform X_train\n",
        "pipeline_outlier_feature_engineering.fit(X_train, y_train)\n",
        "X_train_after_feature_engineering = pipeline_outlier_feature_engineering.transform(X_train)\n",
        "\n",
        "# Step 3: Transform X_test using the same fitted pipeline\n",
        "X_test_after_feature_engineering = pipeline_outlier_feature_engineering.transform(X_test)\n",
        "\n",
        "# Step 4: Convert the transformed data into DataFrames for inspection\n",
        "X_train_feature_engineering_df = pd.DataFrame(X_train_after_feature_engineering)\n",
        "X_test_feature_engineering_df = pd.DataFrame(X_test_after_feature_engineering)\n",
        "\n",
        "# Step 5: Inspect the data types after feature engineering\n",
        "print(\"Data types after feature engineering (train):\")\n",
        "print(X_train_feature_engineering_df.dtypes)\n",
        "\n",
        "print(\"Data types after feature engineering (test):\")\n",
        "print(X_test_feature_engineering_df.dtypes)\n",
        "\n",
        "\n",
        "# Define the updated column categories after feature engineering\n",
        "numeric_features_2 = ['age', 'limit_bal', 'bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june',\n",
        "                    'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september', 'pay_amt_4_april',\n",
        "                    'pay_amt_5_may', 'pay_amt_6_june', 'pay_amt_7_july', 'pay_amt_8_august',\n",
        "                    'pay_amt_9_september', 'severe_delay_count', 'cumulative_delay',\n",
        "                    'severe_delay_payment_ratio', 'avg_payment_severe_delays', 'total_payments',\n",
        "                    'avg_payment', 'payment_std', 'weighted_payment_sum', 'total_bills', 'debt_to_limit_ratio']\n",
        "\n",
        "categorical_features_2 = ['sex', 'marriage', 'education_marriage']\n",
        "boolean_features = ['high_risk_delay', 'deferred_and_decreasing_payments', 'severe_deferred_and_decreasing_payments',\n",
        "                    'severe_deferred_and_any_decreasing_payments']\n",
        "\n",
        "# Step 1: Preprocessing Pipeline\n",
        "numeric_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='mean')),\n",
        "    ('scaler', StandardScaler())\n",
        "])\n",
        "\n",
        "categorical_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('onehot', OneHotEncoder(handle_unknown='ignore'))\n",
        "])\n",
        "\n",
        "ordinal_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('ordinal', OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1))\n",
        "])\n",
        "\n",
        "# Step 2: Import FunctionTransformer and create a boolean transformer\n",
        "bool_to_numeric_transformer = Pipeline(steps=[\n",
        "    ('convert_bool', FunctionTransformer(lambda x: x.astype(int))),\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent'))  # Handle missing values in boolean features\n",
        "])\n",
        "\n",
        "# Step 3: ColumnTransformer for handling preprocessing\n",
        "preprocessor = ColumnTransformer(\n",
        "    transformers=[\n",
        "        ('num', numeric_transformer, numeric_features_2),\n",
        "        ('cat', categorical_transformer, categorical_features_2),\n",
        "        ('ord', ordinal_transformer, ordinal_features),\n",
        "        ('bool', bool_to_numeric_transformer, boolean_features)\n",
        "    ]\n",
        ")\n",
        "\n",
        "# Step 4: Create the full pipeline for preprocessing\n",
        "pipeline_preprocessing = Pipeline(steps=[\n",
        "    ('preprocessor', preprocessor)\n",
        "])\n",
        "\n",
        "# Step 5: Fit the preprocessing pipeline on X_train_feature_engineering_df\n",
        "pipeline_preprocessing.fit(X_train_feature_engineering_df)\n",
        "\n",
        "# Step 6: Transform the training and test data\n",
        "X_train_preprocessed = pipeline_preprocessing.transform(X_train_feature_engineering_df)\n",
        "X_test_preprocessed = pipeline_preprocessing.transform(X_test_feature_engineering_df)\n",
        "\n",
        "# Step 7: Convert the transformed data into DataFrames for easier inspection\n",
        "X_train_preprocessed_df = pd.DataFrame(X_train_preprocessed)\n",
        "X_test_preprocessed_df = pd.DataFrame(X_test_preprocessed)\n",
        "\n",
        "# Step 8: Inspect the preprocessed data types\n",
        "print(\"Data types after preprocessing (train):\")\n",
        "print(X_train_preprocessed_df.dtypes)\n",
        "\n",
        "print(\"Data types after preprocessing (test):\")\n",
        "print(X_test_preprocessed_df.dtypes)\n",
        "\n",
        "# Step 1: Full pipeline setup with SMOTE and Logistic Regression\n",
        "final_pipeline = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    ('feature_engineering', CombinedFeatureEngineeringTransformer(delay_columns, pay_columns, bill_columns)),  # Feature engineering\n",
        "    ('preprocessor', preprocessor),  # Preprocessing\n",
        "    ('smote', SMOTE(random_state=42)),  # SMOTE for resampling\n",
        "    ('classifier', LogisticRegression(max_iter=1000))  # Logistic Regression classifier\n",
        "])\n",
        "\n",
        "# Step 2: Train the final pipeline on X_train_feature_engineering_df\n",
        "final_pipeline.fit(X_train_feature_engineering_df, y_train)\n",
        "\n",
        "# Step 3: Predict on the test data\n",
        "y_pred = final_pipeline.predict(X_test_feature_engineering_df)\n",
        "\n",
        "# Step 4: Evaluate the classifier\n",
        "from sklearn.metrics import classification_report\n",
        "print(classification_report(y_test, y_pred))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QWqvWuClafov",
        "outputId": "e65dcbb9-06af-473d-ee9e-146b45b22f96"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data types after feature engineering (train):\n",
            "limit_bal                                         int64\n",
            "sex                                            category\n",
            "education                                      category\n",
            "marriage                                       category\n",
            "age                                               int64\n",
            "bill_amt_4_april                                float64\n",
            "bill_amt_5_may                                  float64\n",
            "bill_amt_6_june                                 float64\n",
            "bill_amt_7_july                                 float64\n",
            "bill_amt_8_august                               float64\n",
            "bill_amt_9_september                            float64\n",
            "pay_amt_4_april                                 float64\n",
            "pay_amt_5_may                                   float64\n",
            "pay_amt_6_june                                  float64\n",
            "pay_amt_7_july                                  float64\n",
            "pay_amt_8_august                                float64\n",
            "pay_amt_9_september                             float64\n",
            "pay_delay_4_april                              category\n",
            "pay_delay_5_may                                category\n",
            "pay_delay_6_june                               category\n",
            "pay_delay_7_july                               category\n",
            "pay_delay_8_august                             category\n",
            "pay_delay_9_september                          category\n",
            "high_risk_delay                                    bool\n",
            "severe_delay_count                                int64\n",
            "cumulative_delay                                  int64\n",
            "severe_delay_payment_ratio                      float64\n",
            "avg_payment_severe_delays                       float64\n",
            "deferred_and_decreasing_payments                   bool\n",
            "severe_deferred_and_decreasing_payments            bool\n",
            "severe_deferred_and_any_decreasing_payments        bool\n",
            "total_payments                                  float64\n",
            "avg_payment                                     float64\n",
            "payment_std                                     float64\n",
            "weighted_payment_sum                            float64\n",
            "total_bills                                     float64\n",
            "debt_to_limit_ratio                             float64\n",
            "education_marriage                               object\n",
            "dtype: object\n",
            "Data types after feature engineering (test):\n",
            "limit_bal                                         int64\n",
            "sex                                            category\n",
            "education                                      category\n",
            "marriage                                       category\n",
            "age                                               int64\n",
            "bill_amt_4_april                                float64\n",
            "bill_amt_5_may                                  float64\n",
            "bill_amt_6_june                                 float64\n",
            "bill_amt_7_july                                 float64\n",
            "bill_amt_8_august                               float64\n",
            "bill_amt_9_september                            float64\n",
            "pay_amt_4_april                                 float64\n",
            "pay_amt_5_may                                   float64\n",
            "pay_amt_6_june                                  float64\n",
            "pay_amt_7_july                                  float64\n",
            "pay_amt_8_august                                float64\n",
            "pay_amt_9_september                             float64\n",
            "pay_delay_4_april                              category\n",
            "pay_delay_5_may                                category\n",
            "pay_delay_6_june                               category\n",
            "pay_delay_7_july                               category\n",
            "pay_delay_8_august                             category\n",
            "pay_delay_9_september                          category\n",
            "high_risk_delay                                    bool\n",
            "severe_delay_count                                int64\n",
            "cumulative_delay                                  int64\n",
            "severe_delay_payment_ratio                      float64\n",
            "avg_payment_severe_delays                       float64\n",
            "deferred_and_decreasing_payments                   bool\n",
            "severe_deferred_and_decreasing_payments            bool\n",
            "severe_deferred_and_any_decreasing_payments        bool\n",
            "total_payments                                  float64\n",
            "avg_payment                                     float64\n",
            "payment_std                                     float64\n",
            "weighted_payment_sum                            float64\n",
            "total_bills                                     float64\n",
            "debt_to_limit_ratio                             float64\n",
            "education_marriage                               object\n",
            "dtype: object\n",
            "Data types after preprocessing (train):\n",
            "0     float64\n",
            "1     float64\n",
            "2     float64\n",
            "3     float64\n",
            "4     float64\n",
            "5     float64\n",
            "6     float64\n",
            "7     float64\n",
            "8     float64\n",
            "9     float64\n",
            "10    float64\n",
            "11    float64\n",
            "12    float64\n",
            "13    float64\n",
            "14    float64\n",
            "15    float64\n",
            "16    float64\n",
            "17    float64\n",
            "18    float64\n",
            "19    float64\n",
            "20    float64\n",
            "21    float64\n",
            "22    float64\n",
            "23    float64\n",
            "24    float64\n",
            "25    float64\n",
            "26    float64\n",
            "27    float64\n",
            "28    float64\n",
            "29    float64\n",
            "30    float64\n",
            "31    float64\n",
            "32    float64\n",
            "33    float64\n",
            "34    float64\n",
            "35    float64\n",
            "36    float64\n",
            "37    float64\n",
            "38    float64\n",
            "39    float64\n",
            "40    float64\n",
            "41    float64\n",
            "42    float64\n",
            "43    float64\n",
            "44    float64\n",
            "45    float64\n",
            "46    float64\n",
            "47    float64\n",
            "48    float64\n",
            "49    float64\n",
            "50    float64\n",
            "51    float64\n",
            "dtype: object\n",
            "Data types after preprocessing (test):\n",
            "0     float64\n",
            "1     float64\n",
            "2     float64\n",
            "3     float64\n",
            "4     float64\n",
            "5     float64\n",
            "6     float64\n",
            "7     float64\n",
            "8     float64\n",
            "9     float64\n",
            "10    float64\n",
            "11    float64\n",
            "12    float64\n",
            "13    float64\n",
            "14    float64\n",
            "15    float64\n",
            "16    float64\n",
            "17    float64\n",
            "18    float64\n",
            "19    float64\n",
            "20    float64\n",
            "21    float64\n",
            "22    float64\n",
            "23    float64\n",
            "24    float64\n",
            "25    float64\n",
            "26    float64\n",
            "27    float64\n",
            "28    float64\n",
            "29    float64\n",
            "30    float64\n",
            "31    float64\n",
            "32    float64\n",
            "33    float64\n",
            "34    float64\n",
            "35    float64\n",
            "36    float64\n",
            "37    float64\n",
            "38    float64\n",
            "39    float64\n",
            "40    float64\n",
            "41    float64\n",
            "42    float64\n",
            "43    float64\n",
            "44    float64\n",
            "45    float64\n",
            "46    float64\n",
            "47    float64\n",
            "48    float64\n",
            "49    float64\n",
            "50    float64\n",
            "51    float64\n",
            "dtype: object\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.48      0.60      0.53      1326\n",
            "           1       0.88      0.82      0.85      4667\n",
            "\n",
            "    accuracy                           0.77      5993\n",
            "   macro avg       0.68      0.71      0.69      5993\n",
            "weighted avg       0.79      0.77      0.78      5993\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Feature Lists\n",
        "\n",
        "Accounting for every feature explicitly in the pipeline is indeed a **more secure, maintainable, and transparent** solution in the long term compared to relying on `passthrough`. Here’s why:\n",
        "\n",
        "### 1. **Explicit Control**:\n",
        "   - When you define how each feature is processed in the pipeline (whether it's numeric, categorical, ordinal, or boolean), you maintain **full control** over the transformations applied to the data.\n",
        "   - This helps avoid accidental mishandling of columns or unintentional data leaks where unprocessed columns might slip through unchanged.\n",
        "\n",
        "### 2. **Consistency**:\n",
        "   - Ensuring all columns are explicitly handled leads to a **consistent transformation** of the data across both training and testing stages. Any unhandled columns might behave unexpectedly when passed through a model or evaluation step.\n",
        "   - By explicitly specifying all features, you reduce the risk of errors creeping in if the structure of your data changes (e.g., new columns added or columns renamed).\n",
        "\n",
        "### 3. **Robustness**:\n",
        "   - In the long term, explicitly processing all columns makes your pipeline more **robust to changes** in the data. If you add a new feature to your dataset, you'll be forced to decide how to handle it, rather than letting it pass through unaltered.\n",
        "   - This ensures that your pipeline doesn't silently ignore important features or skip required transformations.\n",
        "\n",
        "### 4. **Debugging and Maintenance**:\n",
        "   - If something goes wrong, it’s easier to debug when each column is handled explicitly. You can trace which transformation was applied to each feature, and there's no ambiguity about how columns are treated.\n",
        "\n",
        "### When Would `passthrough` Be Useful?\n",
        "`passthrough` can be a temporary or quick solution if:\n",
        "- You have some features that don’t need any transformation and you want them to be passed through unchanged (e.g., an ID column or pre-scaled/encoded data).\n",
        "- You’re experimenting with feature transformations and want to quickly build a pipeline without specifying how each column is handled.\n",
        "\n",
        "However, as you've correctly pointed out, **explicit handling of each column** is usually more reliable in the long term.\n",
        "\n",
        "### Conclusion:\n",
        "It’s best practice to account for every feature in your pipeline, ensuring that you control how each column is processed. This approach is **more safe, secure, and maintainable** over time.\n",
        "\n"
      ],
      "metadata": {
        "id": "0bTBLJVLhOL_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import the necessary libraries\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler, OneHotEncoder, OrdinalEncoder, FunctionTransformer\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.metrics import classification_report\n",
        "from imblearn.pipeline import Pipeline as IMBPipeline\n",
        "from imblearn.over_sampling import SMOTE\n",
        "from feature_engineering_pipeline_utils import (HighRiskDelayFeatureTransformer, SevereDelayCountTransformer,\n",
        "                                                CumulativeDelayTransformer, SevereDelayPaymentRatioTransformer,\n",
        "                                                AvgPaymentSevereDelaysTransformer, DeferredAndDecreasingPaymentsTransformer,\n",
        "                                                SevereDeferredAndDecreasingPaymentsTransformer, SevereDeferredAndAnyDecreasingPaymentsTransformer,\n",
        "                                                TotalPaymentsTransformer, AvgPaymentTransformer, PaymentStdTransformer, WeightedPaymentSumTransformer,\n",
        "                                                TotalBillsTransformer, DebtToLimitRatioTransformer, EducationMarriageInteractionTransformer,\n",
        "                                                WinsorRobustOutlierRemovalTransformer, CombinedFeatureEngineeringTransformer)\n",
        "\n",
        "# Define the target\n",
        "target = 'default_payment_next_month'\n",
        "\n",
        "# Split the data into features and target\n",
        "X = df.drop(columns=[target])\n",
        "y = df[target]\n",
        "\n",
        "# Perform the train-test split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
        "\n",
        "# Define the columns (numeric, categorical, ordinal, boolean)\n",
        "numeric_features = ['age', 'limit_bal', 'bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june',\n",
        "                    'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september', 'pay_amt_4_april',\n",
        "                    'pay_amt_5_may', 'pay_amt_6_june', 'pay_amt_7_july', 'pay_amt_8_august', 'pay_amt_9_september',\n",
        "                    'severe_delay_count', 'cumulative_delay', 'severe_delay_payment_ratio', 'avg_payment_severe_delays',\n",
        "                    'total_payments', 'avg_payment', 'payment_std', 'weighted_payment_sum', 'total_bills', 'debt_to_limit_ratio']\n",
        "pay_columns = ['pay_amt_4_april', 'pay_amt_5_may','pay_amt_6_june', 'pay_amt_7_july','pay_amt_8_august', 'pay_amt_9_september',\n",
        "               'bill_amt_4_april', 'bill_amt_5_may','bill_amt_6_june', 'bill_amt_7_july','bill_amt_8_august', 'bill_amt_9_september']\n",
        "delay_columns = ['pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "bill_columns = ['bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june', 'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september']\n",
        "categorical_features = ['sex', 'marriage', 'education_marriage']\n",
        "ordinal_features = ['education', 'pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september']\n",
        "boolean_features = ['high_risk_delay', 'deferred_and_decreasing_payments', 'severe_deferred_and_decreasing_payments', 'severe_deferred_and_any_decreasing_payments']\n",
        "\n",
        "# Step 1: Feature Engineering and Preprocessing Pipeline\n",
        "numeric_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='mean')),\n",
        "    ('scaler', StandardScaler())\n",
        "])\n",
        "\n",
        "categorical_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('onehot', OneHotEncoder(handle_unknown='ignore'))\n",
        "])\n",
        "\n",
        "ordinal_transformer = Pipeline(steps=[\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "    ('ordinal', OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1))\n",
        "])\n",
        "\n",
        "bool_to_numeric_transformer = Pipeline(steps=[\n",
        "    ('convert_bool', FunctionTransformer(lambda x: x.astype(int))),\n",
        "    ('imputer', SimpleImputer(strategy='most_frequent'))\n",
        "])\n",
        "\n",
        "preprocessor = ColumnTransformer(\n",
        "    transformers=[\n",
        "        ('num', numeric_transformer, numeric_features),\n",
        "        ('cat', categorical_transformer, categorical_features),\n",
        "        ('ord', ordinal_transformer, ordinal_features),\n",
        "        ('bool', bool_to_numeric_transformer, boolean_features)\n",
        "    ]\n",
        ")\n",
        "\n",
        "# Step 2: Full Pipeline Setup with Feature Engineering, SMOTE, and Logistic Regression\n",
        "final_pipeline = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    ('feature_engineering', CombinedFeatureEngineeringTransformer(delay_columns, pay_columns, bill_columns)),  # Feature engineering\n",
        "    ('preprocessor', preprocessor),  # Preprocessing\n",
        "    ('smote', SMOTE(random_state=42)),  # SMOTE for resampling\n",
        "    ('classifier', LogisticRegression(max_iter=1000))  # Logistic Regression classifier\n",
        "])\n",
        "\n",
        "# Step 3: Train the final pipeline on X_train\n",
        "final_pipeline.fit(X_train, y_train)\n",
        "\n",
        "# Step 4: Predict on the test data\n",
        "y_pred = final_pipeline.predict(X_test)\n",
        "\n",
        "# Step 5: Evaluate the classifier\n",
        "print(classification_report(y_test, y_pred))\n",
        "\n",
        "# Step 6: Print data types after feature engineering\n",
        "pipeline_outlier_feature_engineering = final_pipeline.named_steps['feature_engineering']\n",
        "X_train_after_feature_engineering = pipeline_outlier_feature_engineering.transform(X_train)\n",
        "X_train_feature_engineering_df = pd.DataFrame(X_train_after_feature_engineering)\n",
        "print(\"Data types after feature engineering (train):\")\n",
        "print(X_train_feature_engineering_df.dtypes)\n",
        "\n",
        "# Step 7: Print data types after preprocessing\n",
        "pipeline_preprocessing = final_pipeline.named_steps['preprocessor']\n",
        "X_train_after_preprocessing = pipeline_preprocessing.transform(X_train_after_feature_engineering)\n",
        "X_train_preprocessed_df = pd.DataFrame(X_train_after_preprocessing)\n",
        "print(\"Data types after preprocessing (train):\")\n",
        "print(X_train_preprocessed_df.dtypes)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iKQA8N-tafkk",
        "outputId": "cb4efee5-573d-4ccf-fc23-5d128510b1ab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.48      0.60      0.53      1326\n",
            "           1       0.88      0.82      0.85      4667\n",
            "\n",
            "    accuracy                           0.77      5993\n",
            "   macro avg       0.68      0.71      0.69      5993\n",
            "weighted avg       0.79      0.77      0.78      5993\n",
            "\n",
            "Data types after feature engineering (train):\n",
            "limit_bal                                         int64\n",
            "sex                                            category\n",
            "education                                      category\n",
            "marriage                                       category\n",
            "age                                               int64\n",
            "bill_amt_4_april                                  int64\n",
            "bill_amt_5_may                                    int64\n",
            "bill_amt_6_june                                   int64\n",
            "bill_amt_7_july                                   int64\n",
            "bill_amt_8_august                                 int64\n",
            "bill_amt_9_september                              int64\n",
            "pay_amt_4_april                                   int64\n",
            "pay_amt_5_may                                     int64\n",
            "pay_amt_6_june                                    int64\n",
            "pay_amt_7_july                                    int64\n",
            "pay_amt_8_august                                  int64\n",
            "pay_amt_9_september                               int64\n",
            "pay_delay_4_april                              category\n",
            "pay_delay_5_may                                category\n",
            "pay_delay_6_june                               category\n",
            "pay_delay_7_july                               category\n",
            "pay_delay_8_august                             category\n",
            "pay_delay_9_september                          category\n",
            "high_risk_delay                                    bool\n",
            "severe_delay_count                                int64\n",
            "cumulative_delay                                  int64\n",
            "severe_delay_payment_ratio                      float64\n",
            "avg_payment_severe_delays                       float64\n",
            "deferred_and_decreasing_payments                   bool\n",
            "severe_deferred_and_decreasing_payments            bool\n",
            "severe_deferred_and_any_decreasing_payments        bool\n",
            "total_payments                                    int64\n",
            "avg_payment                                     float64\n",
            "payment_std                                     float64\n",
            "weighted_payment_sum                              int64\n",
            "total_bills                                       int64\n",
            "debt_to_limit_ratio                             float64\n",
            "education_marriage                               object\n",
            "dtype: object\n",
            "Data types after preprocessing (train):\n",
            "0     float64\n",
            "1     float64\n",
            "2     float64\n",
            "3     float64\n",
            "4     float64\n",
            "5     float64\n",
            "6     float64\n",
            "7     float64\n",
            "8     float64\n",
            "9     float64\n",
            "10    float64\n",
            "11    float64\n",
            "12    float64\n",
            "13    float64\n",
            "14    float64\n",
            "15    float64\n",
            "16    float64\n",
            "17    float64\n",
            "18    float64\n",
            "19    float64\n",
            "20    float64\n",
            "21    float64\n",
            "22    float64\n",
            "23    float64\n",
            "24    float64\n",
            "25    float64\n",
            "26    float64\n",
            "27    float64\n",
            "28    float64\n",
            "29    float64\n",
            "30    float64\n",
            "31    float64\n",
            "32    float64\n",
            "33    float64\n",
            "34    float64\n",
            "35    float64\n",
            "36    float64\n",
            "37    float64\n",
            "38    float64\n",
            "39    float64\n",
            "40    float64\n",
            "41    float64\n",
            "42    float64\n",
            "43    float64\n",
            "44    float64\n",
            "45    float64\n",
            "46    float64\n",
            "47    float64\n",
            "48    float64\n",
            "49    float64\n",
            "50    float64\n",
            "51    float64\n",
            "dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Loan Data Utils"
      ],
      "metadata": {
        "id": "3o1VV2ccDa1Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "script_content=r'''\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "import logging\n",
        "from sklearn.metrics import classification_report\n",
        "from sklearn.base import BaseEstimator, TransformerMixin\n",
        "import json\n",
        "\n",
        "# Configure logging\n",
        "logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')\n",
        "\n",
        "target = 'default_payment_next_month'\n",
        "# Define primary, bill, and pay columns\n",
        "primary_columns = ['limit_bal', 'sex', 'education', 'marriage', 'age']\n",
        "bill_columns = ['bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june', 'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september']\n",
        "pay_columns = ['pay_amt_4_april', 'pay_amt_5_may', 'pay_amt_6_june', 'pay_amt_7_july', 'pay_amt_8_august', 'pay_amt_9_september']\n",
        "ordinal_columns = ['education', 'pay_delay_9_september', 'pay_delay_8_august', 'pay_delay_7_july', 'pay_delay_6_june', 'pay_delay_5_may', 'pay_delay_4_april']\n",
        "\n",
        "def load_data_from_url(url):\n",
        "    try:\n",
        "        df = pd.read_excel(url, header=1)\n",
        "        logging.info(\"Data loaded successfully from URL.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error loading data from URL: {e}\")\n",
        "        return None\n",
        "    return df\n",
        "\n",
        "def split_features_target(df, target):\n",
        "    try:\n",
        "        X = df.drop(columns=[target])\n",
        "        y = df[target]\n",
        "        logging.info(\"Features and target split successfully.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error splitting features and target: {e}\")\n",
        "        return None, None\n",
        "    return X, y\n",
        "\n",
        "\n",
        "def clean_column_names(df):\n",
        "    try:\n",
        "        df.columns = [col.lower().replace(' ', '_') for col in df.columns]\n",
        "        logging.info(\"Column names cleaned successfully.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error cleaning column names: {e}\")\n",
        "    return df\n",
        "\n",
        "def remove_id_column(df):\n",
        "    if 'id' in df.columns:\n",
        "        df = df.drop(columns=['id'])\n",
        "        logging.info(\"ID column removed.\")\n",
        "    return df\n",
        "\n",
        "# ---------  Sex Column Processing  --------- #\n",
        "# ---- SEX: Gender (1 = male, 2 = female) ----#\n",
        "\n",
        "# results in cat.categories = ['Female', 'Male'][0,1]\n",
        "def process_sex_column(df):\n",
        "    try:\n",
        "        if 'sex' in df.columns:\n",
        "            df['sex'] = df['sex'].replace({1: 'Male', 2: 'Female'})\n",
        "            df['sex'] = df['sex'].astype('category')\n",
        "            logging.info(\"Sex column processed and converted to categorical successfully.\")\n",
        "        else:\n",
        "            logging.warning(\"Sex column not found in DataFrame.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error processing sex column: {e}\")\n",
        "    return df\n",
        "\n",
        "# results in cat.categories = ['Female', 'Male'][2,1] (alphabetically ordered)\n",
        "def process_sex_column_cat_codes_one_two(df):\n",
        "    try:\n",
        "        if 'sex' in df.columns:\n",
        "            # Convert numeric values to categorical, maintaining original codes\n",
        "            df['sex'] = df['sex'].astype('category')  # First, ensure the column is categorical\n",
        "\n",
        "            # Define the categories explicitly and map original values (1: Male, 2: Female)\n",
        "            df['sex'].cat.set_categories([1, 2], rename=True, inplace=True)  # Set categories as 1, 2\n",
        "            df['sex'] = df['sex'].replace({1: 'Male', 2: 'Female'})  # Replace numeric values with labels\n",
        "\n",
        "            logging.info(\"Sex column processed and converted to categorical successfully.\")\n",
        "        else:\n",
        "            logging.warning(\"Sex column not found in DataFrame.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error processing sex column: {e}\")\n",
        "    return df\n",
        "\n",
        "# ---------  Marriage Column Processing  --------- #\n",
        "\n",
        "# ---- MARRIAGE: Marital status (1 = married, 2 = single, 3 = other) ----#\n",
        "\n",
        "def process_marriage_column(df):\n",
        "    try:\n",
        "        if 'marriage' in df.columns:\n",
        "            df['marriage'] = df['marriage'].replace({0: 'Unknown/Others', 3: 'Unknown/Others'})\n",
        "            df['marriage'] = df['marriage'].replace({1: 'Married', 2: 'Single'})\n",
        "            df['marriage'] = pd.Categorical(df['marriage'], categories=['Married', 'Single', 'Unknown/Others'], ordered=False)\n",
        "            logging.info(\"Marriage column processed and converted to categorical successfully.\")\n",
        "        else:\n",
        "            logging.warning(\"Marriage column not found in DataFrame.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error processing marriage column: {e}\")\n",
        "    return df\n",
        "\n",
        "# ---------  Target Column Processing  --------- #\n",
        "\n",
        "def process_default_payment_column(df):\n",
        "    try:\n",
        "        if 'default_payment_next_month' in df.columns:\n",
        "            # Convert 0 and 1 to categorical values\n",
        "            df['default_payment_next_month'] = df['default_payment_next_month'].astype('category')\n",
        "            logging.info(\"Default payment column processed and converted to categorical successfully.\")\n",
        "        else:\n",
        "            logging.warning(\"Default payment column not found in DataFrame.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error processing default payment column: {e}\")\n",
        "    return df\n",
        "\n",
        "# convert category labels for EDA\n",
        "def process_default_payment_column(df):\n",
        "    try:\n",
        "        if 'default_payment_next_month' in df.columns:\n",
        "            # Label the categories\n",
        "            df['default_payment_next_month'] = df['default_payment_next_month'].replace({0: 'No Default', 1: 'Default'})\n",
        "            df['default_payment_next_month'] = df['default_payment_next_month'].astype('category')\n",
        "            logging.info(\"Default payment column labeled and converted to categorical successfully.\")\n",
        "        else:\n",
        "            logging.warning(\"Default payment column not found in DataFrame.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error processing default payment column: {e}\")\n",
        "    return df\n",
        "\n",
        "# Convert labels to numeric for modeling\n",
        "def convert_default_payment_to_numeric(df):\n",
        "    try:\n",
        "        if 'default_payment_next_month' in df.columns:\n",
        "            df['default_payment_next_month'] = df['default_payment_next_month'].replace({'No Default': 0, 'Default': 1}).astype(int)\n",
        "            logging.info(\"Default payment column converted back to numeric for modeling.\")\n",
        "        else:\n",
        "            logging.warning(\"Default payment column not found in DataFrame.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error converting default payment column to numeric: {e}\")\n",
        "    return df\n",
        "\n",
        "# ---------  Pay Delay Column Processing  --------- #\n",
        "\n",
        "def rename_pay_columns(df):\n",
        "    try:\n",
        "        # Only rename if the original columns exist\n",
        "        if all(col in df.columns for col in ['pay_0', 'pay_2', 'pay_3', 'pay_4', 'pay_5', 'pay_6']):\n",
        "            pay_columns_new_names = {\n",
        "                'pay_0': 'pay_delay_9_september',\n",
        "                'pay_2': 'pay_delay_8_august',\n",
        "                'pay_3': 'pay_delay_7_july',\n",
        "                'pay_4': 'pay_delay_6_june',\n",
        "                'pay_5': 'pay_delay_5_may',\n",
        "                'pay_6': 'pay_delay_4_april'\n",
        "            }\n",
        "            df = df.rename(columns=pay_columns_new_names)\n",
        "            logging.info(\"Pay delay columns renamed successfully.\")\n",
        "        else:\n",
        "            logging.warning(\"Some or all of the expected pay columns are missing. Renaming skipped.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error renaming pay delay columns: {e}\")\n",
        "    return df\n",
        "\n",
        "def rename_bill_and_payment_columns(df):\n",
        "    try:\n",
        "        # Correct renaming of bill_amt and pay_amt columns\n",
        "        bill_amt_new_names = {\n",
        "            'bill_amt1': 'bill_amt_9_september',\n",
        "            'bill_amt2': 'bill_amt_8_august',\n",
        "            'bill_amt3': 'bill_amt_7_july',\n",
        "            'bill_amt4': 'bill_amt_6_june',\n",
        "            'bill_amt5': 'bill_amt_5_may',\n",
        "            'bill_amt6': 'bill_amt_4_april'\n",
        "        }\n",
        "\n",
        "        pay_amt_new_names = {\n",
        "            'pay_amt1': 'pay_amt_9_september',\n",
        "            'pay_amt2': 'pay_amt_8_august',\n",
        "            'pay_amt3': 'pay_amt_7_july',\n",
        "            'pay_amt4': 'pay_amt_6_june',\n",
        "            'pay_amt5': 'pay_amt_5_may',\n",
        "            'pay_amt6': 'pay_amt_4_april'\n",
        "        }\n",
        "\n",
        "        df = df.rename(columns={**bill_amt_new_names, **pay_amt_new_names})\n",
        "        logging.info(\"Bill and payment columns renamed successfully.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error renaming bill and payment columns: {e}\")\n",
        "    return df\n",
        "\n",
        "\n",
        "def label_pay_columns(df, pay_columns):\n",
        "    try:\n",
        "        # Only label the pay_delay_* columns, not pay_amt_*\n",
        "        pay_labels = {\n",
        "            -2: \"No consumption\",\n",
        "            -1: \"Paid in full\",\n",
        "            0: \"Revolving credit\",\n",
        "            1: \"1 month delay\",\n",
        "            2: \"2 months delay\",\n",
        "            3: \"3 months delay\",\n",
        "            4: \"4 months delay\",\n",
        "            5: \"5 months delay\",\n",
        "            6: \"6 months delay\",\n",
        "            7: \"7 months delay\",\n",
        "            8: \"8 months delay\",\n",
        "            9: \"9+ months delay\"\n",
        "        }\n",
        "\n",
        "        for col in pay_columns:\n",
        "            # Ensure we're only mapping the delay columns and not payment amount columns\n",
        "            if 'pay_delay' in col and col in df.columns:\n",
        "                df[col] = df[col].map(pay_labels)\n",
        "                logging.info(f\"Column {col} labeled successfully.\")\n",
        "            else:\n",
        "                logging.error(f\"Column {col} not found in DataFrame.\")\n",
        "\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error labeling pay columns: {e}\")\n",
        "    return df\n",
        "\n",
        "def convert_pay_columns_to_ordinal(df, pay_columns):\n",
        "    try:\n",
        "        pay_order = [\n",
        "            \"No consumption\",  # -2\n",
        "            \"Paid in full\",    # -1\n",
        "            \"Revolving credit\", # 0\n",
        "            \"1 month delay\",   # 1\n",
        "            \"2 months delay\",  # 2\n",
        "            \"3 months delay\",  # 3\n",
        "            \"4 months delay\",  # 4\n",
        "            \"5 months delay\",  # 5\n",
        "            \"6 months delay\",  # 6\n",
        "            \"7 months delay\",  # 7\n",
        "            \"8 months delay\",  # 8\n",
        "            \"9+ months delay\"  # 9\n",
        "        ]\n",
        "\n",
        "        for col in pay_columns:\n",
        "            # Ensure only delay columns are converted to categorical\n",
        "            if 'pay_delay' in col and col in df.columns:\n",
        "                df[col] = pd.Categorical(df[col], categories=pay_order, ordered=True)\n",
        "                logging.info(f\"Column {col} converted to ordinal successfully.\")\n",
        "            else:\n",
        "                logging.error(f\"Column {col} not found in DataFrame.\")\n",
        "\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error converting pay columns to ordinal categories: {e}\")\n",
        "    return df\n",
        "\n",
        "\n",
        "def convert_ordinal_to_category(df, ordinal_columns):\n",
        "    try:\n",
        "        for col in ordinal_columns:\n",
        "            if col in df.columns:\n",
        "                df[col] = df[col].astype('category')\n",
        "                logging.info(f\"Column {col} converted to category successfully.\")\n",
        "            else:\n",
        "                logging.error(f\"Column {col} not found in DataFrame.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error converting ordinal columns to category: {e}\")\n",
        "    return df\n",
        "\n",
        "# ---------  Education Column Processing  --------- #\n",
        "\n",
        "def convert_education_to_ordinal(df):\n",
        "    try:\n",
        "        # Explicitly map all values to handle known categories\n",
        "        education_mapping = {\n",
        "            1: 'Graduate School',\n",
        "            2: 'University',\n",
        "            3: 'High School',\n",
        "            4: 'Other/Unknown',\n",
        "            5: 'Other/Unknown',\n",
        "            6: 'Other/Unknown',\n",
        "            0: 'Other/Unknown'  # Handle the 0 value as well\n",
        "        }\n",
        "\n",
        "        df['education'] = df['education'].replace(education_mapping)\n",
        "\n",
        "        # Define the order of education categories\n",
        "        education_order = [\n",
        "            \"Other/Unknown\",    # Grouped 0, 4, 5, 6 together\n",
        "            \"High School\",      # 3\n",
        "            \"University\",       # 2\n",
        "            \"Graduate School\"   # 1\n",
        "        ]\n",
        "\n",
        "        if 'education' in df.columns:\n",
        "            # Convert the education column to a categorical type with the specified order\n",
        "            df['education'] = pd.Categorical(df['education'], categories=education_order, ordered=True)\n",
        "            logging.info(\"Education column converted to ordinal categories successfully.\")\n",
        "        else:\n",
        "            logging.error(\"Education column not found in DataFrame.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error converting education column to ordinal categories: {e}\")\n",
        "    return df\n",
        "\n",
        "\n",
        "#-------- Utility and validation functions first ----------#\n",
        "\n",
        "def check_column_integrity(df, expected_columns):\n",
        "    missing_columns = [col for col in expected_columns if col not in df.columns]\n",
        "    if missing_columns:\n",
        "        logging.error(f\"Missing columns: {missing_columns}\")\n",
        "    else:\n",
        "        logging.info(\"All expected columns are present.\")\n",
        "\n",
        "def validate_data_types(df, ordinal_columns):\n",
        "    for col in ordinal_columns:\n",
        "        if col in df.columns:\n",
        "            if not pd.api.types.is_categorical_dtype(df[col]):\n",
        "                logging.warning(f\"Column {col} is not correctly set as categorical.\")\n",
        "            else:\n",
        "                logging.info(f\"Column {col} is correctly set as categorical with the following categories: {df[col].cat.categories}\")\n",
        "        else:\n",
        "            logging.error(f\"Column {col} not found in DataFrame.\")\n",
        "    logging.info(\"Data type validation complete.\")\n",
        "\n",
        "def reorder_columns(df):\n",
        "    try:\n",
        "        # Define the order of the pay_delay columns in chronological order\n",
        "        pay_delay_order = [\n",
        "            'pay_delay_4_april',\n",
        "            'pay_delay_5_may',\n",
        "            'pay_delay_6_june',\n",
        "            'pay_delay_7_july',\n",
        "            'pay_delay_8_august',\n",
        "            'pay_delay_9_september'\n",
        "        ]\n",
        "\n",
        "        # Combine primary, bill, pay, and pay_delay columns with other columns\n",
        "        other_columns = [col for col in df.columns if col not in primary_columns + bill_columns + pay_columns + pay_delay_order]\n",
        "        df = df[primary_columns + bill_columns + pay_columns + pay_delay_order + other_columns]\n",
        "        logging.info(\"Columns reordered successfully.\")\n",
        "    except Exception as e:\n",
        "        logging.error(f\"Error reordering columns: {e}\")\n",
        "    return df\n",
        "\n",
        "\n",
        "#--------  Load and Preprocess Data  --------- #\n",
        "\n",
        "def load_and_preprocess_data(url, categorical_columns, target):\n",
        "    df = load_data_from_url(url)\n",
        "    if df is not None:\n",
        "        try:\n",
        "            # Include the target column from the start\n",
        "            df = clean_column_names(df)\n",
        "            df = remove_id_column(df)\n",
        "            df = rename_pay_columns(df)\n",
        "            df = rename_bill_and_payment_columns(df)\n",
        "            df = label_pay_columns(df, [col for col in df.columns if 'pay_delay' in col])\n",
        "            df = convert_pay_columns_to_ordinal(df, [col for col in df.columns if 'pay_delay' in col])\n",
        "            df = reorder_columns(df)\n",
        "            df = convert_education_to_ordinal(df)\n",
        "            df = process_sex_column(df)\n",
        "            # df = process_sex_column_cat_codes_one_two(df)\n",
        "            df = process_marriage_column(df)\n",
        "            df = process_default_payment_column(df)\n",
        "            df = convert_ordinal_to_category(df, ordinal_columns)\n",
        "\n",
        "            # Run validation checks\n",
        "            check_column_integrity(df, primary_columns + bill_columns + pay_columns + ordinal_columns)\n",
        "            validate_data_types(df, ordinal_columns)\n",
        "\n",
        "            # Drop duplicates consistently across both features and target\n",
        "            df = df.drop_duplicates()\n",
        "\n",
        "            logging.info(\"Data loaded and preprocessed successfully.\")\n",
        "            return df\n",
        "        except Exception as e:\n",
        "            logging.error(f\"Error in data preprocessing: {e}\")\n",
        "            return None\n",
        "    return None\n",
        "\n",
        "#--------  Load Preprocess Split Data  --------- #\n",
        "\n",
        "def load_preprocess_split_data(url, categorical_columns, target):\n",
        "    df = load_data_from_url(url)\n",
        "    if df is not None:\n",
        "        try:\n",
        "            df = clean_column_names(df)\n",
        "            df = remove_id_column(df)\n",
        "            df = rename_pay_columns(df)\n",
        "            df = rename_bill_and_payment_columns(df)\n",
        "            df = label_pay_columns(df, [col for col in df.columns if 'pay_delay' in col])\n",
        "            df = convert_pay_columns_to_ordinal(df, [col for col in df.columns if 'pay_delay' in col])\n",
        "            df = reorder_columns(df)\n",
        "            df = convert_education_to_ordinal(df)\n",
        "            df = process_sex_column(df)  # Process the sex column separately\n",
        "            df = process_marriage_column(df)  # Process the marriage column separately\n",
        "            df = convert_ordinal_to_category(df, ordinal_columns)\n",
        "\n",
        "            # Run validation checks\n",
        "            check_column_integrity(df, primary_columns + bill_columns + pay_columns + ordinal_columns)\n",
        "            validate_data_types(df, ordinal_columns)\n",
        "\n",
        "            X, y = split_features_target(df, target)\n",
        "            logging.info(\"Data loaded and preprocessed successfully.\")\n",
        "            return X, y\n",
        "        except Exception as e:\n",
        "            logging.error(f\"Error in data preprocessing: {e}\")\n",
        "            return None, None\n",
        "    return None, None\n",
        "\n",
        "\n",
        "def check_categorical_order(df, columns):\n",
        "    for col in columns:\n",
        "        if pd.api.types.is_categorical_dtype(df[col]):\n",
        "            print(f\"Column: {col}\")\n",
        "            print(f\"Categories: {df[col].cat.categories}\")\n",
        "            print(f\"Ordered: {df[col].cat.ordered}\\n\")\n",
        "        else:\n",
        "            print(f\"Column: {col} is not categorical.\\n\")\n",
        "\n",
        "#--------  Plot Categorical Data Functions  --------- #\n",
        "\n",
        "categorical_columns = [\n",
        "    'default_payment_next_month', 'sex', 'education', 'marriage'\n",
        "]\n",
        "\n",
        "ordinal_columns = [\n",
        "    'pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june',\n",
        "    'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september'\n",
        "]\n",
        "\n",
        "def plot_categorical_distributions(df, categorical_columns):\n",
        "    \"\"\"Function to plot categorical distributions.\"\"\"\n",
        "    plt.figure(figsize=(16, 14))\n",
        "    sns.set_context('talk')\n",
        "    for i, column in enumerate(categorical_columns, 1):\n",
        "        plt.subplot(2, 2, i)\n",
        "        sns.countplot(data=df, x=column, hue=column, palette='Set3', legend=False)\n",
        "        plt.title(f'Distribution of {column}')\n",
        "        plt.xlabel(column)\n",
        "        plt.ylabel('Count')\n",
        "\n",
        "        # Add percentage annotations\n",
        "        total = len(df)\n",
        "        for p in plt.gca().patches:\n",
        "            percentage = 100 * p.get_height() / total\n",
        "            plt.gca().text(p.get_x() + p.get_width() / 2, p.get_height(),\n",
        "                           f'{percentage:.1f}%', ha='center', va='bottom')\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "def plot_ordinal_distributions(df, ordinal_columns):\n",
        "    \"\"\"Function to plot ordinal distributions using barplot with hue.\"\"\"\n",
        "    plt.figure(figsize=(16, 25))\n",
        "    sns.set_context('talk', font_scale=0.8)\n",
        "    for i, column in enumerate(ordinal_columns, 1):\n",
        "        plt.subplot(3, 2, i)\n",
        "\n",
        "        # Get the counts for each category\n",
        "        category_counts = df[column].value_counts().sort_index()\n",
        "\n",
        "        sns.barplot(x=category_counts.index, y=category_counts.values, hue=category_counts.index, palette='Set3')\n",
        "\n",
        "        plt.title(f'Distribution of {column}')\n",
        "        plt.xlabel(column)\n",
        "        plt.ylabel('Count')\n",
        "\n",
        "        # Rotate x-tick labels for better legibility\n",
        "        plt.xticks(rotation=45, ha='right')\n",
        "\n",
        "        # Add percentage annotations\n",
        "        total = len(df)\n",
        "        for p in plt.gca().patches:\n",
        "            percentage = 100 * p.get_height() / total\n",
        "            plt.gca().text(p.get_x() + p.get_width() / 2, p.get_height(),\n",
        "                           f'{percentage:.1f}%', ha='center', va='bottom')\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "# --------- Custom Transformer for Threshold Classifier --------- #\n",
        "\n",
        "class ThresholdClassifier(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, base_classifier, threshold=0.5):\n",
        "        self.base_classifier = base_classifier  # Any classifier, e.g., LogisticRegression\n",
        "        self.threshold = threshold\n",
        "\n",
        "    def fit(self, X, y):\n",
        "        self.base_classifier.fit(X, y)  # Fit the base classifier\n",
        "        return self\n",
        "\n",
        "    def predict(self, X):\n",
        "        # Get the predicted probabilities for the positive class\n",
        "        probas = self.base_classifier.predict_proba(X)[:, 1]  # Get probabilities for class 1\n",
        "\n",
        "        # Apply the custom threshold to make class predictions\n",
        "        return np.where(probas >= self.threshold, 1, 0)\n",
        "\n",
        "    def predict_proba(self, X):\n",
        "        return self.base_classifier.predict_proba(X)  # Keep predict_proba the same as the base classifier\n",
        "\n",
        "#--------  Classification Report Functions  --------- #\n",
        "\n",
        "# Function to save the classification reports to a JSON file\n",
        "def save_classification_reports(reports, filename='classification_reports.json'):\n",
        "    with open(filename, 'w') as json_file:\n",
        "        json.dump(reports, json_file, indent=4)  # Use indent for pretty-printing\n",
        "    print(f\"Classification reports saved as {filename}\")\n",
        "\n",
        "\n",
        "# Plotting function with annotations\n",
        "def plot_classification_report_metrics(report, model_name):\n",
        "    metrics_df = pd.DataFrame({\n",
        "        'Class': ['Class 0', 'Class 0', 'Class 0', 'Class 1', 'Class 1', 'Class 1'],\n",
        "        'Metric': ['Precision', 'Recall', 'F1-score', 'Precision', 'Recall', 'F1-score'],\n",
        "        'Value': [\n",
        "            report['0']['precision'],\n",
        "            report['0']['recall'],\n",
        "            report['0']['f1-score'],\n",
        "            report['1']['precision'],\n",
        "            report['1']['recall'],\n",
        "            report['1']['f1-score']\n",
        "        ]\n",
        "    })\n",
        "\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    ax = sns.barplot(x='Class', y='Value', hue='Metric', data=metrics_df, palette='mako')\n",
        "    plt.title(f'Classification Report Metrics for {model_name}')\n",
        "    plt.ylabel('Score')\n",
        "    plt.ylim(0, 1)\n",
        "    plt.legend(loc='lower right')\n",
        "\n",
        "    # Annotate the bars with the values\n",
        "    for p in ax.patches:\n",
        "        height = p.get_height()\n",
        "        ax.annotate(f'{height:.2f}',\n",
        "                    (p.get_x() + p.get_width() / 2., height),\n",
        "                    ha='center', va='center',\n",
        "                    xytext=(0, 5),\n",
        "                    textcoords='offset points')\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "#--------  Classification Report Functions for Categories  --------- #\n",
        "\n",
        "# Function to save classification reports with custom categories\n",
        "def save_classification_reports_with_categories(reports, filename='classification_reports.json'):\n",
        "    try:\n",
        "        # Adjust the keys for the class labels to match your custom categories\n",
        "        for model, report in reports.items():\n",
        "            if '0' in report and '1' in report:\n",
        "                report['No Default'] = report.pop('0')\n",
        "                report['Default'] = report.pop('1')\n",
        "\n",
        "        with open(filename, 'w') as json_file:\n",
        "            json.dump(reports, json_file, indent=4)  # Pretty-printing for clarity\n",
        "        print(f\"Classification reports with categories saved as {filename}\")\n",
        "    except Exception as e:\n",
        "        print(f\"Error saving classification reports: {e}\")\n",
        "\n",
        "# Updated plotting function with category names and annotations\n",
        "def plot_classification_report_metrics_with_categories(report, model_name):\n",
        "    metrics_df = pd.DataFrame({\n",
        "        'Class': ['No Default', 'No Default', 'No Default', 'Default', 'Default', 'Default'],\n",
        "        'Metric': ['Precision', 'Recall', 'F1-score', 'Precision', 'Recall', 'F1-score'],\n",
        "        'Value': [\n",
        "            report['No Default']['precision'],\n",
        "            report['No Default']['recall'],\n",
        "            report['No Default']['f1-score'],\n",
        "            report['Default']['precision'],\n",
        "            report['Default']['recall'],\n",
        "            report['Default']['f1-score']\n",
        "        ]\n",
        "    })\n",
        "\n",
        "    plt.figure(figsize=(10, 6))\n",
        "    ax = sns.barplot(x='Class', y='Value', hue='Metric', data=metrics_df, palette='mako')\n",
        "    plt.title(f'Classification Report Metrics for {model_name}')\n",
        "    plt.ylabel('Score')\n",
        "    plt.ylim(0, 1)\n",
        "    plt.legend(loc='lower right')\n",
        "\n",
        "    # Annotate the bars with the values\n",
        "    for p in ax.patches:\n",
        "        height = p.get_height()\n",
        "        ax.annotate(f'{height:.2f}',\n",
        "                    (p.get_x() + p.get_width() / 2., height),\n",
        "                    ha='center', va='center',\n",
        "                    xytext=(0, 5),\n",
        "                    textcoords='offset points')\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "'''\n",
        "\n",
        "# Write the script to a file\n",
        "with open(\"loan_data_utils.py\", \"w\") as file:\n",
        "    file.write(script_content)\n",
        "\n",
        "print(\"Script successfully written to loan_data_utils.py\")\n",
        "# Reload script to make functions available for use\n",
        "import importlib\n",
        "import loan_data_utils\n",
        "importlib.reload(loan_data_utils)\n",
        "\n",
        "from loan_data_utils import *\n"
      ],
      "metadata": {
        "id": "I0n51ttV4A8y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e1d4edee-90ae-4adc-962c-517aca56425f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Script successfully written to loan_data_utils.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### EDA Utils"
      ],
      "metadata": {
        "id": "ONYYdNCIMlxu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "script_content=r'''\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#--------   Data Overview   --------#\n",
        "\n",
        "def data_overview(X):\n",
        "    # Calculate missing values and their percentage\n",
        "    missing_values = X.isnull().sum().sum()\n",
        "    missing_percentage = (missing_values / len(X)) * 100\n",
        "\n",
        "    # Calculate the number of duplicate rows\n",
        "    duplicate_rows = X.duplicated().sum()\n",
        "\n",
        "    # Print missing values, missing percentage, and duplicate information\n",
        "    print(\"Missing Values:\", missing_values)\n",
        "    print(\"Missing Percentage:\", missing_percentage)\n",
        "    print(f\"Number of Duplicate Rows: {duplicate_rows}\\n\")\n",
        "\n",
        "    # Print basic information\n",
        "    X.info()\n",
        "\n",
        "#--------   Plot Class Distribution   --------#\n",
        "\n",
        "def plot_class_distribution(y_train, target_name):\n",
        "    sns.set()\n",
        "    sns.set(style=\"ticks\")\n",
        "    sns.set_context('notebook')\n",
        "    plt.figure(figsize=(8, 5))\n",
        "    sns.countplot(x=y_train, hue=y_train, palette='viridis')\n",
        "    plt.title(f'Class Distribution in Training Set: {target_name}')\n",
        "    plt.xlabel('Class')\n",
        "    plt.ylabel('Count')\n",
        "    plt.legend([], [], frameon=False)\n",
        "\n",
        "    # Calculate the percentage for each class\n",
        "    total = len(y_train)\n",
        "    class_counts = y_train.value_counts()\n",
        "    for i, count in enumerate(class_counts):\n",
        "        percentage = 100 * count / total\n",
        "        plt.text(i, count, f'{percentage:.1f}%', ha='center', va='bottom')\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "#--------   Plot Univariate Distributions   --------#\n",
        "\n",
        "def plot_univariate_distributions(X, categorical_columns):\n",
        "    numeric_columns = X.select_dtypes(include=[np.number]).columns\n",
        "    sns.set(style=\"ticks\")\n",
        "    sns.set_context('talk')\n",
        "\n",
        "    # Plot histograms and KDE plots for numeric features\n",
        "    for col in numeric_columns:\n",
        "        plt.figure(figsize=(14, 5))\n",
        "\n",
        "        # Histogram and KDE plot\n",
        "        plt.subplot(1, 2, 1)\n",
        "        sns.histplot(X[col], kde=True, color='forestgreen')\n",
        "        plt.title(f'Distribution of {col}')\n",
        "        plt.xlabel(col)\n",
        "\n",
        "        # Boxplot to detect outliers\n",
        "        plt.subplot(1, 2, 2)\n",
        "        sns.boxplot(x=X[col], color='limegreen')\n",
        "        plt.title(f'Boxplot of {col}')\n",
        "        plt.xlabel(col)\n",
        "\n",
        "        plt.tight_layout()\n",
        "        plt.show()\n",
        "\n",
        "    # Plot bar plots for other categorical features\n",
        "    for col in categorical_columns:\n",
        "        plt.figure(figsize=(8, 5))\n",
        "        sns.countplot(x=X[col], hue=X[col], palette='viridis')\n",
        "        plt.title(f'Category Distribution of {col}')\n",
        "        plt.xlabel(col)\n",
        "        plt.ylabel('Count')\n",
        "        plt.show()\n",
        "\n",
        "def plot_pay_delay_distributions(X, pay_delay_columns, aggregate_threshold=10):\n",
        "    sns.set(style=\"ticks\")\n",
        "    sns.set_context('talk')\n",
        "\n",
        "    for col in pay_delay_columns:\n",
        "        # Aggregate categories with low counts into a single \"Other\" category\n",
        "        value_counts = X[col].value_counts()\n",
        "        low_count_categories = value_counts[value_counts < aggregate_threshold].index\n",
        "        X[col] = X[col].apply(lambda x: 'Other' if x in low_count_categories else x)\n",
        "\n",
        "        plt.figure(figsize=(10, 5))\n",
        "\n",
        "        # Count plot for pay_delay columns\n",
        "        sns.countplot(x=X[col], hue=X[col], palette='viridis', order=value_counts.index)\n",
        "        plt.title(f'Distribution of {col.replace(\"_\", \" \").title()} (Aggregated)')\n",
        "        plt.xlabel(col)\n",
        "        plt.ylabel('Count')\n",
        "\n",
        "        # Rotate the x-axis labels for better visibility\n",
        "        plt.xticks(rotation=45)\n",
        "        plt.show()\n",
        "\n",
        "'''\n",
        "\n",
        "# Write the script to a file\n",
        "with open(\"eda_utils.py\", \"w\") as file:\n",
        "    file.write(script_content)\n",
        "\n",
        "print(\"Script successfully written to eda_utils.py\")\n",
        "# Reload script to make functions available for use\n",
        "import importlib\n",
        "import eda_utils\n",
        "importlib.reload(eda_utils)\n",
        "\n",
        "from eda_utils import *"
      ],
      "metadata": {
        "id": "VOWzifWM6fRP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73100609-8ca8-4eff-89a7-1d8ef642b3d3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Script successfully written to eda_utils.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Data Transform Utils"
      ],
      "metadata": {
        "id": "XqAvpP5-XbHn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "script_content=r'''\n",
        "\n",
        "# data_transformations_utils.py\n",
        "\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "from scipy.stats import mstats\n",
        "from sklearn.preprocessing import RobustScaler, PowerTransformer, QuantileTransformer\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.impute import SimpleImputer\n",
        "from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.metrics import classification_report\n",
        "import json\n",
        "import logging\n",
        "\n",
        "# Function to evaluate the baseline model\n",
        "def evaluate_baseline_model(preprocessor, X_train, X_test, y_train, y_test):\n",
        "    pipeline = Pipeline([\n",
        "        ('preprocessor', preprocessor),\n",
        "        ('classifier', LogisticRegression(max_iter=1000, random_state=42))\n",
        "    ])\n",
        "    pipeline.fit(X_train, y_train)\n",
        "    y_pred = pipeline.predict(X_test)\n",
        "    report = classification_report(y_test, y_pred, output_dict=True)\n",
        "    return report\n",
        "\n",
        "# Function to apply Winsorization (Capping)\n",
        "def winsorize_transform(X):\n",
        "    X_transformed = X.copy()\n",
        "    for col in X_transformed.columns:\n",
        "        X_transformed[col] = mstats.winsorize(X_transformed[col], limits=[0.05, 0.05])\n",
        "    return X_transformed\n",
        "\n",
        "# Function to apply the Combined Method: IQR + Winsorization + Robust Scaling\n",
        "def combined_outlier_removal(X):\n",
        "    # Step 1: Apply IQR method to remove outliers\n",
        "    def apply_iqr_outlier_removal(df):\n",
        "        df_cleaned = df.copy()\n",
        "        for col in df_cleaned.columns:\n",
        "            Q1 = df_cleaned[col].quantile(0.25)\n",
        "            Q3 = df_cleaned[col].quantile(0.75)\n",
        "            IQR = Q3 - Q1\n",
        "            lower_bound = Q1 - 1.5 * IQR\n",
        "            upper_bound = Q3 + 1.5 * IQR\n",
        "            df_cleaned = df_cleaned[(df_cleaned[col] >= lower_bound) & (df_cleaned[col] <= upper_bound)]\n",
        "        return df_cleaned\n",
        "\n",
        "    # Step 2: Apply Winsorization to cap extreme values\n",
        "    def apply_winsorization(df):\n",
        "        df_winsorized = df.copy()\n",
        "        for col in df_winsorized.columns:\n",
        "            df_winsorized[col] = mstats.winsorize(df_winsorized[col], limits=[0.05, 0.05])\n",
        "        return df_winsorized\n",
        "\n",
        "    # Step 3: Apply RobustScaler to normalize the data\n",
        "    def apply_robust_scaler(df):\n",
        "        scaler = RobustScaler()\n",
        "        return pd.DataFrame(scaler.fit_transform(df), columns=df.columns)\n",
        "\n",
        "    # Apply all the steps in sequence\n",
        "    X_cleaned = apply_iqr_outlier_removal(X)\n",
        "    X_winsorized = apply_winsorization(X_cleaned)\n",
        "    X_scaled = apply_robust_scaler(X_winsorized)\n",
        "\n",
        "    return X_scaled\n",
        "\n",
        "\n",
        "# Function to create the preprocessing pipeline\n",
        "def create_preprocessor(ordinal_columns, categorical_columns, numeric_columns, categories_for_encoder):\n",
        "    preprocessor = ColumnTransformer(\n",
        "        transformers=[\n",
        "            ('ordinal', Pipeline([\n",
        "                ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "                ('encoder', OrdinalEncoder(categories=categories_for_encoder))\n",
        "            ]), ordinal_columns),\n",
        "\n",
        "            ('categorical', Pipeline([\n",
        "                ('imputer', SimpleImputer(strategy='most_frequent')),\n",
        "                ('encoder', OneHotEncoder(drop='first', handle_unknown='ignore'))\n",
        "            ]), categorical_columns),\n",
        "\n",
        "            ('numeric', Pipeline([\n",
        "                ('imputer', SimpleImputer(strategy='median')),\n",
        "                ('scaler', StandardScaler())\n",
        "            ]), numeric_columns)\n",
        "        ],\n",
        "        remainder='passthrough'\n",
        "    )\n",
        "    return preprocessor\n",
        "\n",
        "# Function to evaluate models with different transformations\n",
        "def evaluate_method(preprocessor, X_train, X_test, y_train, y_test, method_name, classification_reports, pay_columns, transformation):\n",
        "    logging.info(f\"Evaluating method: {method_name}\")\n",
        "\n",
        "    # Apply the transformation only to the specified pay_columns\n",
        "    transformed_train = transformation(X_train[pay_columns])\n",
        "    transformed_test = transformation(X_test[pay_columns])\n",
        "\n",
        "    # Replace the original pay columns with the transformed data\n",
        "    X_train_transformed = X_train.copy()\n",
        "    X_test_transformed = X_test.copy()\n",
        "    X_train_transformed[pay_columns] = transformed_train\n",
        "    X_test_transformed[pay_columns] = transformed_test\n",
        "\n",
        "    # Build the pipeline\n",
        "    pipeline = Pipeline([\n",
        "        ('preprocessor', preprocessor),\n",
        "        ('classifier', LogisticRegression(max_iter=1000, random_state=42))\n",
        "    ])\n",
        "\n",
        "    # Train and evaluate the model\n",
        "    pipeline.fit(X_train_transformed, y_train)\n",
        "    y_pred = pipeline.predict(X_test_transformed)\n",
        "    report = classification_report(y_test, y_pred, output_dict=True)\n",
        "\n",
        "    # Save the report in the dictionary under the method name\n",
        "    classification_reports[method_name] = report\n",
        "\n",
        "# Log transformation function for pay columns\n",
        "def log_transform(X, pay_columns):\n",
        "    X_transformed = X.copy()\n",
        "    for col in pay_columns:\n",
        "        # Apply log1p transformation and handle any potential NaN/Inf values\n",
        "        X_transformed[col] = np.log1p(X_transformed[col].replace([np.inf, -np.inf], np.nan)).fillna(0)\n",
        "    return X_transformed[pay_columns]\n",
        "\n",
        "'''\n",
        "\n",
        "with open('data_transformations_utils.py', 'w') as file:\n",
        "    file.write(script_content)\n",
        "\n",
        "print(\"data_transformations_utils.py created successfully\")\n",
        "# Reload script to make functions available for use\n",
        "import importlib\n",
        "import data_transformations_utils\n",
        "importlib.reload(data_transformations_utils)\n",
        "\n",
        "from data_transformations_utils import *\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P0pD1L5wpiYv",
        "outputId": "b1a9885d-cf1b-4429-d749-f84ba8ca2cb9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "data_transformations_utils.py created successfully\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Feature Engineering Pipeline Script"
      ],
      "metadata": {
        "id": "qwjNKuQezwvc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "script_content = r'''\n",
        "# feature_engineering_pipeline_utils.py\n",
        "\n",
        "from sklearn.base import BaseEstimator, TransformerMixin\n",
        "from scipy.stats import mstats\n",
        "from sklearn.preprocessing import RobustScaler\n",
        "import pandas as pd\n",
        "\n",
        "pay_columns = ['pay_amt_4_april', 'pay_amt_5_may',\n",
        "               'pay_amt_6_june', 'pay_amt_7_july',\n",
        "               'pay_amt_8_august', 'pay_amt_9_september',\n",
        "               'bill_amt_4_april', 'bill_amt_5_may',\n",
        "               'bill_amt_6_june', 'bill_amt_7_july',\n",
        "               'bill_amt_8_august', 'bill_amt_9_september']\n",
        "\n",
        "delay_columns = [\n",
        "        'pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june',\n",
        "        'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september'\n",
        "    ]\n",
        "\n",
        "\n",
        "# ------- Outlier Removal Transformer Winsor Robust Returns Pandas DataFrame --------#\n",
        "\n",
        "class WinsorRobustOutlierRemovalTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, columns):\n",
        "        self.columns = columns\n",
        "        self.scaler = RobustScaler()\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        self.scaler.fit(X[self.columns])\n",
        "        return self\n",
        "\n",
        "    def transform(self, X):\n",
        "        X_transformed = X.copy()\n",
        "\n",
        "        # Apply Winsorization (capping)\n",
        "        for col in self.columns:\n",
        "            X_transformed[col] = mstats.winsorize(X_transformed[col], limits=[0.05, 0.05])\n",
        "\n",
        "        # Apply Robust Scaling\n",
        "        X_transformed[self.columns] = self.scaler.transform(X_transformed[self.columns])\n",
        "\n",
        "        # Convert back to DataFrame if X was a DataFrame\n",
        "        if isinstance(X, pd.DataFrame):\n",
        "            X_transformed = pd.DataFrame(X_transformed, columns=X.columns, index=X.index)\n",
        "\n",
        "        return X_transformed\n",
        "\n",
        "# ------- High Risk Delay Feature Transformer -------#\n",
        "\n",
        "class HighRiskDelayFeatureTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns):\n",
        "        self.delay_columns = delay_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Generate the 'high_risk_delay' feature\n",
        "        X['high_risk_delay'] = X[self.delay_columns].apply(\n",
        "            lambda row: any(delay in ['3 months delay', '4 months delay', '5 months delay',\n",
        "                                      '6 months delay', '7 months delay', '8 months delay',\n",
        "                                      '9+ months delay'] for delay in row),\n",
        "            axis=1\n",
        "        )\n",
        "\n",
        "        return X\n",
        "\n",
        "# ------- Severe Delay Count Transformer -------#\n",
        "\n",
        "class SevereDelayCountTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns):\n",
        "        self.delay_columns = delay_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Generate the 'severe_delay_count' feature\n",
        "        X['severe_delay_count'] = X[self.delay_columns].apply(\n",
        "            lambda row: sum(1 for delay in row if delay in ['3 months delay', '4 months delay',\n",
        "                                                            '5 months delay', '6 months delay',\n",
        "                                                            '7 months delay', '8 months delay',\n",
        "                                                            '9+ months delay']),\n",
        "            axis=1\n",
        "        )\n",
        "\n",
        "        return X\n",
        "\n",
        "# ------- Cumulative Delay Transformer -------#\n",
        "\n",
        "class AvgPaymentSevereDelaysTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self):\n",
        "        pass  # No parameters to initialize for this transformer\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Define severe delay categories\n",
        "        delays = ['3 months delay', '4 months delay', '5 months delay', '6 months delay',\n",
        "                  '7 months delay', '8 months delay', '9+ months delay']\n",
        "\n",
        "        # Calculate the average payment for severe delays\n",
        "        def calculate_avg_payment_for_severe_delays(row):\n",
        "            total_payment = 0\n",
        "            severe_delay_months = 0\n",
        "            for i, month in enumerate(['april', 'may', 'june', 'july', 'august', 'september']):\n",
        "                if row[f'pay_delay_{i+4}_{month}'] in delays:\n",
        "                    total_payment += row[f'pay_amt_{i+4}_{month}']\n",
        "                    severe_delay_months += 1\n",
        "            return total_payment / severe_delay_months if severe_delay_months > 0 else 0\n",
        "\n",
        "        # Apply the function to each row\n",
        "        X['avg_payment_severe_delays'] = X.apply(calculate_avg_payment_for_severe_delays, axis=1)\n",
        "\n",
        "        return X\n",
        "\n",
        "\n",
        "# ------- Cumulative Delay Transformer -------#\n",
        "\n",
        "class CumulativeDelayTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns):\n",
        "        self.delay_columns = delay_columns\n",
        "        self.delay_mapping = {\n",
        "            'No consumption': 0,\n",
        "            'Paid in full': 0,\n",
        "            'Revolving credit': 0,\n",
        "            '1 month delay': 1,\n",
        "            '2 months delay': 2,\n",
        "            '3 months delay': 3,\n",
        "            '4 months delay': 4,\n",
        "            '5 months delay': 5,\n",
        "            '6 months delay': 6,\n",
        "            '7 months delay': 7,\n",
        "            '8 months delay': 8,\n",
        "            '9+ months delay': 9\n",
        "        }\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Generate the 'cumulative_delay' feature\n",
        "        X['cumulative_delay'] = X[self.delay_columns].apply(\n",
        "            lambda row: sum(self.delay_mapping.get(delay, 0) for delay in row),\n",
        "            axis=1\n",
        "        )\n",
        "\n",
        "        return X\n",
        "\n",
        "\n",
        "# ------- Severe Delay Payment Ratio Transformer -------#\n",
        "\n",
        "class SevereDelayPaymentRatioTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, pay_columns, scaling_factor=10000):\n",
        "        self.pay_columns = pay_columns\n",
        "        self.scaling_factor = scaling_factor\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Calculate the total payment across the specified columns\n",
        "        X['total_payment'] = X[self.pay_columns].sum(axis=1)\n",
        "\n",
        "        # Calculate the severe delay payment ratio\n",
        "        X['severe_delay_payment_ratio'] = X.apply(\n",
        "            lambda row: (row['severe_delay_count'] / row['total_payment'] * self.scaling_factor)\n",
        "            if row['total_payment'] > 0 else 0,\n",
        "            axis=1\n",
        "        )\n",
        "\n",
        "        # Drop the temporary 'total_payment' column if desired\n",
        "        X.drop(columns=['total_payment'], inplace=True)\n",
        "\n",
        "        return X\n",
        "\n",
        "\n",
        "# ------- Deferred & Decreasing Payments Transformer -------#\n",
        "\n",
        "class DeferredAndDecreasingPaymentsTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns, pay_columns):\n",
        "        self.delay_columns = delay_columns\n",
        "        self.pay_columns = pay_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Generate the 'deferred_and_decreasing_payments' feature\n",
        "        X['deferred_and_decreasing_payments'] = X.apply(self._check_deferred_and_decreasing, axis=1)\n",
        "\n",
        "        return X\n",
        "\n",
        "    def _check_deferred_and_decreasing(self, row):\n",
        "        delays = ['1 month delay', '2 months delay', '3 months delay',\n",
        "                  '4 months delay', '5 months delay', '6 months delay',\n",
        "                  '7 months delay', '8 months delay', '9+ months delay']\n",
        "\n",
        "        # Initialize list to store payments in months with any delay\n",
        "        delay_payments = []\n",
        "\n",
        "        # Iterate over the months and collect payments for any delay\n",
        "        for i, month in enumerate(['april', 'may', 'june', 'july', 'august', 'september']):\n",
        "            if row[f'pay_delay_{i+4}_{month}'] in delays:\n",
        "                delay_payments.append(row[f'pay_amt_{i+4}_{month}'])\n",
        "\n",
        "        # Check if payments are decreasing over time\n",
        "        for j in range(1, len(delay_payments)):\n",
        "            if delay_payments[j] > delay_payments[j-1]:\n",
        "                return False  # Payments are not consistently decreasing\n",
        "\n",
        "        return True if len(delay_payments) > 1 else False  # Return True if payments are decreasing\n",
        "\n",
        "\n",
        "# ------- Severe Deferred & Decreasing Payments Transformer -------#\n",
        "\n",
        "class SevereDeferredAndDecreasingPaymentsTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns, pay_columns):\n",
        "        self.delay_columns = delay_columns\n",
        "        self.pay_columns = pay_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Generate the 'severe_deferred_and_decreasing_payments' feature\n",
        "        X['severe_deferred_and_decreasing_payments'] = X.apply(self._check_severe_deferred_and_decreasing, axis=1)\n",
        "\n",
        "        return X\n",
        "\n",
        "    def _check_severe_deferred_and_decreasing(self, row):\n",
        "        delays = ['3 months delay', '4 months delay', '5 months delay',\n",
        "                  '6 months delay', '7 months delay', '8 months delay', '9+ months delay']\n",
        "\n",
        "        # Check if there are deferred payments\n",
        "        deferred = any(row[f'pay_delay_{i+4}_{month}'] in delays for i, month in enumerate(['april', 'may', 'june', 'july', 'august', 'september']))\n",
        "\n",
        "        # Check if payments are decreasing\n",
        "        payments = [row[f'pay_amt_{i+4}_{month}'] for i, month in enumerate(['april', 'may', 'june', 'july', 'august', 'september'])]\n",
        "        decreasing = all(x >= y for x, y in zip(payments, payments[1:]))\n",
        "\n",
        "        # Return True if both conditions are met\n",
        "        return deferred and decreasing\n",
        "\n",
        "\n",
        "# ------- Severe Deferred & Any Decreasing Payments Transformer -------#\n",
        "\n",
        "class SevereDeferredAndAnyDecreasingPaymentsTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns, pay_columns):\n",
        "        self.delay_columns = delay_columns\n",
        "        self.pay_columns = pay_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Generate the 'severe_deferred_and_any_decreasing_payments' feature\n",
        "        X['severe_deferred_and_any_decreasing_payments'] = X.apply(self._check_severe_deferred_and_any_decreasing, axis=1)\n",
        "\n",
        "        return X\n",
        "\n",
        "    def _check_severe_deferred_and_any_decreasing(self, row):\n",
        "        delays = ['3 months delay', '4 months delay', '5 months delay',\n",
        "                  '6 months delay', '7 months delay', '8 months delay', '9+ months delay']\n",
        "\n",
        "        # Check if there are severe deferred payments\n",
        "        deferred = any(row[f'pay_delay_{i+4}_{month}'] in delays for i, month in enumerate(['april', 'may', 'june', 'july', 'august', 'september']))\n",
        "\n",
        "        # Check if payments are decreasing (any decrease)\n",
        "        payments = [row[f'pay_amt_{i+4}_{month}'] for i, month in enumerate(['april', 'may', 'june', 'july', 'august', 'september'])]\n",
        "        decreasing = any(x > y for x, y in zip(payments, payments[1:]))  # Any decrease in payments\n",
        "\n",
        "        # Return True if both conditions are met\n",
        "        return deferred and decreasing\n",
        "\n",
        "# ---------------------------------------------------#\n",
        "# ---------- Ratio and Interaction Features ---------#\n",
        "# ---------------------------------------------------#\n",
        "\n",
        "# ------- Bill To Payment Ratio Transformer -------#\n",
        "\n",
        "class BillToPaymentRatioTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, month):\n",
        "        self.month = month\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Define the column names based on the month\n",
        "        ratio_column = f'bill_to_payment_ratio_{self.month}'\n",
        "        bill_column = f'bill_amt_{self.month}'\n",
        "        pay_column = f'pay_amt_{self.month}'\n",
        "\n",
        "        # Calculate the bill-to-payment ratio\n",
        "        X[ratio_column] = X[bill_column] / X[pay_column].replace(0, np.nan)\n",
        "        X[ratio_column] = X[ratio_column].fillna(0)\n",
        "\n",
        "        return X\n",
        "\n",
        "# ------- Total Payments Transformer -------#\n",
        "\n",
        "class TotalPaymentsTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, pay_columns):\n",
        "        self.pay_columns = pay_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Calculate the total payments across the specified columns\n",
        "        X['total_payments'] = X[self.pay_columns].sum(axis=1)\n",
        "\n",
        "        return X\n",
        "\n",
        "# ------- Average Payment Transformer -------#\n",
        "\n",
        "class AvgPaymentTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, total_payments_column='total_payments', num_months=6):\n",
        "        self.total_payments_column = total_payments_column\n",
        "        self.num_months = num_months\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Calculate the average payment\n",
        "        X['avg_payment'] = X[self.total_payments_column] / self.num_months\n",
        "\n",
        "        return X\n",
        "\n",
        "# ------- Standard Deviation Transformer -------#\n",
        "\n",
        "class PaymentStdTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, pay_columns):\n",
        "        self.pay_columns = pay_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Calculate the standard deviation of payments across the specified columns\n",
        "        X['payment_std'] = X[self.pay_columns].std(axis=1)\n",
        "\n",
        "        return X\n",
        "\n",
        "# ------- Weighted Payment Sum Transformer -------#\n",
        "\n",
        "class WeightedPaymentSumTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, pay_columns, weights=None):\n",
        "        self.pay_columns = pay_columns\n",
        "        self.weights = weights if weights is not None else [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]  # Default weights\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Calculate the weighted payment sum across the specified columns\n",
        "        X['weighted_payment_sum'] = (X[self.pay_columns] * self.weights).sum(axis=1)\n",
        "\n",
        "        # Return the DataFrame with all original columns plus the new feature\n",
        "        return X\n",
        "\n",
        "\n",
        "\n",
        "# ------- Debt To Limit Ratio Transformer -------#\n",
        "\n",
        "class TotalBillsTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, bill_columns):\n",
        "        self.bill_columns = bill_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Calculate the total bills across the specified columns\n",
        "        X['total_bills'] = X[self.bill_columns].sum(axis=1)\n",
        "\n",
        "        return X\n",
        "\n",
        "\n",
        "class DebtToLimitRatioTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, total_bills_column='total_bills', limit_bal_column='limit_bal'):\n",
        "        self.total_bills_column = total_bills_column\n",
        "        self.limit_bal_column = limit_bal_column\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Handle cases where limit_bal is zero to avoid division by zero\n",
        "        epsilon = 1e-10  # Small value to avoid division by zero\n",
        "        X['debt_to_limit_ratio'] = X[self.total_bills_column] / (X[self.limit_bal_column] + epsilon)\n",
        "\n",
        "        # Handle infinite values, though this should be rare due to the epsilon\n",
        "        X['debt_to_limit_ratio'].replace([float('inf'), -float('inf')], 0, inplace=True)\n",
        "\n",
        "        return X\n",
        "\n",
        "\n",
        "# ------- Education & Marriage Interaction Transformer -------#\n",
        "\n",
        "class EducationMarriageInteractionTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, education_column='education', marriage_column='marriage'):\n",
        "        self.education_column = education_column\n",
        "        self.marriage_column = marriage_column\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self  # No fitting necessary\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Create the education_marriage interaction feature\n",
        "        X['education_marriage'] = X[self.education_column].astype(str) + '_' + X[self.marriage_column].astype(str)\n",
        "\n",
        "        return X\n",
        "\n",
        "# ------- Combined Feature Engineering Transformer for IMBPipeline -------#\n",
        "\n",
        "# must be ColumnTransformer to use in IMBPipeline\n",
        "class CombinedFeatureEngineeringTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns, pay_columns, bill_columns):\n",
        "        self.delay_columns = delay_columns\n",
        "        self.pay_columns = pay_columns\n",
        "        self.bill_columns = bill_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        return self\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = HighRiskDelayFeatureTransformer(self.delay_columns).fit_transform(X)\n",
        "        X = SevereDelayCountTransformer(self.delay_columns).fit_transform(X)\n",
        "        X = CumulativeDelayTransformer(self.delay_columns).fit_transform(X)\n",
        "        X = SevereDelayPaymentRatioTransformer(self.pay_columns).fit_transform(X)\n",
        "        X = AvgPaymentSevereDelaysTransformer().fit_transform(X)\n",
        "        X = DeferredAndDecreasingPaymentsTransformer(self.delay_columns, self.pay_columns).fit_transform(X)\n",
        "        X = SevereDeferredAndDecreasingPaymentsTransformer(self.delay_columns, self.pay_columns).fit_transform(X)\n",
        "        X = SevereDeferredAndAnyDecreasingPaymentsTransformer(self.delay_columns, self.pay_columns).fit_transform(X)\n",
        "        X = TotalPaymentsTransformer(self.pay_columns).fit_transform(X)\n",
        "        X = AvgPaymentTransformer().fit_transform(X)\n",
        "        X = PaymentStdTransformer(self.pay_columns).fit_transform(X)\n",
        "        X = WeightedPaymentSumTransformer(self.pay_columns).fit_transform(X)\n",
        "        X = TotalBillsTransformer(self.bill_columns).fit_transform(X)\n",
        "        X = DebtToLimitRatioTransformer(total_bills_column='total_bills', limit_bal_column='limit_bal').fit_transform(X)\n",
        "        X = EducationMarriageInteractionTransformer().fit_transform(X)\n",
        "        return X\n",
        "\n",
        "\n",
        "'''\n",
        "\n",
        "# Write the script to a file\n",
        "with open(\"feature_engineering_pipeline_utils.py\", \"w\") as file:\n",
        "    file.write(script_content)\n",
        "\n",
        "print(\"Script successfully written to feature_engineering_pipeline_utils.py\")\n",
        "# Reload script to make functions available for use\n",
        "import importlib\n",
        "import feature_engineering_pipeline_utils\n",
        "importlib.reload(feature_engineering_pipeline_utils)\n",
        "\n",
        "from feature_engineering_pipeline_utils import *"
      ],
      "metadata": {
        "id": "p9TfChdMGhTF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3716ec41-9d8c-4f71-945e-b202c42fa065"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Script successfully written to feature_engineering_pipeline_utils.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X['education'].astype(str) + '_' + X['marriage'].astype(str)"
      ],
      "metadata": {
        "id": "_oueCkOWCm6f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cU9U02Y5CpJ7"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}