loan_defaults_027_feature_selection.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/micah-shull/loan_defaults/blob/main/loan_defaults_027_feature_selection.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "### Strategy for Selecting and Rejecting Features\n",
        "\n",
        "1. **Review Feature Selection Results**:\n",
        "   - **Filter Methods**: Examine the results from variance threshold, ANOVA F-test, and mutual information.\n",
        "     - **Variance Threshold**: Identify features with consistently low variance across all data points. These features likely provide little to no predictive power and can be candidates for removal.\n",
        "     - **ANOVA F-test** and **Mutual Information**: Identify features with high scores. Features consistently ranked high across multiple filter methods are likely strong predictors.\n",
        "   - **Wrapper Methods**: Analyze the selected features from wrapper methods (RFE and RFECV with Logistic Regression and Random Forest). Since these methods involve the model directly, they are useful for identifying features that provide a real performance boost in the context of your specific model.\n",
        "\n",
        "2. **Identify Consistently Important Features**:\n",
        "   - **Intersection of Selected Features**: Look for features that were selected across multiple methods (both filter and wrapper). These features are likely strong candidates for inclusion in the final pipeline as they have been identified as important through various lenses.\n",
        "   - **High-Ranking Features**: Focus on the top-ranked features from each method. Features that consistently appear in the top rankings (e.g., top 10–15) across different methods are prime candidates for inclusion.\n",
        "   - **Feature Importance**: For wrapper methods like RFE and RFECV with Random Forest, consider the feature importances provided by the Random Forest model. Select features with high importance scores.\n",
        "\n",
        "3. **Exclude Uninformative or Redundant Features**:\n",
        "   - **Low Importance Scores**: Remove features that have low scores or were frequently excluded by wrapper methods (e.g., RFE with Logistic Regression and Random Forest). These features are likely adding noise rather than signal.\n",
        "   - **Variance Threshold**: Features that were dropped due to low variance are likely uninformative and can be safely excluded.\n",
        "   - **Highly Correlated Features**: Use the correlation matrix (from Pearson’s Correlation) to identify pairs of features with high correlation (e.g., correlation > 0.8). In highly correlated pairs, consider removing the one with the lower importance score or which appeared less frequently in the feature selection results.\n",
        "\n",
        "4. **Incorporate Domain Knowledge**:\n",
        "   - Use your understanding of the dataset and domain knowledge to guide feature inclusion. Certain features might be known to be relevant (e.g., \"age\" or \"limit balance\" in a loan default scenario). If these features are consistently ranked lower, re-evaluate why they might be less predictive and decide if they should still be included based on real-world importance.\n",
        "\n",
        "5. **Balance Complexity and Performance**:\n",
        "   - **Trade-off Analysis**: Reducing the number of features helps in simplifying the model and reducing overfitting, but it can also limit the model’s predictive power. Aim to find a balance between including enough features to capture the necessary information and excluding redundant/noisy features to reduce the model's complexity.\n",
        "   - **Number of Features**: Target a manageable number of features (e.g., 10–30) based on your findings. Both RFE and RFECV methods help to find an optimal subset of features, which can guide this decision.\n",
        "\n",
        "6. **Cross-Validation for Final Selection**:\n",
        "   - After narrowing down the feature set, perform cross-validation with the reduced feature set to ensure the model’s performance does not drop significantly.\n",
        "   - **Regularization**: Consider using models with built-in regularization (e.g., Lasso regression) to further refine the feature set and penalize less informative features.\n",
        "\n",
        "7. **Iterative Refinement**:\n",
        "   - **Experiment**: Use different combinations of features based on the analysis and iteratively refine the final set. Start with a conservative number of features and gradually introduce more if performance improvements are needed.\n",
        "   - **Reject Non-Performing Features**: Features that frequently result in performance degradation or add complexity without much gain should be removed from the pipeline.\n",
        "\n",
        "8. **Documentation**:\n",
        "   - Keep track of which features are selected or rejected by each method and your rationale for the final set of features. This transparency will help in justifying the final model and understanding its behavior.\n",
        "\n",
        "### Example Workflow\n",
        "1. **Initial Filtering**: Remove low-variance features and highly correlated ones.\n",
        "2. **Intersection**: Select features that appear across multiple filter and wrapper methods.\n",
        "3. **Prioritize**: Choose the top 15–30 features based on ranking from RFE and RFECV.\n",
        "4. **Cross-Validation**: Run the model with the selected features, evaluate performance, and adjust the feature set if necessary.\n",
        "5. **Final Selection**: Use the refined set of features in the final model.\n",
        "\n",
        "### Summary\n",
        "The goal of this strategy is to select a subset of features that:\n",
        "- Have demonstrated importance across multiple selection methods.\n",
        "- Reduce redundancy and noise, thus mitigating overfitting.\n",
        "- Maintain a balance between model complexity and predictive power.\n",
        "\n"
      ],
      "metadata": {
        "id": "9eWooSh7aLhW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Different models (like Logistic Regression and Random Forest) have varying characteristics and handle features differently. Selecting features tailored to each model can certainly improve performance. Here's how we can handle feature selection for different models, including logistic regression, random forests, boosting, and others:\n",
        "\n",
        "### 1. **Initial Feature Selection and Filtering**\n",
        "   - **Remove Non-Informative Features**: As mentioned before, start by removing low-variance features, highly correlated features, and those deemed uninformative (low importance scores) based on both filter and wrapper methods.\n",
        "   - **Create a Common \"Core\" Set of Features**: Identify a set of **\"core\" features** that are consistently selected across multiple methods and models (e.g., features selected by both RFE with Logistic Regression and Random Forest). This \"core\" set can serve as a starting point, as they are generally strong predictors and likely to be useful across different models.\n",
        "\n",
        "### 2. **Model-Specific Feature Sets**\n",
        "   - After filtering, you can divide the remaining features into **model-specific subsets**:\n",
        "     - **Logistic Regression**: Focus on features that are linearly separable. Logistic Regression works well with features that have a linear relationship with the target variable. You may also prioritize features with higher coefficients from the RFE with Logistic Regression.\n",
        "     - **Random Forest**: Emphasize features with high importance scores from the Random Forest model. Tree-based models like Random Forests and Gradient Boosting can capture complex interactions between features, so they may benefit from including features with nonlinear relationships.\n",
        "   - **How to Split**: Use the results from your wrapper methods to guide the split:\n",
        "     - Features selected by **RFE or RFECV with Logistic Regression** should go into the logistic regression subset.\n",
        "     - Features selected by **RFE or RFECV with Random Forest** go into the Random Forest subset.\n",
        "   - **Overlap Features**: Some features may be valuable to both types of models. Keep those in both sets.\n",
        "\n",
        "### 3. **Combining and Refining Feature Sets for Other Models**\n",
        "   - For models like **boosting (XGBoost, LightGBM, etc.)**, **SVM**, **Neural Networks**, etc., use the intersection of features selected by both filter and wrapper methods, along with a model-specific refinement:\n",
        "     - **Boosting Models**: Since they are ensemble tree-based models, they can handle non-linear interactions well. Start with the feature set used for Random Forest and add a few more features if needed.\n",
        "     - **SVM**: SVMs can handle complex boundaries but may be sensitive to irrelevant features. Start with a reduced set of features (those common across methods) and iteratively add more as needed.\n",
        "     - **Neural Networks**: Neural networks can learn complex feature interactions, but excessive noise in features can lead to overfitting. Start with a slightly larger set of features than other models and rely on dropout or regularization techniques to handle overfitting.\n",
        "\n",
        "### 4. **Feature Selection for Generalization**\n",
        "   - **Start Broad, Then Refine**: Initially, you might want to select a **broader set of features** and then refine based on cross-validation performance:\n",
        "     - Start with the intersection of features selected by multiple methods and models.\n",
        "     - Evaluate model performance using cross-validation to iteratively refine the set, removing or adding features to optimize results.\n",
        "\n",
        "### 5. **Automation of Feature Selection per Model**\n",
        "   - **Pipeline and Cross-Validation**: You can use scikit-learn’s `Pipeline` and `GridSearchCV` to automate feature selection for different models. For example:\n",
        "     - Use an `RFE` step in the pipeline with the model of choice (e.g., Logistic Regression, Random Forest) and perform cross-validation to identify the best feature subset.\n",
        "     - Apply **RFECV** to different models to identify the optimal number of features for each model.\n",
        "   - **Dynamic Selection**: Keep a flexible approach to feature selection by dynamically choosing features based on model performance during cross-validation.\n",
        "\n",
        "### 6. **Final Strategy Recap**\n",
        "   - **Identify Core Features**: Start with features common across selection methods.\n",
        "   - **Split into Model-Specific Subsets**: Create separate subsets tailored to models (e.g., Logistic Regression, Random Forest).\n",
        "   - **Test and Refine**: For each model, test different combinations of features and refine using cross-validation.\n",
        "   - **Optimize for New Models**: When adding new models (e.g., boosting models), use the refined feature sets as a starting point and further optimize based on model-specific performance.\n",
        "\n",
        "### 7. **Handling Changes in Model Choice**\n",
        "   - If you change models (e.g., from Logistic Regression to XGBoost), you don’t need to start from scratch. Use the results from your initial filter and wrapper methods to build a feature subset for the new model and refine based on cross-validation results.\n",
        "\n",
        "### Summary\n",
        "- **Split into Model-Specific Sets**: Based on the characteristics of the models, separate features into subsets tailored to each model (Logistic Regression, Random Forest, etc.).\n",
        "- **Test and Refine**: Use cross-validation to validate and refine the feature sets.\n",
        "- **Adapt and Optimize**: When using other models (like boosting), start with a broader set of features and adapt based on model performance.\n",
        "\n",
        "By following this approach, you'll create a flexible and tailored feature selection strategy that can be adjusted to fit different types of models, reducing overfitting and improving model generalization."
      ],
      "metadata": {
        "id": "Y1-9elGQbN4d"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NjJGNa0zVRt4"
      },
      "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"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_vARfjW4_LcJ"
      },
      "source": [
        "## Load & Preprocess Data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "collapsed": true,
        "id": "6HxbQMjvTcYL",
        "outputId": "db4a8f0d-38ae-4662-950a-78b53f563461"
      },
      "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  int64   \n",
            "dtypes: category(9), int64(15)\n",
            "memory usage: 3.9 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 is not categorical.\n",
            "\n",
            "Target as numeric\n",
            "int64\n",
            "default_payment_next_month\n",
            "0    23335\n",
            "1     6630\n",
            "Name: count, dtype: int64\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": {}
        }
      ],
      "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,load_and_preprocess_data,\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",
        "print('Target as numeric')\n",
        "print(df['default_payment_next_month'].dtype)\n",
        "print(df[target].value_counts())\n",
        "\n",
        "# visualize the categorical data\n",
        "plot_categorical_distributions(df, categorical_columns)\n",
        "plot_ordinal_distributions(df, ordinal_columns)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Feature Selection"
      ],
      "metadata": {
        "id": "rzB6c0f_UfIc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Load the JSON files"
      ],
      "metadata": {
        "id": "y0NZ5n1VkLRa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "\n",
        "# Load the selected features and classification reports from JSON files\n",
        "with open('classification_reports_filter_methods.json', 'r') as f:\n",
        "    classification_reports_filter = json.load(f)\n",
        "\n",
        "with open('classification_reports_wrapper_methods.json', 'r') as f:\n",
        "    classification_reports_wrapper = json.load(f)\n",
        "\n",
        "with open('selected_features_filter_methods.json', 'r') as f:\n",
        "    selected_features_filter = json.load(f)\n",
        "\n",
        "with open('selected_features_wrapper_methods.json', 'r') as f:\n",
        "    selected_features_wrapper = json.load(f)\n",
        "\n",
        "# Display the loaded data to understand its structure (optional)\n",
        "print(\"Selected Features (Filter Methods):\", selected_features_filter)\n",
        "print(\"Selected Features (Wrapper Methods):\", selected_features_wrapper)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UARjhwcjkBrS",
        "outputId": "898cefe8-40b0-4026-e4ff-f13c742626b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Selected Features (Filter Methods): {'Variance Threshold': ['age', 'limit_bal', 'bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june', 'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september', 'pay_amt_4_april', 'pay_amt_5_may', 'pay_amt_6_june', 'pay_amt_7_july', 'pay_amt_8_august', 'pay_amt_9_september', 'severe_delay_count', 'cumulative_delay', 'severe_delay_payment_ratio', 'avg_payment_severe_delays', 'total_payments', 'avg_payment', 'payment_std', 'weighted_payment_sum', 'total_bills', 'debt_to_limit_ratio', 'rolling_avg_delay', 'education_risk_ratio', 'marriage_risk_ratio', 'education_woe', 'marriage_woe', 'sex_Female', 'sex_Male', 'marriage_Married', 'marriage_Single', 'marriage_Unknown/Others', 'education_marriage_Graduate School_Married', 'education_marriage_Graduate School_Single', 'education_marriage_High School_Married', 'education_marriage_High School_Single', 'education_marriage_University_Married', 'education_marriage_University_Single', 'cumulative_delay_category_High Delay', 'cumulative_delay_category_Low Delay', 'cumulative_delay_category_Moderate Delay', 'cumulative_delay_category_No Delay', 'cumulative_delay_category_Severe Delay', 'pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september', 'education', 'high_risk_delay', 'deferred_and_decreasing_payments', 'severe_deferred_and_decreasing_payments', 'severe_deferred_and_any_decreasing_payments', 'education_or_marriage_unknown_flag'], 'Correlation Matrix': ['age', 'limit_bal', 'bill_amt_4_april', 'pay_amt_4_april', 'pay_amt_5_may', 'pay_amt_6_june', 'pay_amt_7_july', 'pay_amt_8_august', 'pay_amt_9_september', 'severe_delay_count', 'cumulative_delay', 'severe_delay_payment_ratio', 'avg_payment_severe_delays', 'debt_to_limit_ratio', 'education_risk_ratio', 'marriage_risk_ratio', 'sex_Female', 'marriage_Unknown/Others', 'education_marriage_Graduate School_Married', 'education_marriage_Graduate School_Single', 'education_marriage_Graduate School_Unknown/Others', 'education_marriage_High School_Married', 'education_marriage_High School_Single', 'education_marriage_High School_Unknown/Others', 'education_marriage_Other/Unknown_Married', 'education_marriage_Other/Unknown_Single', 'education_marriage_Other/Unknown_Unknown/Others', 'education_marriage_University_Married', 'education_marriage_University_Single', 'education_marriage_University_Unknown/Others', 'cumulative_delay_category_High Delay', 'cumulative_delay_category_Low Delay', 'cumulative_delay_category_Moderate Delay', 'cumulative_delay_category_No Delay', 'pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september', 'education', 'deferred_and_decreasing_payments', 'severe_deferred_and_decreasing_payments', 'education_or_marriage_unknown_flag'], 'ANOVA F-test': ['cumulative_delay', 'rolling_avg_delay', 'cumulative_delay_category_Moderate Delay', 'cumulative_delay_category_No Delay', 'pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september'], 'Mutual Information': ['age', 'limit_bal', 'pay_amt_4_april', 'pay_amt_5_may', 'pay_amt_8_august', 'cumulative_delay', 'rolling_avg_delay', 'cumulative_delay_category_No Delay', 'pay_delay_8_august', 'pay_delay_9_september']}\n",
            "Selected Features (Wrapper Methods): {'Logistic Regression with RFE': ['bill_amt_8_august', 'cumulative_delay', 'payment_std', 'education_marriage_Other/Unknown_Married', 'cumulative_delay_category_No Delay'], 'Random Forest with RFE': ['age', 'limit_bal', 'bill_amt_9_september', 'pay_amt_4_april', 'pay_amt_6_june', 'pay_amt_7_july', 'pay_amt_8_august', 'pay_amt_9_september', 'cumulative_delay', 'avg_payment', 'payment_std', 'weighted_payment_sum', 'debt_to_limit_ratio', 'rolling_avg_delay', 'pay_delay_9_september'], 'Logistic Regression with RFECV': ['cumulative_delay_category_No Delay'], 'Random Forest with RFECV': ['age', 'limit_bal', 'bill_amt_4_april', 'bill_amt_5_may', 'bill_amt_6_june', 'bill_amt_7_july', 'bill_amt_8_august', 'bill_amt_9_september', 'pay_amt_4_april', 'pay_amt_5_may', 'pay_amt_6_june', 'pay_amt_7_july', 'pay_amt_8_august', 'pay_amt_9_september', 'severe_delay_count', 'cumulative_delay', 'severe_delay_payment_ratio', 'avg_payment_severe_delays', 'total_payments', 'avg_payment', 'payment_std', 'weighted_payment_sum', 'total_bills', 'debt_to_limit_ratio', 'rolling_avg_delay', 'education_risk_ratio', 'marriage_risk_ratio', 'education_woe', 'marriage_woe', 'sex_Female', 'sex_Male', 'marriage_Married', 'marriage_Single', 'marriage_Unknown/Others', 'education_marriage_Graduate School_Married', 'education_marriage_Graduate School_Single', 'education_marriage_Graduate School_Unknown/Others', 'education_marriage_High School_Married', 'education_marriage_High School_Single', 'education_marriage_High School_Unknown/Others', 'education_marriage_Other/Unknown_Married', 'education_marriage_Other/Unknown_Single', 'education_marriage_University_Married', 'education_marriage_University_Single', 'education_marriage_University_Unknown/Others', 'cumulative_delay_category_High Delay', 'cumulative_delay_category_Low Delay', 'cumulative_delay_category_Moderate Delay', 'cumulative_delay_category_No Delay', 'cumulative_delay_category_Severe Delay', 'pay_delay_4_april', 'pay_delay_5_may', 'pay_delay_6_june', 'pay_delay_7_july', 'pay_delay_8_august', 'pay_delay_9_september', 'education', 'high_risk_delay', 'deferred_and_decreasing_payments', 'severe_deferred_and_decreasing_payments', 'severe_deferred_and_any_decreasing_payments', 'education_or_marriage_unknown_flag']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Core Features"
      ],
      "metadata": {
        "id": "aWgXvP470pOI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Analyze Filter Methods\n",
        "\n",
        "- Variance Threshold: Features removed by the variance threshold likely have low predictive power.\n",
        "- Extract features that were excluded due to low variance."
      ],
      "metadata": {
        "id": "XxAGINNqkOxn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Extract all column names from the processed DataFrame (before variance threshold)\n",
        "all_features = set(X_train_processed_df.columns)-{'target'}\n",
        "\n",
        "# Extract the features that remain after variance threshold (from the JSON file)\n",
        "remaining_features_var_thresh = set(selected_features_filter['Variance Threshold'])\n",
        "\n",
        "# Identify features that were removed by the variance threshold\n",
        "low_variance_features = all_features - remaining_features_var_thresh\n",
        "print(\"Low Variance Features (Potentially for Removal):\\n\")\n",
        "for i in low_variance_features:\n",
        "    print(i)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bgR6yCeXkBoa",
        "outputId": "e9920dbe-429c-4639-9c6f-1fc08bee09da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Low Variance Features (Potentially for Removal):\n",
            "\n",
            "education_marriage_Other/Unknown_Unknown/Others\n",
            "education_marriage_Other/Unknown_Single\n",
            "education_marriage_Other/Unknown_Married\n",
            "education_marriage_Graduate School_Unknown/Others\n",
            "education_marriage_University_Unknown/Others\n",
            "education_marriage_High School_Unknown/Others\n",
            "education_and_marriage_unknown_flag\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ANOVA F-test & Mutual Information\n",
        "- Identify features with high scores and those that are consistently selected by both methods.\n"
      ],
      "metadata": {
        "id": "DSQ00dfIlTYj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Features selected by ANOVA F-test and Mutual Information\n",
        "anova_features = set(selected_features_filter['ANOVA F-test'])\n",
        "mutual_info_features = set(selected_features_filter['Mutual Information'])\n",
        "\n",
        "# Features that consistently appear in both ANOVA and Mutual Information\n",
        "strong_filter_features = anova_features.intersection(mutual_info_features)\n",
        "print(\"Features consistently selected by ANOVA F-test and Mutual Information:\\n\")\n",
        "for i in strong_filter_features:\n",
        "    print(i)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_-6YNf1tkBli",
        "outputId": "d6c3dce3-655b-4b09-de84-93712d291371"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Features consistently selected by ANOVA F-test and Mutual Information:\n",
            "\n",
            "rolling_avg_delay\n",
            "pay_delay_9_september\n",
            "cumulative_delay\n",
            "pay_delay_8_august\n",
            "cumulative_delay_category_No Delay\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Analyze Wrapper Methods\n",
        "RFE & RFECV for Logistic Regression and Random Forest:\n",
        "\n",
        "Extract features selected by each wrapper method.\n",
        "Identify features that are common between RFE and RFECV for each model."
      ],
      "metadata": {
        "id": "5QB8Lla6ldj4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Features selected by RFE and RFECV for Logistic Regression\n",
        "rfe_log_reg_features = set(selected_features_wrapper[\"Logistic Regression with RFE\"])\n",
        "rfecv_log_reg_features = set(selected_features_wrapper[\"Logistic Regression with RFECV\"])\n",
        "\n",
        "# Features selected by RFE and RFECV for Random Forest\n",
        "rfe_rf_features = set(selected_features_wrapper[\"Random Forest with RFE\"])\n",
        "rfecv_rf_features = set(selected_features_wrapper[\"Random Forest with RFECV\"])\n",
        "\n",
        "# Common features for Logistic Regression\n",
        "common_log_reg_features = rfe_log_reg_features.intersection(rfecv_log_reg_features)\n",
        "print(\"Common Features selected by RFE and RFECV for Logistic Regression:\\n\")\n",
        "for i in common_log_reg_features:\n",
        "    print(i)\n",
        "\n",
        "# Common features for Random Forest\n",
        "common_rf_features = rfe_rf_features.intersection(rfecv_rf_features)\n",
        "print(\"\\nCommon Features selected by RFE and RFECV for Random Forest:\\n\")\n",
        "for i in common_rf_features:\n",
        "    print(i)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7sAngfw9kBig",
        "outputId": "fb06bf48-5204-49cc-9a21-668cb76d8ab2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Common Features selected by RFE and RFECV for Logistic Regression:\n",
            "\n",
            "cumulative_delay_category_No Delay\n",
            "\n",
            "Common Features selected by RFE and RFECV for Random Forest:\n",
            "\n",
            "pay_amt_6_june\n",
            "debt_to_limit_ratio\n",
            "weighted_payment_sum\n",
            "rolling_avg_delay\n",
            "bill_amt_9_september\n",
            "pay_delay_9_september\n",
            "limit_bal\n",
            "pay_amt_4_april\n",
            "pay_amt_7_july\n",
            "payment_std\n",
            "avg_payment\n",
            "pay_amt_9_september\n",
            "cumulative_delay\n",
            "pay_amt_8_august\n",
            "age\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "### Summary of Results\n",
        "1. **Low Variance Features**: The features flagged for potential removal include some that were previously identified as highly predictive. Since you’ve decided to retain these for now, we’ll keep them in our feature set for further analysis.\n",
        "\n",
        "2. **Features Consistently Selected by Both ANOVA F-test and Mutual Information**:\n",
        "   - `rolling_avg_delay`\n",
        "   - `pay_delay_9_september`\n",
        "   - `cumulative_delay`\n",
        "   - `pay_delay_8_august`\n",
        "   - `cumulative_delay_category_No Delay`\n",
        "\n",
        "   These features are strong candidates for inclusion since they were consistently ranked highly by both filter methods.\n",
        "\n",
        "3. **Wrapper Methods**:\n",
        "   - **Logistic Regression**: Only `cumulative_delay_category_No Delay` was consistently selected by both RFE and RFECV for logistic regression, suggesting it might be particularly useful for linear models.\n",
        "   - **Random Forest**: Identified a broader set of 15 features, indicating that these are likely to capture complex interactions useful for tree-based models.\n",
        "\n",
        "### Strategy for Refining the Feature Set\n",
        "\n",
        "#### 1. **Core Feature Set**\n",
        "   - **Intersection of Filter and Wrapper Methods**: Identify features that appear in multiple methods as a \"core\" feature set. In this case, `cumulative_delay_category_No Delay` appears in both the ANOVA/Mutual Information results and the RFE/RFECV with logistic regression. This makes it a strong candidate for inclusion in the final pipeline for both linear and tree-based models.\n",
        "\n",
        "   - **Strong Predictive Features**: Since `rolling_avg_delay`, `pay_delay_9_september`, `cumulative_delay`, and `pay_delay_8_august` were consistently selected by the filter methods, they should also be included in the core feature set.\n",
        "\n",
        "   **Core Feature Set**:\n",
        "   - `rolling_avg_delay`\n",
        "   - `pay_delay_9_september`\n",
        "   - `cumulative_delay`\n",
        "   - `pay_delay_8_august`\n",
        "   - `cumulative_delay_category_No Delay`\n",
        "\n",
        "#### 2. **Model-Specific Features**\n",
        "   - **Logistic Regression**:\n",
        "     - Since `cumulative_delay_category_No Delay` is the only feature selected by both RFE and RFECV for logistic regression, we'll start with the **Core Feature Set** for logistic regression and then experiment with adding features that were flagged as predictive (e.g., those that had high ANOVA or Mutual Information scores).\n",
        "   \n",
        "   - **Random Forest**:\n",
        "     - For Random Forest, include the features identified by both RFE and RFECV (`common_rf_features`). Since Random Forest can handle more complex interactions, including additional features may improve its performance. We can start with the **Core Feature Set** and add the features from the Random Forest selection:\n",
        "       - `pay_amt_6_june`, `debt_to_limit_ratio`, `weighted_payment_sum`, `bill_amt_9_september`, `limit_bal`, `pay_amt_4_april`, `pay_amt_7_july`, `payment_std`, `avg_payment`, `pay_amt_9_september`, `pay_amt_8_august`, `age`.\n",
        "\n",
        "   **Random Forest Feature Set**:\n",
        "   - Core Features: `rolling_avg_delay`, `pay_delay_9_september`, `cumulative_delay`, `pay_delay_8_august`, `cumulative_delay_category_No Delay`\n",
        "   - Additional Features: `pay_amt_6_june`, `debt_to_limit_ratio`, `weighted_payment_sum`, `bill_amt_9_september`, `limit_bal`, `pay_amt_4_april`, `pay_amt_7_july`, `payment_std`, `avg_payment`, `pay_amt_9_september`, `pay_amt_8_august`, `age`.\n",
        "\n",
        "#### 3. **Next Steps**\n",
        "1. **Create Separate Feature Sets**:\n",
        "   - **Logistic Regression**: Use the core feature set to start. You may then add more features in an iterative manner based on cross-validation performance.\n",
        "   - **Random Forest**: Use the broader feature set outlined above, including both the core features and the additional features identified by the wrapper methods for Random Forest.\n",
        "\n",
        "2. **Cross-Validation**:\n",
        "   - Validate the performance of each model with its respective feature set using cross-validation. Fine-tune the selection by removing or adding features based on model performance.\n",
        "   - For boosting models or other classifiers, begin with the Random Forest feature set and refine based on their specific characteristics.\n",
        "\n",
        "3. **Iterative Refinement**:\n",
        "   - **Experiment**: After validating performance, iteratively refine the feature sets by either removing low-impact features or including new ones to improve generalization.\n",
        "   - **Document**: Keep track of which features were added or removed in each model to build a clear understanding of the features contributing to predictive power.\n",
        "\n",
        "### Summary\n",
        "- **Core Features**: Identified a small subset of features selected by multiple methods (`rolling_avg_delay`, `pay_delay_9_september`, `cumulative_delay`, `pay_delay_8_august`, `cumulative_delay_category_No Delay`).\n",
        "- **Model-Specific Features**: Created a more extensive set for Random Forest, including both the core features and additional features identified by RFE and RFECV.\n",
        "- **Next Steps**: Implement cross-validation to finalize the selection for each model, iteratively refine, and document changes.\n",
        "\n",
        "### Updated Strategy\n",
        "\n",
        "1. **Retain Original Features**:\n",
        "   - Keep all the original features (`['limit_bal', 'sex', 'education', ..., 'pay_delay_9_september']`). These provide a baseline and carry essential information for most models.\n",
        "\n",
        "2. **Prioritize Engineered Features**:\n",
        "   - **Retain Important Engineered Features**: You mentioned retaining `rolling_avg_delay` and `cumulative_delay`, which were consistently identified as valuable by filter and wrapper methods.\n",
        "   - **Exclude Other Engineered Features**: Initially, exclude the other engineered features unless they are later found to significantly boost model performance during fine-tuning or cross-validation.\n",
        "\n",
        "3. **Fine-Grained Selection for Different Models**:\n",
        "   - **For Logistic Regression**:\n",
        "     - Start with the original features, `rolling_avg_delay`, and `cumulative_delay`.\n",
        "     - Gradually add or remove other engineered features (if needed) during cross-validation to monitor performance improvements. Focus on simplicity due to the linear nature of logistic regression.\n",
        "   - **For Tree-Based Models**:\n",
        "     - Start with the original features, `rolling_avg_delay`, and `cumulative_delay`, but keep a more flexible approach.\n",
        "     - Add or remove other engineered features based on the tree model's ability to capture complex interactions. Tree-based models, like Random Forest and Gradient Boosting, often benefit from having a more diverse feature set.\n",
        "\n",
        "4. **Next Steps**:\n",
        "   - Create subsets of features for logistic regression and tree-based models using this strategy.\n",
        "   - Use cross-validation to validate and refine these subsets.\n",
        "   - Log any changes in features during this iterative refinement.\n",
        "\n",
        "### Implementation\n",
        "\n",
        "Let's start by creating two feature sets: one for logistic regression and one for tree-based models. Each set will contain all original features, `rolling_avg_delay`, and `cumulative_delay`.\n",
        "\n",
        "\n",
        "### Fine-Grained Selection Process\n",
        "1. **Logistic Regression**: Keep the feature set simple with just the original features and the selected engineered features (`rolling_avg_delay` and `cumulative_delay`). During cross-validation, you can explore adding additional engineered features one by one (if desired) and monitor the impact on model performance.\n",
        "2. **Tree-Based Models**: Use the larger feature set as the starting point. Since tree-based models can handle complex interactions, you can be more flexible about including additional engineered features. Monitor the feature importance scores during training to identify any additional features that the model finds useful.\n",
        "\n",
        "### Summary\n",
        "- **Retain Original Features**: Keep all the original features in both models.\n",
        "- **Engineered Feature Selection**: Initially retain only `rolling_avg_delay` and `cumulative_delay`.\n",
        "- **Model-Specific Adjustments**: Tailor the feature set based on model type (simple for logistic regression, more flexible for tree-based models).\n",
        "- **Iterative Refinement**: Use cross-validation to further refine the feature sets based on model performance.\n",
        "\n",
        "By starting with this strategy, you maintain a strong baseline and can iteratively refine the model to find the best balance between simplicity and predictive power. Would you like to proceed with this implementation and start setting up cross-validation for fine-tuning?"
      ],
      "metadata": {
        "id": "rHG3olLnls0s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Model Specific Feature Selection"
      ],
      "metadata": {
        "id": "WYF2x9WO13Xg"
      }
    },
    {
      "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 imblearn.pipeline import Pipeline as IMBPipeline\n",
        "from imblearn.over_sampling import SMOTE\n",
        "from loan_data_utils import bill_columns, pay_columns, delay_columns, ordinal_columns\n",
        "from feature_engineering_pipeline_utils import WinsorRobustOutlierRemovalTransformer\n",
        "\n",
        "# Numeric Features (New numeric features added)\n",
        "numeric_features = ['limit_bal', 'age', '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",
        "\n",
        "# Categorical Features\n",
        "categorical_features = ['sex', 'marriage']\n",
        "\n",
        "# Ordinal Features\n",
        "ordinal_features = delay_columns + ['education']\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",
        "# 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",
        "# Add boolean transformer if needed\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",
        "        # Uncomment if there are boolean features to process\n",
        "        # ('bool', bool_to_numeric_transformer, boolean_features)\n",
        "    ]\n",
        ")\n",
        "\n",
        "# Step 1: Define the full pipeline (with SMOTE) for the training data\n",
        "smote_preprocessing_pipeline = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    ('preprocessor', preprocessor),  # Preprocessing\n",
        "    ('smote', SMOTE())  # SMOTE for resampling\n",
        "])\n",
        "\n",
        "# Step 2: Define the preprocessing pipeline for the test data (without SMOTE)\n",
        "test_preprocessing_pipeline = Pipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    ('preprocessor', preprocessor)  # Preprocessing (without SMOTE)\n",
        "])\n",
        "\n",
        "# Step 3: Fit the training pipeline and resample the training data\n",
        "X_train_processed, y_train_resampled = smote_preprocessing_pipeline.fit_resample(X_train, y_train)\n",
        "\n",
        "# Step 4: Fit the test preprocessing pipeline using the training data\n",
        "test_preprocessing_pipeline.fit(X_train)\n",
        "\n",
        "# Step 5: Transform the test data using the test preprocessing pipeline\n",
        "X_test_processed = test_preprocessing_pipeline.transform(X_test)\n",
        "\n",
        "# Initialize an empty list to store feature names\n",
        "all_feature_names = []\n",
        "\n",
        "# Loop through each transformer in the preprocessor to capture feature names\n",
        "for name, transformer, columns in smote_preprocessing_pipeline.named_steps['preprocessor'].transformers_:\n",
        "    if name == 'num':  # Numeric features (imputation and scaling)\n",
        "        all_feature_names.extend(columns)  # Original column names since scaling doesn't change them\n",
        "    elif name == 'cat':  # Categorical features (OneHotEncoder)\n",
        "        all_feature_names.extend(transformer.named_steps['onehot'].get_feature_names_out(columns))\n",
        "    elif name == 'ord':  # Ordinal features (OrdinalEncoder)\n",
        "        all_feature_names.extend(columns)  # Ordinal features use original column names\n",
        "\n",
        "# Step 6: Convert the processed training and test data to DataFrames with meaningful feature names\n",
        "X_train_processed_df = pd.DataFrame(X_train_processed, columns=all_feature_names)\n",
        "X_test_processed_df = pd.DataFrame(X_test_processed, columns=all_feature_names)\n",
        "\n",
        "# Step 7: Add the target variable to the training and test DataFrames\n",
        "X_train_processed_df['target'] = y_train_resampled.reset_index(drop=True)\n",
        "X_test_processed_df['target'] = y_test.reset_index(drop=True)\n",
        "\n",
        "# Step 8: Inspect the processed DataFrames\n",
        "print(\"Processed training data:\")\n",
        "print(X_train_processed_df.info())\n",
        "print(\"Processed test data:\")\n",
        "print(X_test_processed_df.info())\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i0DvK_jhXL8h",
        "outputId": "eab7ca8e-fbdf-4400-e2b6-633d4abd5a8f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Processed training data:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 37336 entries, 0 to 37335\n",
            "Data columns (total 27 columns):\n",
            " #   Column                   Non-Null Count  Dtype  \n",
            "---  ------                   --------------  -----  \n",
            " 0   limit_bal                37336 non-null  float64\n",
            " 1   age                      37336 non-null  float64\n",
            " 2   bill_amt_4_april         37336 non-null  float64\n",
            " 3   bill_amt_5_may           37336 non-null  float64\n",
            " 4   bill_amt_6_june          37336 non-null  float64\n",
            " 5   bill_amt_7_july          37336 non-null  float64\n",
            " 6   bill_amt_8_august        37336 non-null  float64\n",
            " 7   bill_amt_9_september     37336 non-null  float64\n",
            " 8   pay_amt_4_april          37336 non-null  float64\n",
            " 9   pay_amt_5_may            37336 non-null  float64\n",
            " 10  pay_amt_6_june           37336 non-null  float64\n",
            " 11  pay_amt_7_july           37336 non-null  float64\n",
            " 12  pay_amt_8_august         37336 non-null  float64\n",
            " 13  pay_amt_9_september      37336 non-null  float64\n",
            " 14  sex_Female               37336 non-null  float64\n",
            " 15  sex_Male                 37336 non-null  float64\n",
            " 16  marriage_Married         37336 non-null  float64\n",
            " 17  marriage_Single          37336 non-null  float64\n",
            " 18  marriage_Unknown/Others  37336 non-null  float64\n",
            " 19  pay_delay_4_april        37336 non-null  float64\n",
            " 20  pay_delay_5_may          37336 non-null  float64\n",
            " 21  pay_delay_6_june         37336 non-null  float64\n",
            " 22  pay_delay_7_july         37336 non-null  float64\n",
            " 23  pay_delay_8_august       37336 non-null  float64\n",
            " 24  pay_delay_9_september    37336 non-null  float64\n",
            " 25  education                37336 non-null  float64\n",
            " 26  target                   37336 non-null  int64  \n",
            "dtypes: float64(26), int64(1)\n",
            "memory usage: 7.7 MB\n",
            "None\n",
            "Processed test data:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 5993 entries, 0 to 5992\n",
            "Data columns (total 27 columns):\n",
            " #   Column                   Non-Null Count  Dtype  \n",
            "---  ------                   --------------  -----  \n",
            " 0   limit_bal                5993 non-null   float64\n",
            " 1   age                      5993 non-null   float64\n",
            " 2   bill_amt_4_april         5993 non-null   float64\n",
            " 3   bill_amt_5_may           5993 non-null   float64\n",
            " 4   bill_amt_6_june          5993 non-null   float64\n",
            " 5   bill_amt_7_july          5993 non-null   float64\n",
            " 6   bill_amt_8_august        5993 non-null   float64\n",
            " 7   bill_amt_9_september     5993 non-null   float64\n",
            " 8   pay_amt_4_april          5993 non-null   float64\n",
            " 9   pay_amt_5_may            5993 non-null   float64\n",
            " 10  pay_amt_6_june           5993 non-null   float64\n",
            " 11  pay_amt_7_july           5993 non-null   float64\n",
            " 12  pay_amt_8_august         5993 non-null   float64\n",
            " 13  pay_amt_9_september      5993 non-null   float64\n",
            " 14  sex_Female               5993 non-null   float64\n",
            " 15  sex_Male                 5993 non-null   float64\n",
            " 16  marriage_Married         5993 non-null   float64\n",
            " 17  marriage_Single          5993 non-null   float64\n",
            " 18  marriage_Unknown/Others  5993 non-null   float64\n",
            " 19  pay_delay_4_april        5993 non-null   float64\n",
            " 20  pay_delay_5_may          5993 non-null   float64\n",
            " 21  pay_delay_6_june         5993 non-null   float64\n",
            " 22  pay_delay_7_july         5993 non-null   float64\n",
            " 23  pay_delay_8_august       5993 non-null   float64\n",
            " 24  pay_delay_9_september    5993 non-null   float64\n",
            " 25  education                5993 non-null   float64\n",
            " 26  target                   5993 non-null   int64  \n",
            "dtypes: float64(26), int64(1)\n",
            "memory usage: 1.2 MB\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Feature Engineering Pipeline - Log Reg"
      ],
      "metadata": {
        "id": "A1bKssRSncOj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.base import BaseEstimator, TransformerMixin\n",
        "\n",
        "core_features = ['rolling_avg_delay', 'cumulative_delay']\n",
        "rf_features = core_features + ['debt_to_limit_ratio','weighted_payment_sum', 'payment_std', 'avg_payment']\n",
        "boolean_features = [ 'education_and_marriage_unknown_flag', 'education_or_marriage_unknown_flag']\n",
        "\n",
        "# ------- Combined Feature Engineering Transformer for IMBPipeline -------#\n",
        "\n",
        "class CombinedFeatureEngineeringTransformerLogReg(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns):\n",
        "        self.delay_columns = delay_columns\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        # This method doesn't need to do anything for this transformer\n",
        "        return self\n",
        "\n",
        "    def transform(self, X, y=None):\n",
        "        \"\"\"\n",
        "        Apply only the necessary transformations for logistic regression.\n",
        "        \"\"\"\n",
        "        # Apply transformations for the core features\n",
        "        X = RollingAverageDelayTransformer(self.delay_columns).transform(X)\n",
        "        X = CumulativeDelayTransformer(self.delay_columns).transform(X)\n",
        "        X = EducationMarriageInteractionTransformer().transform(X)\n",
        "        X = EducationMarriageUnknownFlagTransformer().transform(X)\n",
        "\n",
        "        return X\n"
      ],
      "metadata": {
        "id": "-Wx4mY3SokU7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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 loan_data_utils import bill_columns, pay_columns, delay_columns, ordinal_columns, ThresholdClassifier\n",
        "from feature_engineering_pipeline_utils import WinsorRobustOutlierRemovalTransformer, RollingAverageDelayTransformer, CumulativeDelayTransformer, EducationMarriageInteractionTransformer, EducationMarriageUnknownFlagTransformer\n",
        "\n",
        "# Numeric Features (New numeric features added)\n",
        "numeric_features_logreg = ['limit_bal', 'age', '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'] + core_features\n",
        "# Categorical Features\n",
        "categorical_features = categorical_columns + ['education_marriage']\n",
        "# Ordinal Features\n",
        "ordinal_features = delay_columns + ['education']\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",
        "\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_logreg),\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 1: Define the full pipeline (with SMOTE) for the training data\n",
        "smote_preprocessing_pipeline = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    ('feature_engineering', CombinedFeatureEngineeringTransformerLogReg(delay_columns)),  # Feature engineering\n",
        "    ('preprocessor', preprocessor),  # Preprocessing\n",
        "    ('smote', SMOTE())  # SMOTE for resampling\n",
        "])\n",
        "\n",
        "# Step 2: Define the preprocessing pipeline for the test data (without SMOTE)\n",
        "test_preprocessing_pipeline = Pipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    # Reuse the fitted CombinedFeatureEngineeringTransformer from the training pipeline\n",
        "    ('feature_engineering', smote_preprocessing_pipeline.named_steps['feature_engineering']),\n",
        "    ('preprocessor', preprocessor)  # Preprocessing (without SMOTE)\n",
        "])\n",
        "\n",
        "# Step 3: Fit the training pipeline and resample the training data\n",
        "X_train_processed, y_train_resampled = smote_preprocessing_pipeline.fit_resample(X_train, y_train)\n",
        "\n",
        "# Step 4: Fit the test preprocessing pipeline using the training data\n",
        "# Ensuring the test pipeline learns from X_train for scaling and encoding\n",
        "test_preprocessing_pipeline.fit(X_train)\n",
        "\n",
        "# Step 5: Transform the test data using the test preprocessing pipeline\n",
        "X_test_processed = test_preprocessing_pipeline.transform(X_test)\n",
        "\n",
        "# Initialize an empty list to store feature names\n",
        "all_feature_names = []\n",
        "\n",
        "# Loop through each transformer in the preprocessor to capture feature names\n",
        "for name, transformer, columns in smote_preprocessing_pipeline.named_steps['preprocessor'].transformers_:\n",
        "    if name == 'num':  # Numeric features (imputation and scaling)\n",
        "        all_feature_names.extend(transformer.named_steps['scaler'].get_feature_names_out(columns))\n",
        "    elif name == 'cat':  # Categorical features (OneHotEncoder)\n",
        "        all_feature_names.extend(transformer.named_steps['onehot'].get_feature_names_out(columns))\n",
        "    elif name == 'ord':  # Ordinal features (OrdinalEncoder)\n",
        "        all_feature_names.extend(columns)  # Ordinal features don't expand, so just use the column names\n",
        "    elif name == 'bool':  # Boolean features (converted to int)\n",
        "        all_feature_names.extend(columns)\n",
        "\n",
        "# Step 7: Convert the processed training and test data to DataFrames with meaningful feature names\n",
        "X_train_processed_df = pd.DataFrame(X_train_processed, columns=all_feature_names)\n",
        "X_test_processed_df = pd.DataFrame(X_test_processed, columns=all_feature_names)\n",
        "\n",
        "# Step 8: Add the target variable to the training and test DataFrames\n",
        "X_train_processed_df['target'] = y_train_resampled.reset_index(drop=True)\n",
        "X_test_processed_df['target'] = y_test.reset_index(drop=True)  # We don't resample y_test\n",
        "\n",
        "# Step 9: Inspect the processed DataFrames (Optional step)\n",
        "print(\"Processed training data:\")\n",
        "print(X_train_processed_df.info())\n",
        "print(\"Processed test data:\")\n",
        "print(X_test_processed_df.info())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ArZ6mQ8EQ3hb",
        "outputId": "5abdca49-142d-4cf7-e6b2-ed4c9d80f81a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Processed training data:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 37336 entries, 0 to 37335\n",
            "Data columns (total 43 columns):\n",
            " #   Column                                             Non-Null Count  Dtype  \n",
            "---  ------                                             --------------  -----  \n",
            " 0   limit_bal                                          37336 non-null  float64\n",
            " 1   age                                                37336 non-null  float64\n",
            " 2   bill_amt_4_april                                   37336 non-null  float64\n",
            " 3   bill_amt_5_may                                     37336 non-null  float64\n",
            " 4   bill_amt_6_june                                    37336 non-null  float64\n",
            " 5   bill_amt_7_july                                    37336 non-null  float64\n",
            " 6   bill_amt_8_august                                  37336 non-null  float64\n",
            " 7   bill_amt_9_september                               37336 non-null  float64\n",
            " 8   pay_amt_4_april                                    37336 non-null  float64\n",
            " 9   pay_amt_5_may                                      37336 non-null  float64\n",
            " 10  pay_amt_6_june                                     37336 non-null  float64\n",
            " 11  pay_amt_7_july                                     37336 non-null  float64\n",
            " 12  pay_amt_8_august                                   37336 non-null  float64\n",
            " 13  pay_amt_9_september                                37336 non-null  float64\n",
            " 14  rolling_avg_delay                                  37336 non-null  float64\n",
            " 15  cumulative_delay                                   37336 non-null  float64\n",
            " 16  sex_Female                                         37336 non-null  float64\n",
            " 17  sex_Male                                           37336 non-null  float64\n",
            " 18  marriage_Married                                   37336 non-null  float64\n",
            " 19  marriage_Single                                    37336 non-null  float64\n",
            " 20  marriage_Unknown/Others                            37336 non-null  float64\n",
            " 21  education_marriage_Graduate School_Married         37336 non-null  float64\n",
            " 22  education_marriage_Graduate School_Single          37336 non-null  float64\n",
            " 23  education_marriage_Graduate School_Unknown/Others  37336 non-null  float64\n",
            " 24  education_marriage_High School_Married             37336 non-null  float64\n",
            " 25  education_marriage_High School_Single              37336 non-null  float64\n",
            " 26  education_marriage_High School_Unknown/Others      37336 non-null  float64\n",
            " 27  education_marriage_Other/Unknown_Married           37336 non-null  float64\n",
            " 28  education_marriage_Other/Unknown_Single            37336 non-null  float64\n",
            " 29  education_marriage_Other/Unknown_Unknown/Others    37336 non-null  float64\n",
            " 30  education_marriage_University_Married              37336 non-null  float64\n",
            " 31  education_marriage_University_Single               37336 non-null  float64\n",
            " 32  education_marriage_University_Unknown/Others       37336 non-null  float64\n",
            " 33  pay_delay_4_april                                  37336 non-null  float64\n",
            " 34  pay_delay_5_may                                    37336 non-null  float64\n",
            " 35  pay_delay_6_june                                   37336 non-null  float64\n",
            " 36  pay_delay_7_july                                   37336 non-null  float64\n",
            " 37  pay_delay_8_august                                 37336 non-null  float64\n",
            " 38  pay_delay_9_september                              37336 non-null  float64\n",
            " 39  education                                          37336 non-null  float64\n",
            " 40  education_and_marriage_unknown_flag                37336 non-null  float64\n",
            " 41  education_or_marriage_unknown_flag                 37336 non-null  float64\n",
            " 42  target                                             37336 non-null  int64  \n",
            "dtypes: float64(42), int64(1)\n",
            "memory usage: 12.2 MB\n",
            "None\n",
            "Processed test data:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 5993 entries, 0 to 5992\n",
            "Data columns (total 43 columns):\n",
            " #   Column                                             Non-Null Count  Dtype  \n",
            "---  ------                                             --------------  -----  \n",
            " 0   limit_bal                                          5993 non-null   float64\n",
            " 1   age                                                5993 non-null   float64\n",
            " 2   bill_amt_4_april                                   5993 non-null   float64\n",
            " 3   bill_amt_5_may                                     5993 non-null   float64\n",
            " 4   bill_amt_6_june                                    5993 non-null   float64\n",
            " 5   bill_amt_7_july                                    5993 non-null   float64\n",
            " 6   bill_amt_8_august                                  5993 non-null   float64\n",
            " 7   bill_amt_9_september                               5993 non-null   float64\n",
            " 8   pay_amt_4_april                                    5993 non-null   float64\n",
            " 9   pay_amt_5_may                                      5993 non-null   float64\n",
            " 10  pay_amt_6_june                                     5993 non-null   float64\n",
            " 11  pay_amt_7_july                                     5993 non-null   float64\n",
            " 12  pay_amt_8_august                                   5993 non-null   float64\n",
            " 13  pay_amt_9_september                                5993 non-null   float64\n",
            " 14  rolling_avg_delay                                  5993 non-null   float64\n",
            " 15  cumulative_delay                                   5993 non-null   float64\n",
            " 16  sex_Female                                         5993 non-null   float64\n",
            " 17  sex_Male                                           5993 non-null   float64\n",
            " 18  marriage_Married                                   5993 non-null   float64\n",
            " 19  marriage_Single                                    5993 non-null   float64\n",
            " 20  marriage_Unknown/Others                            5993 non-null   float64\n",
            " 21  education_marriage_Graduate School_Married         5993 non-null   float64\n",
            " 22  education_marriage_Graduate School_Single          5993 non-null   float64\n",
            " 23  education_marriage_Graduate School_Unknown/Others  5993 non-null   float64\n",
            " 24  education_marriage_High School_Married             5993 non-null   float64\n",
            " 25  education_marriage_High School_Single              5993 non-null   float64\n",
            " 26  education_marriage_High School_Unknown/Others      5993 non-null   float64\n",
            " 27  education_marriage_Other/Unknown_Married           5993 non-null   float64\n",
            " 28  education_marriage_Other/Unknown_Single            5993 non-null   float64\n",
            " 29  education_marriage_Other/Unknown_Unknown/Others    5993 non-null   float64\n",
            " 30  education_marriage_University_Married              5993 non-null   float64\n",
            " 31  education_marriage_University_Single               5993 non-null   float64\n",
            " 32  education_marriage_University_Unknown/Others       5993 non-null   float64\n",
            " 33  pay_delay_4_april                                  5993 non-null   float64\n",
            " 34  pay_delay_5_may                                    5993 non-null   float64\n",
            " 35  pay_delay_6_june                                   5993 non-null   float64\n",
            " 36  pay_delay_7_july                                   5993 non-null   float64\n",
            " 37  pay_delay_8_august                                 5993 non-null   float64\n",
            " 38  pay_delay_9_september                              5993 non-null   float64\n",
            " 39  education                                          5993 non-null   float64\n",
            " 40  education_and_marriage_unknown_flag                5993 non-null   float64\n",
            " 41  education_or_marriage_unknown_flag                 5993 non-null   float64\n",
            " 42  target                                             5993 non-null   int64  \n",
            "dtypes: float64(42), int64(1)\n",
            "memory usage: 2.0 MB\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Feature Engineering Pipeline - Random Forest"
      ],
      "metadata": {
        "id": "8kY6REVmn4cD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from loan_data_utils import bill_columns, pay_columns, delay_columns, ordinal_columns, ThresholdClassifier\n",
        "from feature_engineering_pipeline_utils import (WinsorRobustOutlierRemovalTransformer, RollingAverageDelayTransformer, CumulativeDelayTransformer,\n",
        "                                                EducationMarriageInteractionTransformer, EducationMarriageUnknownFlagTransformer, TotalBillsTransformer, TotalPaymentsTransformer,\n",
        "                                                DebtToLimitRatioTransformer, WeightedPaymentSumTransformer, AvgPaymentTransformer, PaymentStdTransformer)\n",
        "\n",
        "rf_features = core_features + ['debt_to_limit_ratio', 'total_payments', 'total_bills', 'payment_std', 'avg_payment', 'weighted_payment_sum']\n",
        "boolean_features = [ 'education_and_marriage_unknown_flag', 'education_or_marriage_unknown_flag']\n",
        "\n",
        "# ------- Combined Feature Engineering Transformer for IMBPipeline (Random Forest) -------#\n",
        "\n",
        "class CombinedFeatureEngineeringTransformerRF(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",
        "        # This method doesn't need to do anything for this transformer\n",
        "        return self\n",
        "\n",
        "    def transform(self, X, y=None):\n",
        "        \"\"\"\n",
        "        Apply only the necessary transformations for Random Forest.\n",
        "        \"\"\"\n",
        "        # Apply transformations for the core features\n",
        "        X = RollingAverageDelayTransformer(self.delay_columns).transform(X)\n",
        "        X = CumulativeDelayTransformer(self.delay_columns).transform(X)\n",
        "        X = EducationMarriageInteractionTransformer().transform(X)\n",
        "        X = EducationMarriageUnknownFlagTransformer().transform(X)\n",
        "        X = TotalBillsTransformer(self.bill_columns).transform(X)\n",
        "        X = DebtToLimitRatioTransformer(total_bills_column='total_bills', limit_bal_column='limit_bal').transform(X)\n",
        "        X = TotalPaymentsTransformer(self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = AvgPaymentTransformer().transform(X)\n",
        "        X = PaymentStdTransformer(self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = WeightedPaymentSumTransformer(self.pay_columns + self.bill_columns).transform(X)\n",
        "\n",
        "        return X\n"
      ],
      "metadata": {
        "id": "3BctA2d_RE7D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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 loan_data_utils import bill_columns, pay_columns, delay_columns, ordinal_columns, ThresholdClassifier\n",
        "# from feature_engineering_pipeline_utils import (WinsorRobustOutlierRemovalTransformer, RollingAverageDelayTransformer, CumulativeDelayTransformer,\n",
        "#                                                 EducationMarriageInteractionTransformer, EducationMarriageUnknownFlagTransformer, TotalBillsTransformer, TotalPaymentsTransformer,\n",
        "#                                                 DebtToLimitRatioTransformer, WeightedPaymentSumTransformer, AvgPaymentTransformer, PaymentStdTransformer)\n",
        "\n",
        "# Numeric Features (New numeric features added)\n",
        "numeric_features_RF = ['limit_bal', 'age', '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'] + rf_features\n",
        "# Categorical Features\n",
        "categorical_features = categorical_columns + ['education_marriage']\n",
        "# Ordinal Features\n",
        "ordinal_features = delay_columns + ['education']\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",
        "\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_RF),\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 1: Define the full pipeline (with SMOTE) for the training data\n",
        "smote_preprocessing_pipeline = IMBPipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    ('feature_engineering', CombinedFeatureEngineeringTransformerRF(delay_columns, pay_columns, bill_columns)),  # Feature engineering\n",
        "    ('preprocessor', preprocessor),  # Preprocessing\n",
        "    ('smote', SMOTE())  # SMOTE for resampling\n",
        "])\n",
        "\n",
        "# Step 2: Define the preprocessing pipeline for the test data (without SMOTE)\n",
        "test_preprocessing_pipeline = Pipeline(steps=[\n",
        "    ('outlier_removal', WinsorRobustOutlierRemovalTransformer(columns=pay_columns)),  # Outlier removal\n",
        "    # Reuse the fitted CombinedFeatureEngineeringTransformer from the training pipeline\n",
        "    ('feature_engineering', smote_preprocessing_pipeline.named_steps['feature_engineering']),\n",
        "    ('preprocessor', preprocessor)  # Preprocessing (without SMOTE)\n",
        "])\n",
        "\n",
        "# Step 3: Fit the training pipeline and resample the training data\n",
        "X_train_processed, y_train_resampled = smote_preprocessing_pipeline.fit_resample(X_train, y_train)\n",
        "\n",
        "# Step 4: Fit the test preprocessing pipeline using the training data\n",
        "# Ensuring the test pipeline learns from X_train for scaling and encoding\n",
        "test_preprocessing_pipeline.fit(X_train)\n",
        "\n",
        "# Step 5: Transform the test data using the test preprocessing pipeline\n",
        "X_test_processed = test_preprocessing_pipeline.transform(X_test)\n",
        "\n",
        "# Initialize an empty list to store feature names\n",
        "all_feature_names = []\n",
        "\n",
        "# Loop through each transformer in the preprocessor to capture feature names\n",
        "for name, transformer, columns in smote_preprocessing_pipeline.named_steps['preprocessor'].transformers_:\n",
        "    if name == 'num':  # Numeric features (imputation and scaling)\n",
        "        all_feature_names.extend(transformer.named_steps['scaler'].get_feature_names_out(columns))\n",
        "    elif name == 'cat':  # Categorical features (OneHotEncoder)\n",
        "        all_feature_names.extend(transformer.named_steps['onehot'].get_feature_names_out(columns))\n",
        "    elif name == 'ord':  # Ordinal features (OrdinalEncoder)\n",
        "        all_feature_names.extend(columns)  # Ordinal features don't expand, so just use the column names\n",
        "    elif name == 'bool':  # Boolean features (converted to int)\n",
        "        all_feature_names.extend(columns)\n",
        "\n",
        "# Step 7: Convert the processed training and test data to DataFrames with meaningful feature names\n",
        "X_train_processed_df = pd.DataFrame(X_train_processed, columns=all_feature_names)\n",
        "X_test_processed_df = pd.DataFrame(X_test_processed, columns=all_feature_names)\n",
        "\n",
        "# Step 8: Add the target variable to the training and test DataFrames\n",
        "X_train_processed_df['target'] = y_train_resampled.reset_index(drop=True)\n",
        "X_test_processed_df['target'] = y_test.reset_index(drop=True)  # We don't resample y_test\n",
        "\n",
        "# Step 9: Inspect the processed DataFrames (Optional step)\n",
        "print(\"Processed training data:\")\n",
        "print(X_train_processed_df.info())\n",
        "print(\"Processed test data:\")\n",
        "print(X_test_processed_df.info())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D_SSSDvhlkRd",
        "outputId": "fde5a925-d795-4923-af02-eb6f2e9116d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Processed training data:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 37336 entries, 0 to 37335\n",
            "Data columns (total 49 columns):\n",
            " #   Column                                             Non-Null Count  Dtype  \n",
            "---  ------                                             --------------  -----  \n",
            " 0   limit_bal                                          37336 non-null  float64\n",
            " 1   age                                                37336 non-null  float64\n",
            " 2   bill_amt_4_april                                   37336 non-null  float64\n",
            " 3   bill_amt_5_may                                     37336 non-null  float64\n",
            " 4   bill_amt_6_june                                    37336 non-null  float64\n",
            " 5   bill_amt_7_july                                    37336 non-null  float64\n",
            " 6   bill_amt_8_august                                  37336 non-null  float64\n",
            " 7   bill_amt_9_september                               37336 non-null  float64\n",
            " 8   pay_amt_4_april                                    37336 non-null  float64\n",
            " 9   pay_amt_5_may                                      37336 non-null  float64\n",
            " 10  pay_amt_6_june                                     37336 non-null  float64\n",
            " 11  pay_amt_7_july                                     37336 non-null  float64\n",
            " 12  pay_amt_8_august                                   37336 non-null  float64\n",
            " 13  pay_amt_9_september                                37336 non-null  float64\n",
            " 14  rolling_avg_delay                                  37336 non-null  float64\n",
            " 15  cumulative_delay                                   37336 non-null  float64\n",
            " 16  debt_to_limit_ratio                                37336 non-null  float64\n",
            " 17  total_payments                                     37336 non-null  float64\n",
            " 18  total_bills                                        37336 non-null  float64\n",
            " 19  payment_std                                        37336 non-null  float64\n",
            " 20  avg_payment                                        37336 non-null  float64\n",
            " 21  weighted_payment_sum                               37336 non-null  float64\n",
            " 22  sex_Female                                         37336 non-null  float64\n",
            " 23  sex_Male                                           37336 non-null  float64\n",
            " 24  marriage_Married                                   37336 non-null  float64\n",
            " 25  marriage_Single                                    37336 non-null  float64\n",
            " 26  marriage_Unknown/Others                            37336 non-null  float64\n",
            " 27  education_marriage_Graduate School_Married         37336 non-null  float64\n",
            " 28  education_marriage_Graduate School_Single          37336 non-null  float64\n",
            " 29  education_marriage_Graduate School_Unknown/Others  37336 non-null  float64\n",
            " 30  education_marriage_High School_Married             37336 non-null  float64\n",
            " 31  education_marriage_High School_Single              37336 non-null  float64\n",
            " 32  education_marriage_High School_Unknown/Others      37336 non-null  float64\n",
            " 33  education_marriage_Other/Unknown_Married           37336 non-null  float64\n",
            " 34  education_marriage_Other/Unknown_Single            37336 non-null  float64\n",
            " 35  education_marriage_Other/Unknown_Unknown/Others    37336 non-null  float64\n",
            " 36  education_marriage_University_Married              37336 non-null  float64\n",
            " 37  education_marriage_University_Single               37336 non-null  float64\n",
            " 38  education_marriage_University_Unknown/Others       37336 non-null  float64\n",
            " 39  pay_delay_4_april                                  37336 non-null  float64\n",
            " 40  pay_delay_5_may                                    37336 non-null  float64\n",
            " 41  pay_delay_6_june                                   37336 non-null  float64\n",
            " 42  pay_delay_7_july                                   37336 non-null  float64\n",
            " 43  pay_delay_8_august                                 37336 non-null  float64\n",
            " 44  pay_delay_9_september                              37336 non-null  float64\n",
            " 45  education                                          37336 non-null  float64\n",
            " 46  education_and_marriage_unknown_flag                37336 non-null  float64\n",
            " 47  education_or_marriage_unknown_flag                 37336 non-null  float64\n",
            " 48  target                                             37336 non-null  int64  \n",
            "dtypes: float64(48), int64(1)\n",
            "memory usage: 14.0 MB\n",
            "None\n",
            "Processed test data:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 5993 entries, 0 to 5992\n",
            "Data columns (total 49 columns):\n",
            " #   Column                                             Non-Null Count  Dtype  \n",
            "---  ------                                             --------------  -----  \n",
            " 0   limit_bal                                          5993 non-null   float64\n",
            " 1   age                                                5993 non-null   float64\n",
            " 2   bill_amt_4_april                                   5993 non-null   float64\n",
            " 3   bill_amt_5_may                                     5993 non-null   float64\n",
            " 4   bill_amt_6_june                                    5993 non-null   float64\n",
            " 5   bill_amt_7_july                                    5993 non-null   float64\n",
            " 6   bill_amt_8_august                                  5993 non-null   float64\n",
            " 7   bill_amt_9_september                               5993 non-null   float64\n",
            " 8   pay_amt_4_april                                    5993 non-null   float64\n",
            " 9   pay_amt_5_may                                      5993 non-null   float64\n",
            " 10  pay_amt_6_june                                     5993 non-null   float64\n",
            " 11  pay_amt_7_july                                     5993 non-null   float64\n",
            " 12  pay_amt_8_august                                   5993 non-null   float64\n",
            " 13  pay_amt_9_september                                5993 non-null   float64\n",
            " 14  rolling_avg_delay                                  5993 non-null   float64\n",
            " 15  cumulative_delay                                   5993 non-null   float64\n",
            " 16  debt_to_limit_ratio                                5993 non-null   float64\n",
            " 17  total_payments                                     5993 non-null   float64\n",
            " 18  total_bills                                        5993 non-null   float64\n",
            " 19  payment_std                                        5993 non-null   float64\n",
            " 20  avg_payment                                        5993 non-null   float64\n",
            " 21  weighted_payment_sum                               5993 non-null   float64\n",
            " 22  sex_Female                                         5993 non-null   float64\n",
            " 23  sex_Male                                           5993 non-null   float64\n",
            " 24  marriage_Married                                   5993 non-null   float64\n",
            " 25  marriage_Single                                    5993 non-null   float64\n",
            " 26  marriage_Unknown/Others                            5993 non-null   float64\n",
            " 27  education_marriage_Graduate School_Married         5993 non-null   float64\n",
            " 28  education_marriage_Graduate School_Single          5993 non-null   float64\n",
            " 29  education_marriage_Graduate School_Unknown/Others  5993 non-null   float64\n",
            " 30  education_marriage_High School_Married             5993 non-null   float64\n",
            " 31  education_marriage_High School_Single              5993 non-null   float64\n",
            " 32  education_marriage_High School_Unknown/Others      5993 non-null   float64\n",
            " 33  education_marriage_Other/Unknown_Married           5993 non-null   float64\n",
            " 34  education_marriage_Other/Unknown_Single            5993 non-null   float64\n",
            " 35  education_marriage_Other/Unknown_Unknown/Others    5993 non-null   float64\n",
            " 36  education_marriage_University_Married              5993 non-null   float64\n",
            " 37  education_marriage_University_Single               5993 non-null   float64\n",
            " 38  education_marriage_University_Unknown/Others       5993 non-null   float64\n",
            " 39  pay_delay_4_april                                  5993 non-null   float64\n",
            " 40  pay_delay_5_may                                    5993 non-null   float64\n",
            " 41  pay_delay_6_june                                   5993 non-null   float64\n",
            " 42  pay_delay_7_july                                   5993 non-null   float64\n",
            " 43  pay_delay_8_august                                 5993 non-null   float64\n",
            " 44  pay_delay_9_september                              5993 non-null   float64\n",
            " 45  education                                          5993 non-null   float64\n",
            " 46  education_and_marriage_unknown_flag                5993 non-null   float64\n",
            " 47  education_or_marriage_unknown_flag                 5993 non-null   float64\n",
            " 48  target                                             5993 non-null   int64  \n",
            "dtypes: float64(48), int64(1)\n",
            "memory usage: 2.2 MB\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3o1VV2ccDa1Z"
      },
      "source": [
        "#### Loan Data Utils"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I0n51ttV4A8y",
        "outputId": "70e73ad4-78fd-489a-f6b9-1efe70efbe55"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Script successfully written to loan_data_utils.py\n"
          ]
        }
      ],
      "source": [
        "script_content=r'''\n",
        "# loan_data_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",
        "import logging\n",
        "from sklearn.metrics import classification_report\n",
        "from sklearn.base import BaseEstimator, TransformerMixin, ClassifierMixin\n",
        "\n",
        "import json\n",
        "\n",
        "# Configure logging\n",
        "logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')\n",
        "\n",
        "# Define constants\n",
        "target = 'default_payment_next_month'\n",
        "\n",
        "# ------  Define columns  --------- #\n",
        "\n",
        "# column lists from loan data utils\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",
        "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",
        "categorical_columns = ['sex', 'marriage']\n",
        "ordinal_columns = delay_columns + ['education']\n",
        "\n",
        "# ---------  Load Data  --------- #\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",
        "            # 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",
        "\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) # leave as numeric for modeling\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",
        "\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",
        "ord_cols = [\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_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(ord_cols, 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, ClassifierMixin):\n",
        "    def __init__(self, base_classifier=None, threshold=0.5):\n",
        "        # Default to LogisticRegression if no classifier is provided\n",
        "        self.base_classifier = base_classifier if base_classifier is not None else LogisticRegression(max_iter=1000)\n",
        "        self.threshold = threshold\n",
        "\n",
        "    def fit(self, X, y):\n",
        "        # Fit the base classifier on the training data\n",
        "        self.base_classifier.fit(X, y)\n",
        "        return self\n",
        "\n",
        "    def predict(self, X):\n",
        "        # Get the predicted probabilities for class 1 (positive class)\n",
        "        probas = self.base_classifier.predict_proba(X)[:, 1]\n",
        "        # Apply the threshold to make class predictions\n",
        "        return (probas >= self.threshold).astype(int)\n",
        "\n",
        "    def predict_proba(self, X):\n",
        "        # Return the predicted probabilities from the base classifier\n",
        "        return self.base_classifier.predict_proba(X)\n",
        "\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",
        "# 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"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ONYYdNCIMlxu"
      },
      "source": [
        "#### EDA Utils"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VOWzifWM6fRP",
        "outputId": "77f604af-cf72-474b-a667-61df91f32271"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Script successfully written to eda_utils.py\n"
          ]
        }
      ],
      "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 *"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XqAvpP5-XbHn"
      },
      "source": [
        "#### Data Transform Utils"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P0pD1L5wpiYv",
        "outputId": "c4bc618c-4a4a-4f27-f0c3-44360491e13a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "data_transformations_utils.py created successfully\n"
          ]
        }
      ],
      "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"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Feature Engineering Script"
      ],
      "metadata": {
        "id": "jTdy0ysdGptt"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p9TfChdMGhTF",
        "outputId": "d40e2b34-69c4-450a-89d4-a2bc8b4cf117"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Script successfully written to feature_engineering_pipeline_utils.py\n"
          ]
        }
      ],
      "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",
        "import numpy as np\n",
        "\n",
        "# -----------  Define the columns All Engineered Features ------------#\n",
        "\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",
        "#                     'rolling_avg_delay', 'education_risk_ratio', 'marriage_risk_ratio', 'education_woe', 'marriage_woe']\n",
        "\n",
        "# # Categorical Features (New categorical feature added)\n",
        "# categorical_features = ['sex', 'marriage', 'education_marriage', 'cumulative_delay_category']\n",
        "\n",
        "# # Ordinal Features\n",
        "# ordinal_features = delay_columns + ['education']\n",
        "\n",
        "# # Boolean Features (New flags added)\n",
        "# boolean_features = ['high_risk_delay', 'deferred_and_decreasing_payments', 'severe_deferred_and_decreasing_payments',\n",
        "#                     'severe_deferred_and_any_decreasing_payments', 'education_or_marriage_unknown_flag',\n",
        "#                     'education_and_marriage_unknown_flag']\n",
        "\n",
        "# -----------  Define the columns LogReg & RF Engineered Features ------------#\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",
        "# ------- Rolling Average Delay Transformer -------#\n",
        "\n",
        "class RollingAverageDelayTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns):\n",
        "        \"\"\"\n",
        "        Initialize the transformer with the columns to calculate the rolling average delay.\n",
        "        \"\"\"\n",
        "        self.delay_columns = delay_columns\n",
        "        # Embedded delay mapping inside the transformer\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",
        "        # No fitting necessary, so we simply return the transformer.\n",
        "        return self\n",
        "\n",
        "    def transform(self, X):\n",
        "        \"\"\"\n",
        "        Transforms the input DataFrame by calculating the rolling average delay,\n",
        "        without modifying the original delay columns.\n",
        "\n",
        "        Parameters:\n",
        "        - X: pandas DataFrame.\n",
        "\n",
        "        Returns:\n",
        "        - Transformed DataFrame with the original columns and an additional\n",
        "          'rolling_avg_delay' column.\n",
        "        \"\"\"\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Use apply with map for each column instead of applymap\n",
        "        delay_numeric = X[self.delay_columns].apply(lambda col: col.map(self.delay_mapping).astype(float))\n",
        "\n",
        "        # Handle potential missing values after mapping (optional)\n",
        "        delay_numeric = delay_numeric.fillna(0)\n",
        "\n",
        "        # Calculate the rolling average delay and add it as a new feature in the original DataFrame\n",
        "        X['rolling_avg_delay'] = delay_numeric.mean(axis=1)\n",
        "\n",
        "        return X  # Return the DataFrame with the original and new feature\n",
        "\n",
        "\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 CumulativeDelayTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, delay_columns):\n",
        "        self.delay_columns = delay_columns\n",
        "        # Embedded delay mapping inside the transformer\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",
        "        # No fitting necessary, so we simply return the transformer.\n",
        "        return self\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Create a new DataFrame for delay columns mapped to numeric values\n",
        "        # delay_numeric = X[self.delay_columns].applymap(self.delay_mapping.get).astype(float)\n",
        "        delay_numeric = X[self.delay_columns].apply(lambda col: col.map(self.delay_mapping).astype(float))\n",
        "\n",
        "\n",
        "        # Handle potential missing values after mapping (optional)\n",
        "        delay_numeric = delay_numeric.fillna(0)\n",
        "\n",
        "        # Generate the 'cumulative_delay' feature by summing the numeric values across the delay columns\n",
        "        X['cumulative_delay'] = delay_numeric.sum(axis=1)\n",
        "\n",
        "        # Return the original DataFrame with the new 'cumulative_delay' feature added\n",
        "        return X\n",
        "\n",
        "# ------- Cumulative Delay Binning Transformer -------#\n",
        "\n",
        "class CumulativeDelayBinningTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, column='cumulative_delay', bins=[-np.inf, 0, 5, 10, 15, np.inf], labels=['No Delay', 'Low Delay', 'Moderate Delay', 'High Delay', 'Severe Delay']):\n",
        "        self.column = column\n",
        "        self.bins = bins\n",
        "        self.labels = labels\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",
        "        # Apply binning to the cumulative_delay column\n",
        "        X['cumulative_delay_category'] = pd.cut(X[self.column], bins=self.bins, labels=self.labels, ordered=True)\n",
        "\n",
        "        # Return the updated DataFrame with the new 'cumulative_delay_category' column\n",
        "        return X\n",
        "\n",
        "\n",
        "# ------- Avg Payment Severe Delays 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",
        "        ).astype(int)\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",
        "# ------- 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",
        "# ------- 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",
        "# ------- Debt To Limit Ratio Transformer -------#\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",
        "# ------- 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",
        "#         X['education_marriage'] = X['education_marriage'].astype('category')\n",
        "\n",
        "#         return X\n",
        "\n",
        "\n",
        "# ------- Education & Marriage Interaction Transformer -------#\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",
        "        # Check if the column already exists to avoid overwriting\n",
        "        if 'education_marriage' in X.columns:\n",
        "            raise ValueError(\"Column 'education_marriage' already exists in the 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",
        "        X['education_marriage'] = X['education_marriage'].astype('category')\n",
        "\n",
        "        return X\n",
        "\n",
        "\n",
        "# ------- Education & Marriage Unknown Flag Transformer -------#\n",
        "\n",
        "# class EducationMarriageUnknownFlagTransformer(BaseEstimator, TransformerMixin):\n",
        "#     def __init__(self):\n",
        "#         pass\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",
        "#         # Feature for when either education or marriage is \"Other/Unknown\"\n",
        "#         X['education_or_marriage_unknown_flag'] = ((X['education'] == 'Other/Unknown') |\n",
        "#                                                    (X['marriage'] == 'Unknown/Others')).astype('bool')\n",
        "\n",
        "#         # Feature for when both education and marriage are \"Other/Unknown\"\n",
        "#         X['education_and_marriage_unknown_flag'] = ((X['education'] == 'Other/Unknown') &\n",
        "#                                                     (X['marriage'] == 'Unknown/Others')).astype('bool')\n",
        "\n",
        "#         return X\n",
        "\n",
        "# ------- Education & Marriage Unknown Flag Transformer -------#\n",
        "class EducationMarriageUnknownFlagTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self):\n",
        "        pass\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",
        "        # Check if the columns already exist to avoid overwriting\n",
        "        if 'education_or_marriage_unknown_flag' in X.columns or 'education_and_marriage_unknown_flag' in X.columns:\n",
        "            raise ValueError(\"One or both of the flag columns ('education_or_marriage_unknown_flag', 'education_and_marriage_unknown_flag') already exist in the DataFrame.\")\n",
        "\n",
        "        # Feature for when either education or marriage is \"Other/Unknown\"\n",
        "        X['education_or_marriage_unknown_flag'] = ((X['education'] == 'Other/Unknown') |\n",
        "                                                   (X['marriage'] == 'Unknown/Others')).astype('bool')\n",
        "\n",
        "        # Feature for when both education and marriage are \"Other/Unknown\"\n",
        "        X['education_and_marriage_unknown_flag'] = ((X['education'] == 'Other/Unknown') &\n",
        "                                                    (X['marriage'] == 'Unknown/Others')).astype('bool')\n",
        "\n",
        "        return X\n",
        "\n",
        "\n",
        "# ------- Risk Ratio Transformer -------#\n",
        "\n",
        "class RiskRatioTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, education_col='education', marriage_col='marriage'):\n",
        "        self.education_col = education_col\n",
        "        self.marriage_col = marriage_col\n",
        "        self.education_default_rates = None\n",
        "        self.marriage_default_rates = None\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        if y is None:\n",
        "            raise ValueError(\"Target variable 'y' is required for fit.\")\n",
        "\n",
        "        X = X.copy()\n",
        "        X['target'] = y  # Add the target values to X temporarily\n",
        "\n",
        "        # Calculate the default rates based on the target\n",
        "        self.education_default_rates = X.groupby(self.education_col, observed=True)['target'].mean()\n",
        "        self.marriage_default_rates = X.groupby(self.marriage_col, observed=True)['target'].mean()\n",
        "\n",
        "        return self\n",
        "\n",
        "    def transform(self, X):\n",
        "        X = X.copy()\n",
        "\n",
        "        # Convert categorical columns to object type to avoid issues with adding new categories\n",
        "        X[self.education_col] = X[self.education_col].astype(object)\n",
        "        X[self.marriage_col] = X[self.marriage_col].astype(object)\n",
        "\n",
        "        # Map the default rates, filling NaN for unseen categories with a default value (e.g., 0 or the mean of the default rates)\n",
        "        X['education_risk_ratio'] = X[self.education_col].map(self.education_default_rates).fillna(0).astype(float)\n",
        "        X['marriage_risk_ratio'] = X[self.marriage_col].map(self.marriage_default_rates).fillna(0).astype(float)\n",
        "\n",
        "        # Drop the target column if it exists\n",
        "        if 'target' in X.columns:\n",
        "            X.drop(columns=['target'], inplace=True)\n",
        "\n",
        "        return X\n",
        "\n",
        "# ------- WoE & IV Transformer -------#\n",
        "\n",
        "class WoeIvTransformer(BaseEstimator, TransformerMixin):\n",
        "    def __init__(self, features, target_col):\n",
        "        self.features = features\n",
        "        self.target_col = target_col\n",
        "        self.woe_dict = {}  # To store WoE for each feature\n",
        "        self.iv_dict = {}   # To store IV for each feature\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        if y is None:\n",
        "            raise ValueError(\"Target variable 'y' is required for fit.\")\n",
        "\n",
        "        # Ensure `y` is a pandas Series\n",
        "        y = pd.Series(y, name=self.target_col)\n",
        "\n",
        "        for feature in self.features:\n",
        "            if feature not in X.columns:\n",
        "                raise ValueError(f\"Feature '{feature}' is not present in the DataFrame.\")\n",
        "\n",
        "            # Create a DataFrame from the feature in X and the target (y)\n",
        "            df = pd.DataFrame({feature: X[feature], self.target_col: y})\n",
        "\n",
        "            # Group by the feature and calculate counts and sums (events)\n",
        "            grouped = df.groupby(feature, observed=True)[self.target_col].agg(['count', 'sum'])\n",
        "\n",
        "            # Calculate non-events and rates\n",
        "            grouped['non_event'] = grouped['count'] - grouped['sum']\n",
        "            grouped['event_rate'] = grouped['sum'] / grouped['sum'].sum()\n",
        "            grouped['non_event_rate'] = grouped['non_event'] / grouped['non_event'].sum()\n",
        "\n",
        "            # Avoid division by zero in WoE calculation\n",
        "            grouped.replace({'event_rate': {0: 1e-6}, 'non_event_rate': {0: 1e-6}}, inplace=True)\n",
        "\n",
        "            # Calculate WoE and IV\n",
        "            grouped['woe'] = np.log(grouped['event_rate'] / grouped['non_event_rate'])\n",
        "            grouped['iv'] = (grouped['event_rate'] - grouped['non_event_rate']) * grouped['woe']\n",
        "\n",
        "            iv = grouped['iv'].sum()  # Total IV for the feature\n",
        "\n",
        "            # Store WoE and IV in dictionaries\n",
        "            self.woe_dict[feature] = grouped['woe']\n",
        "            self.iv_dict[feature] = iv\n",
        "\n",
        "        return self\n",
        "\n",
        "    def transform(self, X):\n",
        "        \"\"\"\n",
        "        Apply the WoE transformation to the given features in the DataFrame `X`\n",
        "        using the WoE values learned during `fit()`.\n",
        "        \"\"\"\n",
        "        X = X.copy()  # Avoid modifying the original DataFrame\n",
        "\n",
        "        # Map the WoE values to the features and add them as new columns\n",
        "        for feature in self.features:\n",
        "            if feature in self.woe_dict:\n",
        "                X[f'{feature}_woe'] = X[feature].map(self.woe_dict[feature]).fillna(0)\n",
        "\n",
        "        return X\n",
        "\n",
        "    def get_iv(self):\n",
        "        \"\"\"\n",
        "        Return the IV (Information Value) for each feature.\n",
        "        \"\"\"\n",
        "        return self.iv_dict\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# ------- Combined Feature Engineering Transformer for IMBPipeline -------#\n",
        "\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",
        "        # Add the target-dependent transformers here\n",
        "        self.risk_ratio_transformer = RiskRatioTransformer()\n",
        "        self.woe_iv_transformer = WoeIvTransformer(features=['education', 'marriage'], target_col='target')\n",
        "\n",
        "        # Track whether these transformers have been fitted\n",
        "        self.risk_ratio_fitted = False\n",
        "        self.woe_iv_fitted = False\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        \"\"\"\n",
        "        Fit all the transformers that require y here.\n",
        "        The target (y) is used for RiskRatioTransformer and WoeIvTransformer.\n",
        "        \"\"\"\n",
        "        # Fit the transformers that don't need y (some transformers may have fit methods)\n",
        "        # Other transformers like RollingAverageDelayTransformer may not require fit, so we can skip them\n",
        "\n",
        "        if y is not None:\n",
        "            self.risk_ratio_transformer.fit(X, y)  # Fit using X and y\n",
        "            self.woe_iv_transformer.fit(X, y)  # Fit using X and y\n",
        "            self.risk_ratio_fitted = True  # Mark that the transformer has been fitted\n",
        "            self.woe_iv_fitted = True  # Mark that the transformer has been fitted\n",
        "\n",
        "        return self\n",
        "\n",
        "    def transform(self, X, y=None):\n",
        "        \"\"\"\n",
        "        Apply all the transformations. This method should not depend on `y` during inference.\n",
        "        \"\"\"\n",
        "        # Apply transformations that do not require target (y)\n",
        "        X = RollingAverageDelayTransformer(self.delay_columns).transform(X)\n",
        "        X = HighRiskDelayFeatureTransformer(self.delay_columns).transform(X)\n",
        "        X = SevereDelayCountTransformer(self.delay_columns).transform(X)\n",
        "        X = CumulativeDelayTransformer(self.delay_columns).transform(X)\n",
        "        X = CumulativeDelayBinningTransformer().transform(X)\n",
        "\n",
        "        # Combine pay_columns and bill_columns for relevant transformations\n",
        "        X = SevereDelayPaymentRatioTransformer(self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = AvgPaymentSevereDelaysTransformer().transform(X)\n",
        "        X = DeferredAndDecreasingPaymentsTransformer(self.delay_columns, self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = SevereDeferredAndDecreasingPaymentsTransformer(self.delay_columns, self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = SevereDeferredAndAnyDecreasingPaymentsTransformer(self.delay_columns, self.pay_columns + self.bill_columns).transform(X)\n",
        "\n",
        "        X = TotalPaymentsTransformer(self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = AvgPaymentTransformer().transform(X)\n",
        "        X = PaymentStdTransformer(self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = WeightedPaymentSumTransformer(self.pay_columns + self.bill_columns).transform(X)\n",
        "\n",
        "        X = TotalBillsTransformer(self.bill_columns).transform(X)\n",
        "        X = DebtToLimitRatioTransformer(total_bills_column='total_bills', limit_bal_column='limit_bal').transform(X)\n",
        "        X = EducationMarriageInteractionTransformer().transform(X)\n",
        "        X = EducationMarriageUnknownFlagTransformer().transform(X)\n",
        "\n",
        "        # print('Before Risk Ratio', X.columns) # debug check\n",
        "\n",
        "        # Apply the learned transformations that depend on target (y) if they've been fitted\n",
        "        if self.risk_ratio_fitted:\n",
        "            X = self.risk_ratio_transformer.transform(X)  # Transform using the parameters learned in fit\n",
        "\n",
        "        # print('After Risk Ratio', X.columns) # debug check\n",
        "\n",
        "        if self.woe_iv_fitted:\n",
        "            X = self.woe_iv_transformer.transform(X)  # Transform using the parameters learned in fit\n",
        "\n",
        "        # print('Data after All Feature Engineering', X.columns) # debug check\n",
        "\n",
        "        return X\n",
        "\n",
        "\n",
        "# ------- Combined Feature Engineering Transformer for Logistic Regression -------#\n",
        "\n",
        "class CombinedFeatureEngineeringTransformer_LogisticRegression(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",
        "        # This method doesn't need to do anything for this transformer\n",
        "        return self\n",
        "\n",
        "    def transform(self, X, y=None):\n",
        "        # Apply only the necessary transformations for logistic regression\n",
        "        X = RollingAverageDelayTransformer(self.delay_columns).transform(X)\n",
        "        X = CumulativeDelayTransformer(self.delay_columns).transform(X)\n",
        "        X = CumulativeDelayBinningTransformer().transform(X)\n",
        "\n",
        "        return X\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# ------- Combined Feature Engineering Transformer for Tree-Based Models -------#\n",
        "\n",
        "class CombinedFeatureEngineeringTransformer_RandomForest(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",
        "        # Add the target-dependent transformers here\n",
        "        self.risk_ratio_transformer = RiskRatioTransformer()\n",
        "        self.woe_iv_transformer = WoeIvTransformer(features=['education', 'marriage'], target_col='target')\n",
        "\n",
        "        # Track whether these transformers have been fitted\n",
        "        self.risk_ratio_fitted = False\n",
        "        self.woe_iv_fitted = False\n",
        "\n",
        "    def fit(self, X, y=None):\n",
        "        if y is not None:\n",
        "            self.risk_ratio_transformer.fit(X, y)\n",
        "            self.woe_iv_transformer.fit(X, y)\n",
        "            self.risk_ratio_fitted = True\n",
        "            self.woe_iv_fitted = True\n",
        "        return self\n",
        "\n",
        "    def transform(self, X, y=None):\n",
        "        \"\"\"\n",
        "        Apply the selected transformations.\n",
        "        \"\"\"\n",
        "        # Only retain the required transformers\n",
        "        X = HighRiskDelayFeatureTransformer(self.delay_columns).transform(X)\n",
        "        X = SevereDelayCountTransformer(self.delay_columns).transform(X)\n",
        "        X = CumulativeDelayBinningTransformer().transform(X)  # Creates cumulative_delay_category_*\n",
        "        X = SevereDelayPaymentRatioTransformer(self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = AvgPaymentSevereDelaysTransformer().transform(X)\n",
        "        X = DeferredAndDecreasingPaymentsTransformer(self.delay_columns, self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = SevereDeferredAndDecreasingPaymentsTransformer(self.delay_columns, self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = SevereDeferredAndAnyDecreasingPaymentsTransformer(self.delay_columns, self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = TotalPaymentsTransformer(self.pay_columns + self.bill_columns).transform(X)\n",
        "        X = TotalBillsTransformer(self.bill_columns).transform(X)\n",
        "\n",
        "        # Apply the learned transformations that depend on target (y) if they've been fitted\n",
        "        if self.risk_ratio_fitted:\n",
        "            X = self.risk_ratio_transformer.transform(X)\n",
        "        if self.woe_iv_fitted:\n",
        "            X = self.woe_iv_transformer.transform(X)\n",
        "\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 *"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Feature Selection Script"
      ],
      "metadata": {
        "id": "I3L0w6TkqNZ2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "script_content = \"\"\"\n",
        "\n",
        "import json\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.base import BaseEstimator, TransformerMixin\n",
        "\n",
        "# Helper function to save classification reports and selected features to JSON files\n",
        "def save_results_to_json(results_dict, features_dict, method_name, classification_report, selected_features):\n",
        "    # Load existing results if available\n",
        "    try:\n",
        "        with open('classification_reports.json', 'r') as f:\n",
        "            results_dict.update(json.load(f))\n",
        "        with open('selected_features.json', 'r') as f:\n",
        "            features_dict.update(json.load(f))\n",
        "    except FileNotFoundError:\n",
        "        pass  # Files don't exist yet, which is fine for the first run\n",
        "\n",
        "    # Add new method results\n",
        "    results_dict[method_name] = classification_report\n",
        "    features_dict[method_name] = selected_features\n",
        "\n",
        "    # Save the updated results\n",
        "    with open('classification_reports.json', 'w') as f:\n",
        "        json.dump(results_dict, f, indent=4)\n",
        "\n",
        "    with open('selected_features.json', 'w') as f:\n",
        "        json.dump(features_dict, f, indent=4)\n",
        "\n",
        "#--------   Plot Selected Features  --------#\n",
        "\n",
        "def plot_selected_features(selected_features, model_name, figsize=(16,16)):\n",
        "\n",
        "    sns.set_theme(\"notebook\")\n",
        "    sns.set_style(\"ticks\")\n",
        "    features = list(selected_features.keys())\n",
        "    importances = list(selected_features.values())\n",
        "    plt.figure(figsize=figsize)\n",
        "    sns.barplot(x=importances, y=features, hue=importances, palette='viridis')\n",
        "    plt.title(f'Selected Features and their Importance for {model_name}')\n",
        "    plt.xlabel('Importance')\n",
        "    plt.ylabel('')\n",
        "    plt.legend(loc='lower right')\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "# -----  Plot Classification Report Comparison ------#\n",
        "\n",
        "def plot_comparison_classification_metrics_seaborn(reports, model_names):\n",
        "    '''\n",
        "    Plots Precision, Recall, and F1-score comparisons for multiple filter methods using Seaborn barplots.\n",
        "\n",
        "    Args:\n",
        "    - reports: A list of classification reports (dict format).\n",
        "    - model_names: A list of model names corresponding to the reports.\n",
        "    '''\n",
        "    # Initialize lists to collect metric values for each model\n",
        "    precision_values = []\n",
        "    recall_values = []\n",
        "    f1_values = []\n",
        "\n",
        "    # For each report, extract the values for Precision, Recall, and F1-score (for both classes)\n",
        "    for report in reports:\n",
        "        precision_values.append([\n",
        "            report['0']['precision'],  # Class 0 (No Default)\n",
        "            report['1']['precision']   # Class 1 (Default)\n",
        "        ])\n",
        "        recall_values.append([\n",
        "            report['0']['recall'],     # Class 0 (No Default)\n",
        "            report['1']['recall']      # Class 1 (Default)\n",
        "        ])\n",
        "        f1_values.append([\n",
        "            report['0']['f1-score'],   # Class 0 (No Default)\n",
        "            report['1']['f1-score']    # Class 1 (Default)\n",
        "        ])\n",
        "\n",
        "    # Convert to DataFrame for easy plotting\n",
        "    df_precision = pd.DataFrame(precision_values, columns=['No Default', 'Default'], index=model_names).reset_index()\n",
        "    df_recall = pd.DataFrame(recall_values, columns=['No Default', 'Default'], index=model_names).reset_index()\n",
        "    df_f1 = pd.DataFrame(f1_values, columns=['No Default', 'Default'], index=model_names).reset_index()\n",
        "\n",
        "    # Melt the DataFrames for seaborn\n",
        "    df_precision_melt = df_precision.melt(id_vars='index', var_name='Class', value_name='Precision')\n",
        "    df_recall_melt = df_recall.melt(id_vars='index', var_name='Class', value_name='Recall')\n",
        "    df_f1_melt = df_f1.melt(id_vars='index', var_name='Class', value_name='F1-score')\n",
        "\n",
        "    # Set up the subplots (1x3 grid)\n",
        "    fig, axes = plt.subplots(1, 3, figsize=(12, 8))\n",
        "\n",
        "    # Plot Precision\n",
        "    sns.barplot(x='index', y='Precision', hue='Class', data=df_precision_melt, ax=axes[0])\n",
        "    axes[0].set_title('Precision Comparison')\n",
        "    axes[0].set_ylim(0, 1)\n",
        "    axes[0].set_ylabel('Score')\n",
        "    # axes[0].set_xlabel('Filter Method')\n",
        "    axes[0].legend(loc='lower right')\n",
        "    axes[0].tick_params(axis='x', rotation=90)  # Rotate x-ticks\n",
        "\n",
        "    # Plot Recall\n",
        "    sns.barplot(x='index', y='Recall', hue='Class', data=df_recall_melt, ax=axes[1])\n",
        "    axes[1].set_title('Recall Comparison')\n",
        "    axes[1].set_ylim(0, 1)\n",
        "    axes[1].set_ylabel('Score')\n",
        "    # axes[1].set_xlabel('Filter Method')\n",
        "    axes[1].legend(loc='lower right')\n",
        "    axes[1].tick_params(axis='x', rotation=90)  # Rotate x-ticks\n",
        "\n",
        "    # Plot F1-score\n",
        "    sns.barplot(x='index', y='F1-score', hue='Class', data=df_f1_melt, ax=axes[2])\n",
        "    axes[2].set_title('F1-score Comparison')\n",
        "    axes[2].set_ylim(0, 1)\n",
        "    axes[2].set_ylabel('Score')\n",
        "    # axes[2].set_xlabel('Filter Method')\n",
        "    axes[2].legend(loc='lower right')\n",
        "    axes[2].tick_params(axis='x', rotation=90)  # Rotate x-ticks\n",
        "\n",
        "    # Set the overall title for the figure\n",
        "    plt.suptitle('Classification Report Metric Comparison Across Filter Methods', fontsize=16)\n",
        "\n",
        "    # Adjust layout\n",
        "    plt.tight_layout(rect=[0, 0, 1, 0.95])\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "# Write the script to a file\n",
        "with open(\"feature_selection_utils.py\", \"w\") as file:\n",
        "    file.write(script_content)\n",
        "\n",
        "print(\"Script successfully written to feature_selection_utils.py\")\n",
        "# Reload script to make functions available for use\n",
        "import importlib\n",
        "import feature_selection_utils\n",
        "importlib.reload(feature_selection_utils)\n",
        "\n",
        "from feature_selection_utils import *"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jpE14ST6qQIB",
        "outputId": "82927d30-8e36-4bd7-c129-6d794bf042fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Script successfully written to feature_selection_utils.py\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cU9U02Y5CpJ7"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNENM9uo0XCcYq9aWYxgDQZ",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}