vaisnor-xgb-copy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optiver Trading At The Close\n",
    "\n",
    "[Competition](https://www.kaggle.com/competitions/optiver-trading-at-the-close)\n",
    "\n",
    "[GitHub Repository](https://github.com/cvaisnor/DNN-Final-Project)\n",
    "\n",
    "[Google Slides Presentation](https://docs.google.com/presentation/d/1Xc5F1_NveFi1il3GqHej2aqVmklR_jZU4kx6ZJhiDEM/edit?usp=sharing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# General Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def load_data(kaggle_environment=False):\n",
    "    '''Loads and returns the data files.'''\n",
    "    if kaggle_environment:\n",
    "        data_path = '/kaggle/input/'\n",
    "    else:\n",
    "        data_path = 'kaggle/input/'\n",
    "\n",
    "    train = pd.read_csv(data_path + 'optiver-trading-at-the-close/train.csv')\n",
    "    test = pd.read_csv(data_path + 'optiver-trading-at-the-close/example_test_files/test.csv')\n",
    "    revealed_targets = pd.read_csv(data_path + 'optiver-trading-at-the-close/example_test_files/revealed_targets.csv')\n",
    "    sample_submission = pd.read_csv(data_path + 'optiver-trading-at-the-close/example_test_files/sample_submission.csv')\n",
    "\n",
    "    return train, test, revealed_targets, sample_submission\n",
    "\n",
    "def submit_dummy_predictions(env, predictions):\n",
    "    '''Submits a dummy prediction to the Optiver API. Use when you have an error during processing\n",
    "    of iter_test and you do not want to re-run the whole notebook to figure out if you fixed it.'''\n",
    "    predictions[\"target\"] = [0 for i in range(predictions.shape[0])]\n",
    "    env.predict(predictions)\n",
    "\n",
    "def plot_predictions(actuals, predicted):\n",
    "    '''Plots actual vs predicted values to get a sense of whether the predictions make sense.'''\n",
    "\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(actuals, label='Actual')\n",
    "    plt.plot(predicted, label='Predicted')\n",
    "    plt.title('Actual vs Predicted Values')\n",
    "    plt.xlabel('Samples')\n",
    "    plt.ylabel('Values')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.experimental import enable_iterative_imputer\n",
    "from sklearn.impute import IterativeImputer\n",
    "\n",
    "\n",
    "class LogFeatures(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer for applying logarithmic transformation to specified columns.'''\n",
    "    def __init__(self, columns):\n",
    "        self.columns = columns\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        for column in self.columns:\n",
    "            X[f'{column}_log'] = np.log1p(X[column].clip(lower=0.00001))\n",
    "        return X\n",
    "\n",
    "class CombineFeatures(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer to combine features by multiplication.'''\n",
    "    def __init__(self, combined_features_list):\n",
    "        self.combined_features_list = combined_features_list\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        for combined_features in self.combined_features_list:\n",
    "            combined_feature_name = '_'.join(combined_features)\n",
    "            X[combined_feature_name] = X[combined_features].prod(axis=1)\n",
    "        return X\n",
    "\n",
    "class SubtractFeatures(BaseEstimator, TransformerMixin):\n",
    "    \"\"\"Transformer to subtract one feature from another.\"\"\"\n",
    "\n",
    "    def __init__(self, base_feature, feature_to_subtract):\n",
    "        self.feature_to_subtract = feature_to_subtract\n",
    "        self.base_feature = base_feature\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        new_feature_name = f\"{self.base_feature}_minus_{self.feature_to_subtract}\"\n",
    "        X[new_feature_name] = X[self.base_feature] - X[self.feature_to_subtract]\n",
    "\n",
    "        return X\n",
    "\n",
    "class LagFeatures(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer for creating lag features for specified columns and shift sizes.'''\n",
    "    def __init__(self, features, shift_sizes, default_value):\n",
    "        self.features = features\n",
    "        self.shift_sizes = shift_sizes\n",
    "        self.default_value = default_value\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        for feature in self.features:\n",
    "            for shift_size in self.shift_sizes:\n",
    "                lag_col = f'{feature}_lag_{shift_size}'\n",
    "                X[lag_col] = X.groupby(['stock_id', 'date_id'])[feature].shift(shift_size)\n",
    "                X[lag_col].fillna(self.default_value, inplace=True)\n",
    "\n",
    "        return X\n",
    "\n",
    "\n",
    "class RollingMeanFeatures(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer for calculating rolling mean of each feature over each specified window size.'''\n",
    "    def __init__(self, features, window_sizes):\n",
    "        self.features = features\n",
    "        self.window_sizes = window_sizes\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        rolling_mean_columns = []\n",
    "\n",
    "        for feature in self.features:\n",
    "            for window_size in self.window_sizes:\n",
    "                rolling_mean_col = f'{feature}_rolling_mean{window_size}'\n",
    "                rolling_mean_columns.append(rolling_mean_col)\n",
    "\n",
    "                X[rolling_mean_col] = X.groupby(['stock_id', 'date_id'])[feature].rolling(window=window_size).mean().reset_index(level=[0,1], drop=True)\n",
    "\n",
    "        for col in rolling_mean_columns:\n",
    "            X[col].fillna(1.0, inplace=True)\n",
    "\n",
    "        return X\n",
    "\n",
    "\n",
    "class DiffFeatures(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer for computing the difference of each feature column (i.e., first discrete difference).'''\n",
    "    def __init__(self, features):\n",
    "        self.features = features\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        for feature in self.features:\n",
    "            diff_col = f'{feature}_diff'\n",
    "\n",
    "            X[diff_col] = X.groupby(['stock_id', 'date_id'])[feature].diff()\n",
    "            X[diff_col].fillna(0.0, inplace=True)\n",
    "\n",
    "        return X\n",
    "\n",
    "\n",
    "class ExpandingMeanFeatures(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer for calculating the expanding mean of each of the feature columns.'''\n",
    "    def __init__(self, features):\n",
    "        self.features = features\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        expanding_mean_columns = []\n",
    "\n",
    "        for feature in self.features:\n",
    "            expanding_mean_col = f'{feature}_expanding_mean'\n",
    "            expanding_mean_columns.append(expanding_mean_col)\n",
    "\n",
    "            X[expanding_mean_col] = X.groupby(['stock_id', 'date_id'])[feature].expanding().mean().reset_index(level=[0,1], drop=True)\n",
    "\n",
    "        for col in expanding_mean_columns:\n",
    "            X[col].fillna(1.0, inplace=True)\n",
    "\n",
    "        return X\n",
    "\n",
    "class DropColumns(BaseEstimator, TransformerMixin):\n",
    "    '''Drops columns from the data frame.'''\n",
    "    def __init__(self, columns):\n",
    "        self.columns = columns\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        all_columns = X.columns\n",
    "        drop_columns = []\n",
    "        for column in self.columns:\n",
    "            if column in all_columns:\n",
    "                drop_columns.append(column)\n",
    "        return X.drop(columns=drop_columns)\n",
    "\n",
    "class ForwardFillValues(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer for forward filling NaN values in the DataFrame, grouped by stock_id.'''\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        for column in X.columns:\n",
    "            # X[column] = X.groupby(['stock_id', 'date_id'])[column].transform(lambda group: group.ffill())\n",
    "            X[column] = X.groupby('stock_id')[column].transform(lambda group: group.ffill())\n",
    "        return X\n",
    "\n",
    "\n",
    "class FillZero(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer for replacing NaN values with zero in the DataFrame.'''\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        X = X.fillna(0.0)\n",
    "        return X\n",
    "\n",
    "class FillOne(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer for replacing NaN values with one in the DataFrame.'''\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        X = X.fillna(1.0)\n",
    "        return X\n",
    "\n",
    "class DataFrameWrapper(BaseEstimator, TransformerMixin):\n",
    "    '''Wrapper for transforming output of a transformer to a DataFrame with optional specified columns.'''\n",
    "    def __init__(self, transformer, columns=None):\n",
    "        self.transformer = transformer\n",
    "        self.columns = columns\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        self.transformer.fit(X, y)\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        result = self.transformer.transform(X)\n",
    "        if isinstance(result, pd.DataFrame):\n",
    "            return result\n",
    "        if self.columns is None:\n",
    "            columns = X.columns\n",
    "        else:\n",
    "            columns = []\n",
    "            for column in X.columns:\n",
    "                if column in self.columns:\n",
    "                    columns.append(column)\n",
    "        return pd.DataFrame(result, columns=columns)\n",
    "\n",
    "class PolynomialFeaturesWrapper(BaseEstimator, TransformerMixin):\n",
    "    '''Transformer for generating polynomial and interaction features with specified degree.'''\n",
    "    def __init__(self, degree=2):\n",
    "        self.degree = degree\n",
    "        self.poly = PolynomialFeatures(degree=self.degree, include_bias=False)\n",
    "        self.new_feature_names = None\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        self.poly.fit(X)\n",
    "        self.new_feature_names = self.poly.get_feature_names_out(X.columns)\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        transformed_array = self.poly.transform(X)\n",
    "        return pd.DataFrame(transformed_array, columns=self.new_feature_names)\n",
    "\n",
    "class MissingValueImputer(BaseEstimator, TransformerMixin):\n",
    "    '''Impute missing values in specified columns of a DataFrame using IterativeImputer.'''\n",
    "    def __init__(self, columns, max_iter=10, random_state=0):\n",
    "        self.columns = columns\n",
    "        self.max_iter = max_iter\n",
    "        self.random_state = random_state\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        columns_to_impute = [col for col in self.columns if col in X.columns]\n",
    "\n",
    "        # Select the columns for imputation\n",
    "        columns_data = X[columns_to_impute]\n",
    "\n",
    "        # Check if there are any missing values and if the columns are numeric\n",
    "        if columns_data.isna().any().any() and columns_data.select_dtypes(include='number').shape[1] == len(columns_to_impute):\n",
    "            imputer = IterativeImputer(max_iter=self.max_iter, random_state=self.random_state)\n",
    "\n",
    "            # Apply imputation\n",
    "            imputed_data = imputer.fit_transform(columns_data)\n",
    "            imputed_df = pd.DataFrame(imputed_data, columns=columns_to_impute, index=X.index)\n",
    "\n",
    "            # Update the original DataFrame\n",
    "            X.update(imputed_df)\n",
    "        return X\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import importlib\n",
    "\n",
    "# import helpers\n",
    "\n",
    "kaggle_environment = False # True if running on Kaggle, don't forget to add the dataset!\n",
    "\n",
    "# from helpers.common import load_data, plot_predictions, submit_dummy_predictions\n",
    "# from helpers.pipeline import LogFeatures, LagFeatures, RollingMeanFeatures, DiffFeatures, ExpandingMeanFeatures, \\\n",
    "# ForwardFillValues, FillZero, DataFrameWrapper, PolynomialFeaturesWrapper, MissingValueImputer, DropColumns, FillOne\n",
    "\n",
    "# if not kaggle_environment:\n",
    "#     # Reload the modules\n",
    "#     importlib.reload(helpers.common)\n",
    "#     importlib.reload(helpers.pipeline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "original_train, test, revealed_targets, sample_submission = load_data(kaggle_environment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "split_ratio = 0.8  # 80% for training, 20% for testing\n",
    "split_idx = int(len(original_train) * split_ratio)\n",
    "\n",
    "train = original_train.iloc[:split_idx]\n",
    "test = original_train.iloc[split_idx:]\n",
    "\n",
    "train = train.dropna(subset=['target', 'imbalance_size'])\n",
    "test = test.dropna(subset=['target', 'imbalance_size'])\n",
    "\n",
    "# train = train.dropna()\n",
    "# test = test.dropna()\n",
    "\n",
    "y = train['target'].values\n",
    "y_test = test['target'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature Engineering Section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6.71 s, sys: 818 ms, total: 7.52 s\n",
      "Wall time: 7.33 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.preprocessing import OneHotEncoder, StandardScaler\n",
    "\n",
    "# drop_columns=['target', 'bid_size', 'ask_size', 'imbalance_size', 'matched_size', 'time_id', 'row_id', 'currently_scored']\n",
    "drop_columns=['target', 'time_id', 'row_id', 'currently_scored']\n",
    "# drop_columns=['seconds_in_bucket', 'target', 'bid_size', 'ask_size', 'imbalance_size', 'matched_size', 'time_id', 'row_id', 'currently_scored']\n",
    "\n",
    "# Main Pipeline\n",
    "pipeline = Pipeline([\n",
    "    # ('logs', LogFeatures(['imbalance_size', 'matched_size', 'bid_size', 'ask_size'])),\n",
    "    ('combine_features', CombineFeatures([\n",
    "        ['imbalance_buy_sell_flag', 'reference_price', 'ask_price', 'bid_price'],\n",
    "        ['imbalance_buy_sell_flag', 'far_price', 'near_price', 'ask_price'],\n",
    "    ])),\n",
    "    ('subtract_features', SubtractFeatures('ask_price', 'bid_price')),\n",
    "    ('wap_lags', LagFeatures(['wap', 'imbalance_buy_sell_flag_reference_price_ask_price_bid_price', 'ask_price_minus_bid_price'], [1, 2], 1.0)),\n",
    "    ('matched_size_lags', LagFeatures(['matched_size'], [1, 2], 0.0)),\n",
    "    ('wap_rolling_means', RollingMeanFeatures(['wap'], [2])),\n",
    "    ('diff_features', DiffFeatures(['wap', 'matched_size', 'ask_price', 'reference_price'])),\n",
    "    # ('diff_features', DiffFeatures(['wap', 'imbalance_buy_sell_flag', 'matched_size', 'ask_price', 'reference_price'])),\n",
    "    ('diff_features_2', DiffFeatures(['wap_diff', 'matched_size_diff', 'ask_price_diff', 'reference_price_diff'])),\n",
    "    # ('diff_features_3', DiffFeatures(['wap_diff_diff', 'matched_size_diff_diff', 'ask_price_diff_diff', 'reference_price_diff_diff'])),\n",
    "    ('wap_expanding_mean', ExpandingMeanFeatures(['wap'])),\n",
    "    ('drop_columns', DropColumns(drop_columns)),\n",
    "#     ('missing_value_imputer', MissingValueImputer(['far_price', 'near_price'])),\n",
    "    # ('forward_fill', ForwardFillValues()),\n",
    "    # ('fill_zero', FillZero()),\n",
    "    # ('fill_one', FillOne()),\n",
    "    # ('preprocessor', DataFrameWrapper(preprocessor, columns_to_keep)),\n",
    "    ('drop_grouping_columns', DropColumns(['stock_id', 'date_id'])),\n",
    "    # ('scaler', DataFrameWrapper(StandardScaler())),\n",
    "    # ('poly', PolynomialFeaturesWrapper(2)),\n",
    "])\n",
    "\n",
    "import warnings\n",
    "\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\", category=pd.errors.SettingWithCopyWarning)\n",
    "    train_transformed = pipeline.fit_transform(train)\n",
    "    test_transformed = pipeline.transform(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = train_transformed\n",
    "X_test = test_transformed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All feature transformations should be combined into a generate_feature() function. This can then be applied to the test data will in the for loop for the Optiver API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_features(cumulative_test_df, current_test, pipeline):\n",
    "    transformed_df = pipeline.transform(cumulative_test_df)\n",
    "    \n",
    "    # Only return rows corresponding to the current test dataframe\n",
    "    return transformed_df.iloc[-len(current_test):]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slicing\n",
    "\n",
    "Generally, don't change the cell below. It is used to slice the data into training and validation sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "X_train = X\n",
    "y_train = y "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Development"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xgboost as xgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-2 {color: black;background-color: white;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>XGBRegressor(base_score=None, booster=None, callbacks=None,\n",
       "             colsample_bylevel=None, colsample_bynode=None,\n",
       "             colsample_bytree=0.8, early_stopping_rounds=None,\n",
       "             enable_categorical=False, eval_metric=None, feature_types=None,\n",
       "             gamma=None, gpu_id=0, grow_policy=None, importance_type=None,\n",
       "             interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
       "             max_cat_threshold=None, max_cat_to_onehot=None,\n",
       "             max_delta_step=None, max_depth=15, max_leaves=None,\n",
       "             min_child_weight=None, missing=nan, monotone_constraints=None,\n",
       "             n_estimators=100, n_jobs=None, num_parallel_tree=None,\n",
       "             predictor=None, random_state=None, ...)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">XGBRegressor</label><div class=\"sk-toggleable__content\"><pre>XGBRegressor(base_score=None, booster=None, callbacks=None,\n",
       "             colsample_bylevel=None, colsample_bynode=None,\n",
       "             colsample_bytree=0.8, early_stopping_rounds=None,\n",
       "             enable_categorical=False, eval_metric=None, feature_types=None,\n",
       "             gamma=None, gpu_id=0, grow_policy=None, importance_type=None,\n",
       "             interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
       "             max_cat_threshold=None, max_cat_to_onehot=None,\n",
       "             max_delta_step=None, max_depth=15, max_leaves=None,\n",
       "             min_child_weight=None, missing=nan, monotone_constraints=None,\n",
       "             n_estimators=100, n_jobs=None, num_parallel_tree=None,\n",
       "             predictor=None, random_state=None, ...)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "XGBRegressor(base_score=None, booster=None, callbacks=None,\n",
       "             colsample_bylevel=None, colsample_bynode=None,\n",
       "             colsample_bytree=0.8, early_stopping_rounds=None,\n",
       "             enable_categorical=False, eval_metric=None, feature_types=None,\n",
       "             gamma=None, gpu_id=0, grow_policy=None, importance_type=None,\n",
       "             interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
       "             max_cat_threshold=None, max_cat_to_onehot=None,\n",
       "             max_delta_step=None, max_depth=15, max_leaves=None,\n",
       "             min_child_weight=None, missing=nan, monotone_constraints=None,\n",
       "             n_estimators=100, n_jobs=None, num_parallel_tree=None,\n",
       "             predictor=None, random_state=None, ...)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# setup xgboost regressor\n",
    "regressor = xgb.XGBRegressor(\n",
    "    n_estimators=100,\n",
    "    objective='reg:squarederror',\n",
    "    learning_rate=0.1,\n",
    "    max_depth=15,\n",
    "    subsample=0.8,\n",
    "    colsample_bytree=0.8,\n",
    "    tree_method='gpu_hist',\n",
    "    gpu_id=0\n",
    ")\n",
    "\n",
    "# train model\n",
    "regressor.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Error on the test set: 6.0020\n",
      "Mean Absolute Error on the training set: 5.5945\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import mean_absolute_error\n",
    "\n",
    "predictions = regressor.predict(X_test)\n",
    "mae = mean_absolute_error(y_test, predictions)\n",
    "print(f\"Mean Absolute Error on the test set: {mae:.4f}\")\n",
    "\n",
    "predictions2 = regressor.predict(X_train)\n",
    "mae2 = mean_absolute_error(y_train, predictions2)\n",
    "print(f\"Mean Absolute Error on the training set: {mae2:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions(y_test, predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions(y_train, predictions2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-27.257282 44.97493\n"
     ]
    }
   ],
   "source": [
    "print(predictions.min(), predictions.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generating Predictions\n",
    "\n",
    "Only for Kaggle:\n",
    "When uploading notebook, make sure to add the Optiver data on the right side of the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "if kaggle_environment:\n",
    "    import optiver2023\n",
    "    env = optiver2023.make_env()\n",
    "    iter_test = env.iter_test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment this cell to try to get unstuck from having to restart and run the whole notebook again\n",
    "# submit_dummy_predictions(env, sample_prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if kaggle_environment:\n",
    "#     # To count how many time the \"for loop\" runs.\n",
    "#     counter = 0\n",
    "\n",
    "#     # init 3 empty lists\n",
    "#     # test_ls, revealed_targets_ls, sample_prediction_ls = [], [], []\n",
    "#     cumulative_test_df = pd.DataFrame()\n",
    "\n",
    "#     for (test_in, revealed_targets, sample_prediction) in iter_test:\n",
    "#         # Append the dataframe that API return into the list.\n",
    "#         # test_ls.append(test_in.copy())\n",
    "#         # revealed_targets_ls.append(revealed_targets.copy())\n",
    "#         # sample_prediction_ls.append(sample_prediction.copy())\n",
    "\n",
    "#         recent_rows = cumulative_test_df.tail(2000)\n",
    "#         cumulative_test_df = pd.concat([recent_rows, test_in], axis=0, ignore_index=True)\n",
    "\n",
    "#         # Generate features\n",
    "#         test_transformed = generate_features(cumulative_test_df, test_in, pipeline)\n",
    "\n",
    "#         # Writes our predictions \n",
    "#         sample_prediction[\"target\"] = model.predict(test_transformed)\n",
    "        \n",
    "#         # This line submit our predictions.\n",
    "#         env.predict(sample_prediction)\n",
    "#         counter += 1\n",
    "\n",
    "#     print('\\n', '=' * 50, sep=\"\")\n",
    "#     print(f\"counter: {counter}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "if kaggle_environment:\n",
    "    # To count how many time the \"for loop\" runs.\n",
    "    counter = 0\n",
    "\n",
    "    # init 3 empty lists\n",
    "    # test_ls, revealed_targets_ls, sample_prediction_ls = [], [], []\n",
    "    cumulative_test_df = pd.DataFrame()\n",
    "\n",
    "    for (test_in, revealed_targets, sample_prediction) in iter_test:\n",
    "        # Append the dataframe that API return into the list.\n",
    "        # test_ls.append(test_in.copy())\n",
    "        # revealed_targets_ls.append(revealed_targets.copy())\n",
    "        # sample_prediction_ls.append(sample_prediction.copy())\n",
    "\n",
    "        test_in['target'] = 0\n",
    "        current_date_id = test_in.iloc[0]['date_id']\n",
    "        cumulative_test_df = pd.concat([cumulative_test_df, test_in], axis=0, ignore_index=True)\n",
    "#         if len(cumulative_test_df.columns) > 0:\n",
    "        cumulative_test_df = cumulative_test_df[cumulative_test_df['date_id'] == current_date_id]\n",
    "#             cumulative_test_df = pd.concat([current_date_rows, test_in], axis=0, ignore_index=True)\n",
    "        print(f'{counter}: {cumulative_test_df.shape[0]}')\n",
    "\n",
    "        # Generate features\n",
    "        test_transformed = generate_features(cumulative_test_df, test_in, pipeline)\n",
    "\n",
    "        # Writes our predictions \n",
    "        sample_prediction[\"target\"] = model.predict(test_transformed)\n",
    "        \n",
    "        # This line submit our predictions.\n",
    "        env.predict(sample_prediction)\n",
    "        counter += 1\n",
    "\n",
    "    print('\\n', '=' * 50, sep=\"\")\n",
    "    print(f\"counter: {counter}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cumulative_test_df.to_csv('final_cumulative_2k_rows.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81.03471690678968"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test.var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "none",
   "dataSources": [
    {
     "databundleVersionId": 7056235,
     "sourceId": 57891,
     "sourceType": "competition"
    }
   ],
   "dockerImageVersionId": 30558,
   "isGpuEnabled": false,
   "isInternetEnabled": false,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}