home-credit-baseline-polars-lightgbm.ipynb

{"cells":[{"source":"<a href=\"https://www.kaggle.com/code/syerramilli/home-credit-baseline-polars-lightgbm?scriptVersionId=177079370\" target=\"_blank\"><img align=\"left\" alt=\"Kaggle\" title=\"Open in Kaggle\" src=\"https://kaggle.com/static/images/open-in-kaggle.svg\"></a>","metadata":{},"cell_type":"markdown"},{"cell_type":"markdown","id":"8a8b4d8f","metadata":{"papermill":{"duration":0.008446,"end_time":"2024-05-11T16:52:13.98645","exception":false,"start_time":"2024-05-11T16:52:13.978004","status":"completed"},"tags":[]},"source":["## Introduction\n","\n","In this notebook, we will be building a basline model for the Home Credit Kaggle competition. The goal of this competition is to predict the probability of a client defaulting on a loan. Since the dataset is quite large, we will be using Polars to load and process the data. \n","\n","\n","**CHANGELOG**:\n","\n","v4 -> v5:\n","Re-running on modified dataset.\n","\n","v3 -> v4:\n","1. Added min and mean as aggregate statistics in addition to max for tables with depth >= 1\n","2. Added a preliminary EDA section. \n"]},{"cell_type":"code","execution_count":1,"id":"700339bb","metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","execution":{"iopub.execute_input":"2024-05-11T16:52:14.004728Z","iopub.status.busy":"2024-05-11T16:52:14.003824Z","iopub.status.idle":"2024-05-11T16:52:19.444061Z","shell.execute_reply":"2024-05-11T16:52:19.44306Z"},"papermill":{"duration":5.451753,"end_time":"2024-05-11T16:52:19.446389","exception":false,"start_time":"2024-05-11T16:52:13.994636","status":"completed"},"tags":[]},"outputs":[],"source":["import os\n","import gc\n","from glob import glob\n","from pathlib import Path\n","\n","import numpy as np\n","import pandas as pd\n","import polars as pl\n","import matplotlib.pyplot as plt\n","import seaborn as sns\n","\n","\n","import lightgbm as lgb\n","from sklearn.metrics import roc_auc_score\n","from sklearn.model_selection import StratifiedGroupKFold\n","\n","from typing import List\n","\n","plt.style.use('ggplot')\n","plt.rcParams.update({'figure.dpi':150})"]},{"cell_type":"markdown","id":"db13f6b3","metadata":{"papermill":{"duration":0.007972,"end_time":"2024-05-11T16:52:19.462668","exception":false,"start_time":"2024-05-11T16:52:19.454696","status":"completed"},"tags":[]},"source":["## Loading the data\n","\n","\n","1. We will be using the parquet files provided by the competition. The parquet files are stored in the `parquet_files` directory. The `train` and `test` directories contain the training and testing data, respectively. \n","2. We use the Lazy API to read the parquet files using `scan_parquet`. This allows for efficient reading of the data and also allows us to perform operations on the data without loading it into memory until necessary. "]},{"cell_type":"code","execution_count":2,"id":"1040e319","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:52:19.47947Z","iopub.status.busy":"2024-05-11T16:52:19.479179Z","iopub.status.idle":"2024-05-11T16:52:19.483253Z","shell.execute_reply":"2024-05-11T16:52:19.482424Z"},"papermill":{"duration":0.014861,"end_time":"2024-05-11T16:52:19.485315","exception":false,"start_time":"2024-05-11T16:52:19.470454","status":"completed"},"tags":[]},"outputs":[],"source":["TRAIN_DIR = Path('/kaggle/input/home-credit-credit-risk-model-stability/parquet_files/train/')\n","TEST_DIR = Path('/kaggle/input/home-credit-credit-risk-model-stability/parquet_files/test/')"]},{"cell_type":"code","execution_count":3,"id":"970bd8c1","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:52:19.502019Z","iopub.status.busy":"2024-05-11T16:52:19.501782Z","iopub.status.idle":"2024-05-11T16:52:19.514565Z","shell.execute_reply":"2024-05-11T16:52:19.51369Z"},"papermill":{"duration":0.023272,"end_time":"2024-05-11T16:52:19.516433","exception":false,"start_time":"2024-05-11T16:52:19.493161","status":"completed"},"tags":[]},"outputs":[],"source":["def correct_dtypes(df: pl.LazyFrame) -> pl.LazyFrame:\n","    for column in df.columns:\n","        if column in {'case_id', 'WEEK_NUM', 'num_group1', 'num_group2'}:\n","            df = df.with_columns(pl.col(column).cast(pl.Int64))\n","        elif column == 'date_decision' or column[-1] == 'D':\n","            df = df.with_columns(pl.col(column).cast(pl.Date))\n","        elif column[-1] in {'A', 'P'}:\n","            df = df.with_columns(pl.col(column).cast(pl.Float64))\n","        elif column[-1] == 'M':\n","            df = df.with_columns(pl.col(column).cast(pl.String))\n","        \n","    return df    \n","\n","\n","def aggregate_exprs(df: pl.LazyFrame) -> List:\n","    '''\n","    Create aggregate expressions for tables with depth > 1. The\n","    actual aggreation is done elsewhere following a groupby statement.\n","\n","    TODO: Currently only supports max aggregation. Add more expressions.\n","    '''\n","    \n","    exprs = []\n","    for column in df.columns:\n","        if column[-1] in {'D', 'A', 'P'}:\n","            # dates or numerical\n","            exprs += [\n","                pl.max(column).alias(f'max_{column}'),\n","                pl.min(column).alias(f'min_{column}'),\n","                pl.mean(column).alias(f'mean_{column}')\n","            ]\n","        # TODO: add more expressions\n","    \n","    return exprs\n","\n","\n","def read_file(path, depth:int=None) -> pl.LazyFrame:\n","    '''\n","    Read a parquet file and return a polars dataframe. If depth >= 1,\n","    then the dataframe is grouped by case_id and aggregated.\n","    '''\n","    df = pl.scan_parquet(path).pipe(correct_dtypes)\n","    \n","    if depth in {1, 2}:\n","        df = df.group_by('case_id').agg(aggregate_exprs(df))\n","    \n","    return df\n","\n","def read_files(regex_path, depth:int=None) -> pl.LazyFrame:\n","    '''\n","    Read all parquet files matching the regex pattern and \n","    concatenate them into a single dataframe. If depth >= 1,\n","    then the dataframe is grouped by case_id and aggregated.\n","    '''\n","\n","    chunks = []\n","    for path in glob(str(regex_path)):\n","        chunks.append(\n","            pl.scan_parquet(path).pipe(correct_dtypes)\n","        )\n","\n","    df = pl.concat(chunks, how='vertical_relaxed')\n","    if depth in {1, 2}:\n","        df = df.group_by('case_id').agg(aggregate_exprs(df))\n","    \n","    return df"]},{"cell_type":"code","execution_count":4,"id":"9f5a6f42","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:52:19.533648Z","iopub.status.busy":"2024-05-11T16:52:19.533367Z","iopub.status.idle":"2024-05-11T16:52:19.769366Z","shell.execute_reply":"2024-05-11T16:52:19.768556Z"},"papermill":{"duration":0.247451,"end_time":"2024-05-11T16:52:19.771646","exception":false,"start_time":"2024-05-11T16:52:19.524195","status":"completed"},"tags":[]},"outputs":[],"source":["# Credit: https://www.kaggle.com/code/greysky/home-credit-baseline\n","data_stores = {\n","    \"df_base\": read_file(TRAIN_DIR / \"train_base.parquet\"),\n","    \"other_dfs\": [\n","        # depth 0\n","        read_file(TRAIN_DIR / \"train_static_cb_0.parquet\"),\n","        read_files(TRAIN_DIR / \"train_static_0_*.parquet\"),\n","        # depth 1\n","        read_files(TRAIN_DIR / \"train_applprev_1_*.parquet\", 1),\n","        read_file(TRAIN_DIR / \"train_tax_registry_a_1.parquet\", 1),\n","        read_file(TRAIN_DIR / \"train_tax_registry_b_1.parquet\", 1),\n","        read_file(TRAIN_DIR / \"train_tax_registry_c_1.parquet\", 1),\n","        read_file(TRAIN_DIR / \"train_credit_bureau_b_1.parquet\", 1),\n","        read_file(TRAIN_DIR / \"train_other_1.parquet\", 1),\n","        read_file(TRAIN_DIR / \"train_person_1.parquet\", 1),\n","        read_file(TRAIN_DIR / \"train_deposit_1.parquet\", 1),\n","        read_file(TRAIN_DIR / \"train_debitcard_1.parquet\", 1),\n","        # depth 2\n","        read_file(TRAIN_DIR / \"train_credit_bureau_b_2.parquet\", 2),\n","    ]\n","}"]},{"cell_type":"markdown","id":"a7690c1b","metadata":{"papermill":{"duration":0.008942,"end_time":"2024-05-11T16:52:19.789068","exception":false,"start_time":"2024-05-11T16:52:19.780126","status":"completed"},"tags":[]},"source":["We will now merge the dataframes to create one full training set. "]},{"cell_type":"code","execution_count":5,"id":"2f60ae61","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:52:19.806604Z","iopub.status.busy":"2024-05-11T16:52:19.805963Z","iopub.status.idle":"2024-05-11T16:52:19.815127Z","shell.execute_reply":"2024-05-11T16:52:19.814217Z"},"papermill":{"duration":0.020038,"end_time":"2024-05-11T16:52:19.817134","exception":false,"start_time":"2024-05-11T16:52:19.797096","status":"completed"},"tags":[]},"outputs":[],"source":["def datediff_col_exprs(date_columns):\n","    exprs = []\n","    for column in date_columns:\n","        exprs.append(\n","            (pl.col(column) - pl.col('date_decision')).dt.total_days().alias(f'days_from_decision_{column}')\n","        )\n","    \n","    return exprs\n","\n","def merge_and_basic_fe(df_base, other_dfs:List[pl.LazyFrame]):\n","    '''\n","    Combine the data and add some preliminary feature engineering\n","    '''\n","    \n","    # add month and weekday columns for decision dates\n","    df_base = (\n","        df_base\n","        # the MONTH seems to the same as date_decision without delimiters\n","        .drop('MONTH') \n","        .with_columns(\n","            MONTH_NUM=pl.col('date_decision').dt.month(),\n","            WEEKDAY_NUM=pl.col('date_decision').dt.weekday(),\n","        )\n","    )\n","\n","    # merge the other dataframes\n","    for i, df in enumerate(other_dfs):\n","        df_base = df_base.join(df, on='case_id', how='left', suffix=f'_{i}')\n","    \n","    # Create a new column for each date column that represents the number of \n","    # days from the decision date. The orginal date column is then dropped.\n","    schema = df_base.schema\n","    date_columns = [column for column in schema if schema[column] == pl.Date]\n","    df_base = (\n","        df_base\n","        .with_columns(datediff_col_exprs(date_columns))\n","        .drop(date_columns)\n","        .drop('date_decision')\n","    )\n","    \n","    return df_base.with_columns(pl.col('opencred_647L').cast(pl.Int32))"]},{"cell_type":"code","execution_count":6,"id":"e2a10bb0","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:52:19.834583Z","iopub.status.busy":"2024-05-11T16:52:19.833877Z","iopub.status.idle":"2024-05-11T16:52:19.846609Z","shell.execute_reply":"2024-05-11T16:52:19.845703Z"},"papermill":{"duration":0.023568,"end_time":"2024-05-11T16:52:19.848741","exception":false,"start_time":"2024-05-11T16:52:19.825173","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Number of columns........: 429\n"]}],"source":["df_train = merge_and_basic_fe(**data_stores)\n","schema = df_train.schema\n","print(f'Number of columns........: {len(schema)}')"]},{"cell_type":"code","execution_count":7,"id":"94ba8808","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:52:19.865823Z","iopub.status.busy":"2024-05-11T16:52:19.865543Z","iopub.status.idle":"2024-05-11T16:52:24.396537Z","shell.execute_reply":"2024-05-11T16:52:24.39553Z"},"papermill":{"duration":4.541688,"end_time":"2024-05-11T16:52:24.398635","exception":false,"start_time":"2024-05-11T16:52:19.856947","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Number of observations...: 1526659\n"]}],"source":["# We haven't actually run anything until this step\n","# We need to read in the data to calculate the number of observations\n","# With Lazy API, polars will optimize the amount of data read into memory\n","num_obs = df_train.select(pl.len()).collect(streaming=True).item()\n","\n","print(f'Number of observations...: {num_obs}')"]},{"cell_type":"markdown","id":"d2e7f744","metadata":{"papermill":{"duration":0.008084,"end_time":"2024-05-11T16:52:24.415179","exception":false,"start_time":"2024-05-11T16:52:24.407095","status":"completed"},"tags":[]},"source":["We will drop columns with missing values."]},{"cell_type":"code","execution_count":8,"id":"e9ad153d","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:52:24.43296Z","iopub.status.busy":"2024-05-11T16:52:24.4324Z","iopub.status.idle":"2024-05-11T16:53:47.129793Z","shell.execute_reply":"2024-05-11T16:53:47.128721Z"},"papermill":{"duration":82.716825,"end_time":"2024-05-11T16:53:47.140024","exception":false,"start_time":"2024-05-11T16:52:24.423199","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Number of colums with > 50% missing values: 235\n","Number of columns after dropping: 194\n"]}],"source":["# 1. Compute the number of missing values in each column and compute the percentages\n","# this op takes time to compute since we need to actually perform\n","# operations on the entire training set\n","missing_perc = df_train.null_count().collect(streaming=True) / num_obs * 100\n","\n","# 2. Get a list of all columns with missing value percentages greater than 50%\n","columns_to_drop = [col for col in missing_perc.columns if missing_perc[col][0] > 50]\n","print(f'Number of colums with > 50% missing values: {len(columns_to_drop)}')\n","\n","# 3. Drop these columns from the training set\n","df_train = df_train.drop(columns_to_drop)\n","schema = df_train.schema\n","print(f'Number of columns after dropping: {len(schema)}')"]},{"cell_type":"markdown","id":"dad175ac","metadata":{"papermill":{"duration":0.008127,"end_time":"2024-05-11T16:53:47.156412","exception":false,"start_time":"2024-05-11T16:53:47.148285","status":"completed"},"tags":[]},"source":["There are some columns which are categorical. We will drop columns that have only 1 unique value or have way too many unique values"]},{"cell_type":"code","execution_count":9,"id":"19f20569","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:53:47.174145Z","iopub.status.busy":"2024-05-11T16:53:47.173473Z","iopub.status.idle":"2024-05-11T16:55:09.767259Z","shell.execute_reply":"2024-05-11T16:55:09.766232Z"},"papermill":{"duration":82.612766,"end_time":"2024-05-11T16:55:09.777365","exception":false,"start_time":"2024-05-11T16:53:47.164599","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Number of columns after dropping: 188\n"]}],"source":["cat_columns_to_drop = []\n","for column in schema:\n","    if schema[column] == pl.String:\n","        # get frequency \n","        freq = df_train.select(column).unique().select(pl.len()).collect(streaming=True).item()\n","        \n","        if freq == 1 or freq > 20:\n","            cat_columns_to_drop.append(column)\n","\n","# drop these columns\n","df_train = df_train.drop(cat_columns_to_drop)\n","\n","schema = df_train.schema\n","print(f'Number of columns after dropping: {len(schema)}')"]},{"cell_type":"markdown","id":"12f3a6cc","metadata":{"papermill":{"duration":0.008101,"end_time":"2024-05-11T16:55:09.793982","exception":false,"start_time":"2024-05-11T16:55:09.785881","status":"completed"},"tags":[]},"source":["## EDA\n","\n","The goal of the classification task is to predict the probability of a client defaulting on a loan. We will start by looking at the distribution of the target variable. There is a severe class imbalance in the target variable, with the majority class being the non-default class with about a 97% share of the data. "]},{"cell_type":"code","execution_count":10,"id":"e28c7512","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:55:09.81237Z","iopub.status.busy":"2024-05-11T16:55:09.812088Z","iopub.status.idle":"2024-05-11T16:55:13.714299Z","shell.execute_reply":"2024-05-11T16:55:13.713417Z"},"papermill":{"duration":3.914083,"end_time":"2024-05-11T16:55:13.716271","exception":false,"start_time":"2024-05-11T16:55:09.802188","status":"completed"},"tags":[]},"outputs":[{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>count</th>\n","      <th>percentage</th>\n","    </tr>\n","    <tr>\n","      <th>target</th>\n","      <th></th>\n","      <th></th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>1</th>\n","      <td>47994</td>\n","      <td>3.143728</td>\n","    </tr>\n","    <tr>\n","      <th>0</th>\n","      <td>1478665</td>\n","      <td>96.856272</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["          count  percentage\n","target                     \n","1         47994    3.143728\n","0       1478665   96.856272"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["target_dist = (\n","    df_train\n","    .group_by('target')\n","    .agg(pl.count('target').alias('count'))\n","    .collect(streaming=True)\n","    .with_columns(\n","        percentage = pl.col('count') / pl.col('count').sum() * 100\n","    )\n","    .to_pandas()\n","    .set_index('target')\n",")\n","target_dist"]},{"cell_type":"markdown","id":"7d7c1776","metadata":{"papermill":{"duration":0.008316,"end_time":"2024-05-11T16:55:13.733129","exception":false,"start_time":"2024-05-11T16:55:13.724813","status":"completed"},"tags":[]},"source":["By week number, we can see that the overall default rate in the training data fluctuates around 3% with some weeks having a default rate of 5% or more. There is no clear trend in the default rate over time. "]},{"cell_type":"code","execution_count":11,"id":"1e34f104","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:55:13.751363Z","iopub.status.busy":"2024-05-11T16:55:13.750605Z","iopub.status.idle":"2024-05-11T16:55:15.794093Z","shell.execute_reply":"2024-05-11T16:55:15.793084Z"},"papermill":{"duration":2.055672,"end_time":"2024-05-11T16:55:15.797089","exception":false,"start_time":"2024-05-11T16:55:13.741417","status":"completed"},"tags":[]},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 750x450 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n","(\n","    df_train\n","    .group_by('WEEK_NUM')\n","    .agg(pl.mean('target') * 100)\n","    .collect()\n","    .sort(by='WEEK_NUM')\n","    .to_pandas()\n","    .plot(kind='line', x='WEEK_NUM', y='target', ax=ax, legend=False)\n",")\n","\n","_ = ax.axhline(y=target_dist.loc[1, 'percentage'], color='k', linestyle='--', zorder=0)\n","_ = ax.set_ylabel('Default percentage')"]},{"cell_type":"markdown","id":"ca5ea8ae","metadata":{"papermill":{"duration":0.01036,"end_time":"2024-05-11T16:55:15.817965","exception":false,"start_time":"2024-05-11T16:55:15.807605","status":"completed"},"tags":[]},"source":["The number of queries to the credit bureau seems to have a positive relationship with the default rate. The default rate increases as the number of queries increases."]},{"cell_type":"code","execution_count":12,"id":"1f9049c0","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:55:15.840148Z","iopub.status.busy":"2024-05-11T16:55:15.83981Z","iopub.status.idle":"2024-05-11T16:55:20.223242Z","shell.execute_reply":"2024-05-11T16:55:20.222373Z"},"papermill":{"duration":4.397132,"end_time":"2024-05-11T16:55:20.225509","exception":false,"start_time":"2024-05-11T16:55:15.828377","status":"completed"},"tags":[]},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 900x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n","(\n","    df_train\n","    .group_by('numberofqueries_373L')\n","    .agg(default_perc = pl.mean('target') * 100, n_obs = pl.len())\n","    .collect(streaming=True)\n","    .filter(pl.col('n_obs') > 250)\n","    .sort(by='numberofqueries_373L')\n","    .to_pandas()\n","    .plot(kind='line', x='numberofqueries_373L', y='default_perc', ax=ax, legend=False)\n",")\n","\n","_ = ax.axhline(y=target_dist.loc[1, 'percentage'], color='k', linestyle='--', zorder=0)\n","_ = ax.set_ylabel('Default percentage')\n","_ = ax.set_xlabel('Number of queries to credit bureau')"]},{"cell_type":"markdown","id":"6e742ae5","metadata":{"papermill":{"duration":0.009507,"end_time":"2024-05-11T16:55:20.245019","exception":false,"start_time":"2024-05-11T16:55:20.235512","status":"completed"},"tags":[]},"source":["Note that in the plot above, we filtered out the number of queries that have less than 250 observations. All the filtered out cases have the number of queries > 37 (which is a lot).  Including these observations made the plot unreadable as there was too much noise - in some cases there were only 1 or 2 observations and these are likely to be outliers. To handle this, we will clip the number of queries at 38."]},{"cell_type":"code","execution_count":13,"id":"2206665e","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:55:20.265423Z","iopub.status.busy":"2024-05-11T16:55:20.265138Z","iopub.status.idle":"2024-05-11T16:55:20.271394Z","shell.execute_reply":"2024-05-11T16:55:20.27058Z"},"papermill":{"duration":0.018869,"end_time":"2024-05-11T16:55:20.273434","exception":false,"start_time":"2024-05-11T16:55:20.254565","status":"completed"},"tags":[]},"outputs":[],"source":["df_train = df_train.with_columns(\n","    numberofqueries_373L = (\n","        pl.when(pl.col('numberofqueries_373L') > 38).then(38)\n","        .otherwise(pl.col('numberofqueries_373L'))\n","    )\n",")"]},{"cell_type":"markdown","id":"80c36795","metadata":{"papermill":{"duration":0.009503,"end_time":"2024-05-11T16:55:20.293021","exception":false,"start_time":"2024-05-11T16:55:20.283518","status":"completed"},"tags":[]},"source":["## Convert to pandas\n","\n","We will convert the polars LazyFrame to a pandas DataFrame. As far as I know, lightgbm cannot directly process polars dataframes as of yet. Since some of the columns are categorical, we might need additional type processing for these columns"]},{"cell_type":"code","execution_count":14,"id":"6ffa1da2","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:55:20.313956Z","iopub.status.busy":"2024-05-11T16:55:20.313636Z","iopub.status.idle":"2024-05-11T16:55:38.352918Z","shell.execute_reply":"2024-05-11T16:55:38.352043Z"},"papermill":{"duration":18.052249,"end_time":"2024-05-11T16:55:38.355156","exception":false,"start_time":"2024-05-11T16:55:20.302907","status":"completed"},"tags":[]},"outputs":[],"source":["categorical_cols = [column for column in schema if schema[column] == pl.String]\n","# expensive step: since \n","df_train = df_train.collect().to_pandas()\n","df_train[categorical_cols] = df_train[categorical_cols].astype('category')"]},{"cell_type":"code","execution_count":15,"id":"20c3bd24","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:55:38.376821Z","iopub.status.busy":"2024-05-11T16:55:38.376472Z","iopub.status.idle":"2024-05-11T16:55:38.484441Z","shell.execute_reply":"2024-05-11T16:55:38.483465Z"},"papermill":{"duration":0.121061,"end_time":"2024-05-11T16:55:38.486356","exception":false,"start_time":"2024-05-11T16:55:38.365295","status":"completed"},"tags":[]},"outputs":[],"source":["# garbage collection\n","del data_stores\n","\n","_ = gc.collect()"]},{"cell_type":"code","execution_count":16,"id":"4a5a79b7","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:55:38.507331Z","iopub.status.busy":"2024-05-11T16:55:38.507041Z","iopub.status.idle":"2024-05-11T16:55:38.533329Z","shell.execute_reply":"2024-05-11T16:55:38.532456Z"},"papermill":{"duration":0.038891,"end_time":"2024-05-11T16:55:38.535352","exception":false,"start_time":"2024-05-11T16:55:38.496461","status":"completed"},"tags":[]},"outputs":[{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>case_id</th>\n","      <th>WEEK_NUM</th>\n","      <th>target</th>\n","      <th>MONTH_NUM</th>\n","      <th>WEEKDAY_NUM</th>\n","      <th>days120_123L</th>\n","      <th>days180_256L</th>\n","      <th>days30_165L</th>\n","      <th>days360_512L</th>\n","      <th>days90_310L</th>\n","      <th>...</th>\n","      <th>days_from_decision_mean_dtlastpmtallstes_3545839D</th>\n","      <th>days_from_decision_max_employedfrom_700D</th>\n","      <th>days_from_decision_min_employedfrom_700D</th>\n","      <th>days_from_decision_mean_employedfrom_700D</th>\n","      <th>days_from_decision_max_firstnonzeroinstldate_307D</th>\n","      <th>days_from_decision_min_firstnonzeroinstldate_307D</th>\n","      <th>days_from_decision_mean_firstnonzeroinstldate_307D</th>\n","      <th>days_from_decision_max_birth_259D</th>\n","      <th>days_from_decision_min_birth_259D</th>\n","      <th>days_from_decision_mean_birth_259D</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>4</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>...</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>-11874</td>\n","      <td>-11874</td>\n","      <td>-11874</td>\n","    </tr>\n","    <tr>\n","      <th>1</th>\n","      <td>1</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>4</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>...</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>-22435</td>\n","      <td>-22435</td>\n","      <td>-22435</td>\n","    </tr>\n","    <tr>\n","      <th>2</th>\n","      <td>2</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>5</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>...</td>\n","      <td>NaN</td>\n","      <td>-3245.0</td>\n","      <td>-3245.0</td>\n","      <td>-3245.0</td>\n","      <td>-2071.0</td>\n","      <td>-2071.0</td>\n","      <td>-2071.0</td>\n","      <td>-16105</td>\n","      <td>-16105</td>\n","      <td>-16105</td>\n","    </tr>\n","    <tr>\n","      <th>3</th>\n","      <td>3</td>\n","      <td>0</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>4</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>...</td>\n","      <td>NaN</td>\n","      <td>-233.0</td>\n","      <td>-233.0</td>\n","      <td>-233.0</td>\n","      <td>35.0</td>\n","      <td>35.0</td>\n","      <td>35.0</td>\n","      <td>-9286</td>\n","      <td>-9286</td>\n","      <td>-9286</td>\n","    </tr>\n","    <tr>\n","      <th>4</th>\n","      <td>4</td>\n","      <td>0</td>\n","      <td>1</td>\n","      <td>1</td>\n","      <td>5</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>...</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>NaN</td>\n","      <td>35.0</td>\n","      <td>35.0</td>\n","      <td>35.0</td>\n","      <td>-9134</td>\n","      <td>-9134</td>\n","      <td>-9134</td>\n","    </tr>\n","  </tbody>\n","</table>\n","<p>5 rows × 188 columns</p>\n","</div>"],"text/plain":["   case_id  WEEK_NUM  target  MONTH_NUM  WEEKDAY_NUM  days120_123L  \\\n","0        0         0       0          1            4           NaN   \n","1        1         0       0          1            4           NaN   \n","2        2         0       0          1            5           NaN   \n","3        3         0       0          1            4           NaN   \n","4        4         0       1          1            5           NaN   \n","\n","   days180_256L  days30_165L  days360_512L  days90_310L  ...  \\\n","0           NaN          NaN           NaN          NaN  ...   \n","1           NaN          NaN           NaN          NaN  ...   \n","2           NaN          NaN           NaN          NaN  ...   \n","3           NaN          NaN           NaN          NaN  ...   \n","4           NaN          NaN           NaN          NaN  ...   \n","\n","  days_from_decision_mean_dtlastpmtallstes_3545839D  \\\n","0                                               NaN   \n","1                                               NaN   \n","2                                               NaN   \n","3                                               NaN   \n","4                                               NaN   \n","\n","  days_from_decision_max_employedfrom_700D  \\\n","0                                      NaN   \n","1                                      NaN   \n","2                                  -3245.0   \n","3                                   -233.0   \n","4                                      NaN   \n","\n","  days_from_decision_min_employedfrom_700D  \\\n","0                                      NaN   \n","1                                      NaN   \n","2                                  -3245.0   \n","3                                   -233.0   \n","4                                      NaN   \n","\n","   days_from_decision_mean_employedfrom_700D  \\\n","0                                        NaN   \n","1                                        NaN   \n","2                                    -3245.0   \n","3                                     -233.0   \n","4                                        NaN   \n","\n","   days_from_decision_max_firstnonzeroinstldate_307D  \\\n","0                                                NaN   \n","1                                                NaN   \n","2                                            -2071.0   \n","3                                               35.0   \n","4                                               35.0   \n","\n","  days_from_decision_min_firstnonzeroinstldate_307D  \\\n","0                                               NaN   \n","1                                               NaN   \n","2                                           -2071.0   \n","3                                              35.0   \n","4                                              35.0   \n","\n","  days_from_decision_mean_firstnonzeroinstldate_307D  \\\n","0                                                NaN   \n","1                                                NaN   \n","2                                            -2071.0   \n","3                                               35.0   \n","4                                               35.0   \n","\n","   days_from_decision_max_birth_259D  days_from_decision_min_birth_259D  \\\n","0                             -11874                             -11874   \n","1                             -22435                             -22435   \n","2                             -16105                             -16105   \n","3                              -9286                              -9286   \n","4                              -9134                              -9134   \n","\n","   days_from_decision_mean_birth_259D  \n","0                              -11874  \n","1                              -22435  \n","2                              -16105  \n","3                               -9286  \n","4                               -9134  \n","\n","[5 rows x 188 columns]"]},"execution_count":16,"metadata":{},"output_type":"execute_result"}],"source":["# inspect pandas dataframe\n","df_train.head()"]},{"cell_type":"markdown","id":"65de3e9d","metadata":{"papermill":{"duration":0.012612,"end_time":"2024-05-11T16:55:38.560053","exception":false,"start_time":"2024-05-11T16:55:38.547441","status":"completed"},"tags":[]},"source":["## Lightgbm Model\n","\n","Credit: https://www.kaggle.com/code/greysky/home-credit-baseline"]},{"cell_type":"code","execution_count":17,"id":"2a384390","metadata":{"execution":{"iopub.execute_input":"2024-05-11T16:55:38.589868Z","iopub.status.busy":"2024-05-11T16:55:38.589521Z","iopub.status.idle":"2024-05-11T17:06:38.342005Z","shell.execute_reply":"2024-05-11T17:06:38.340942Z"},"papermill":{"duration":659.769708,"end_time":"2024-05-11T17:06:38.344332","exception":false,"start_time":"2024-05-11T16:55:38.574624","status":"completed"},"tags":[]},"outputs":[{"name":"stderr","output_type":"stream","text":["1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n","1 warning generated.\n"]},{"name":"stdout","output_type":"stream","text":["Training until validation scores don't improve for 50 rounds\n","[100]\tvalid_0's auc: 0.799876\n","[200]\tvalid_0's auc: 0.806692\n","[300]\tvalid_0's auc: 0.808213\n","[400]\tvalid_0's auc: 0.809011\n","[500]\tvalid_0's auc: 0.809355\n","[600]\tvalid_0's auc: 0.809733\n","[700]\tvalid_0's auc: 0.810031\n","[800]\tvalid_0's auc: 0.810176\n","[900]\tvalid_0's auc: 0.810303\n","Early stopping, best iteration is:\n","[855]\tvalid_0's auc: 0.810347\n","Training until validation scores don't improve for 50 rounds\n","[100]\tvalid_0's auc: 0.800587\n","[200]\tvalid_0's auc: 0.806817\n","[300]\tvalid_0's auc: 0.808706\n","[400]\tvalid_0's auc: 0.809599\n","[500]\tvalid_0's auc: 0.810083\n","[600]\tvalid_0's auc: 0.81062\n","[700]\tvalid_0's auc: 0.810882\n","[800]\tvalid_0's auc: 0.81118\n","Early stopping, best iteration is:\n","[821]\tvalid_0's auc: 0.811347\n","Training until validation scores don't improve for 50 rounds\n","[100]\tvalid_0's auc: 0.803364\n","[200]\tvalid_0's auc: 0.810699\n","[300]\tvalid_0's auc: 0.812865\n","[400]\tvalid_0's auc: 0.813435\n","[500]\tvalid_0's auc: 0.813995\n","[600]\tvalid_0's auc: 0.814574\n","[700]\tvalid_0's auc: 0.814861\n","[800]\tvalid_0's auc: 0.815031\n","[900]\tvalid_0's auc: 0.815224\n","Early stopping, best iteration is:\n","[946]\tvalid_0's auc: 0.815403\n","Training until validation scores don't improve for 50 rounds\n","[100]\tvalid_0's auc: 0.804415\n","[200]\tvalid_0's auc: 0.812062\n","[300]\tvalid_0's auc: 0.81411\n","[400]\tvalid_0's auc: 0.815091\n","[500]\tvalid_0's auc: 0.815627\n","[600]\tvalid_0's auc: 0.816119\n","[700]\tvalid_0's auc: 0.816293\n","[800]\tvalid_0's auc: 0.816429\n","[900]\tvalid_0's auc: 0.816651\n","Early stopping, best iteration is:\n","[926]\tvalid_0's auc: 0.816699\n","Training until validation scores don't improve for 50 rounds\n","[100]\tvalid_0's auc: 0.799647\n","[200]\tvalid_0's auc: 0.807822\n","[300]\tvalid_0's auc: 0.809955\n","[400]\tvalid_0's auc: 0.810846\n","[500]\tvalid_0's auc: 0.811619\n","[600]\tvalid_0's auc: 0.812021\n","[700]\tvalid_0's auc: 0.812373\n","[800]\tvalid_0's auc: 0.812732\n","[900]\tvalid_0's auc: 0.812916\n","[1000]\tvalid_0's auc: 0.813042\n","Did not meet early stopping. Best iteration is:\n","[978]\tvalid_0's auc: 0.81308\n"]}],"source":["X = df_train.drop(columns=[\"target\", \"case_id\", \"WEEK_NUM\"])\n","y = df_train[\"target\"]\n","weeks = df_train[\"WEEK_NUM\"]\n","\n","cv = StratifiedGroupKFold(n_splits=5, shuffle=False)\n","\n","params = {\n","    \"boosting_type\": \"gbdt\",\n","    \"objective\": \"binary\",\n","    \"metric\": \"auc\",\n","    \"max_depth\": 10,\n","    \"learning_rate\": 0.05,\n","    \"n_estimators\": 1000,\n","    \"colsample_bytree\": 0.8, \n","    \"colsample_bynode\": 0.8,\n","    \"verbose\": -1,\n","    \"random_state\": 42,\n","    \"device\": \"gpu\",\n","}\n","\n","fitted_models = []\n","\n","for idx_train, idx_valid in cv.split(X, y, groups=weeks):\n","    X_train, y_train = X.iloc[idx_train], y.iloc[idx_train]\n","    X_valid, y_valid = X.iloc[idx_valid], y.iloc[idx_valid]\n","\n","    model = lgb.LGBMClassifier(**params)\n","    model.fit(\n","        X_train, y_train,\n","        eval_set=[(X_valid, y_valid)],\n","        callbacks=[lgb.log_evaluation(100), lgb.early_stopping(50)]\n","    )\n","\n","    fitted_models.append(model)\n"]},{"cell_type":"code","execution_count":18,"id":"17969aa7","metadata":{"execution":{"iopub.execute_input":"2024-05-11T17:06:38.377734Z","iopub.status.busy":"2024-05-11T17:06:38.377404Z","iopub.status.idle":"2024-05-11T17:06:38.929333Z","shell.execute_reply":"2024-05-11T17:06:38.928372Z"},"papermill":{"duration":0.570954,"end_time":"2024-05-11T17:06:38.931464","exception":false,"start_time":"2024-05-11T17:06:38.36051","status":"completed"},"tags":[]},"outputs":[{"data":{"text/plain":["['lgbm_fitted.pkl']"]},"execution_count":18,"metadata":{},"output_type":"execute_result"}],"source":["# save fitted models\n","import joblib\n","joblib.dump(fitted_models, 'lgbm_fitted.pkl')"]},{"cell_type":"markdown","id":"4dfc2a93","metadata":{"papermill":{"duration":0.015736,"end_time":"2024-05-11T17:06:39.006383","exception":false,"start_time":"2024-05-11T17:06:38.990647","status":"completed"},"tags":[]},"source":["# Submission"]},{"cell_type":"code","execution_count":19,"id":"c3f61ce5","metadata":{"execution":{"iopub.execute_input":"2024-05-11T17:06:39.039746Z","iopub.status.busy":"2024-05-11T17:06:39.039151Z","iopub.status.idle":"2024-05-11T17:06:39.226737Z","shell.execute_reply":"2024-05-11T17:06:39.225919Z"},"papermill":{"duration":0.206856,"end_time":"2024-05-11T17:06:39.229148","exception":false,"start_time":"2024-05-11T17:06:39.022292","status":"completed"},"tags":[]},"outputs":[],"source":["# Credit: https://www.kaggle.com/code/greysky/home-credit-baseline\n","data_stores = {\n","    \"df_base\": read_file(TEST_DIR / \"test_base.parquet\"),\n","    \"other_dfs\": [\n","        # depth 0\n","        read_file(TEST_DIR / \"test_static_cb_0.parquet\"),\n","        read_files(TEST_DIR / \"test_static_0_*.parquet\"),\n","        # depth 1\n","        read_files(TEST_DIR / \"test_applprev_1_*.parquet\", 1),\n","        read_file(TEST_DIR / \"test_tax_registry_a_1.parquet\", 1),\n","        read_file(TEST_DIR / \"test_tax_registry_b_1.parquet\", 1),\n","        read_file(TEST_DIR / \"test_tax_registry_c_1.parquet\", 1),\n","        read_file(TEST_DIR / \"test_credit_bureau_b_1.parquet\", 1),\n","        read_file(TEST_DIR / \"test_other_1.parquet\", 1),\n","        read_file(TEST_DIR / \"test_person_1.parquet\", 1),\n","        read_file(TEST_DIR / \"test_deposit_1.parquet\", 1),\n","        read_file(TEST_DIR / \"test_debitcard_1.parquet\", 1),\n","        # depth 2\n","        read_file(TEST_DIR / \"test_credit_bureau_b_2.parquet\", 2),\n","    ]\n","}\n","\n","\n","# process test set in appropriate formate\n","df_test = (\n","    merge_and_basic_fe(**data_stores)\n","    .drop(columns_to_drop) # drop columns with too many missing values\n","    .drop(cat_columns_to_drop) # drop columns with too many categorical values\n","    .with_columns(\n","        numberofqueries_373L = (\n","            pl.when(pl.col('numberofqueries_373L') > 38).then(38)\n","            .otherwise(pl.col('numberofqueries_373L'))\n","        )\n","    )\n","    .collect().to_pandas()\n","    .set_index('case_id')\n","    .drop(columns=['WEEK_NUM'])\n",")\n","\n","df_test[categorical_cols] = df_test[categorical_cols].astype(\"category\")"]},{"cell_type":"code","execution_count":20,"id":"b62e2550","metadata":{"execution":{"iopub.execute_input":"2024-05-11T17:06:39.263762Z","iopub.status.busy":"2024-05-11T17:06:39.263258Z","iopub.status.idle":"2024-05-11T17:06:39.336605Z","shell.execute_reply":"2024-05-11T17:06:39.335824Z"},"papermill":{"duration":0.092047,"end_time":"2024-05-11T17:06:39.338594","exception":false,"start_time":"2024-05-11T17:06:39.246547","status":"completed"},"tags":[]},"outputs":[],"source":["# generate predictions (avgd probabilities)\n","prob_preds = np.column_stack([\n","    model.predict_proba(df_test)[:, 1] for model in fitted_models\n","]).mean(axis=1)\n","\n","submission = pd.DataFrame({\n","    'case_id': df_test.index.tolist(),\n","    'score': prob_preds\n","})\n","\n","submission.to_csv('submission.csv', index=None)"]},{"cell_type":"code","execution_count":null,"id":"1df0c65f","metadata":{"papermill":{"duration":0.015604,"end_time":"2024-05-11T17:06:39.371426","exception":false,"start_time":"2024-05-11T17:06:39.355822","status":"completed"},"tags":[]},"outputs":[],"source":[]}],"metadata":{"kaggle":{"accelerator":"gpu","dataSources":[{"databundleVersionId":7921029,"sourceId":50160,"sourceType":"competition"}],"isGpuEnabled":true,"isInternetEnabled":false,"language":"python","sourceType":"notebook"},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.13"},"papermill":{"default_parameters":{},"duration":869.053873,"end_time":"2024-05-11T17:06:40.208912","environment_variables":{},"exception":null,"input_path":"__notebook__.ipynb","output_path":"__notebook__.ipynb","parameters":{},"start_time":"2024-05-11T16:52:11.155039","version":"2.5.0"}},"nbformat":4,"nbformat_minor":5}