{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":84896,"databundleVersionId":10305135,"sourceType":"competition"}],"dockerImageVersionId":30786,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:14.565318Z","iopub.execute_input":"2024-12-10T17:43:14.565908Z","iopub.status.idle":"2024-12-10T17:43:14.579422Z","shell.execute_reply.started":"2024-12-10T17:43:14.565853Z","shell.execute_reply":"2024-12-10T17:43:14.578129Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Libraries","metadata":{}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport tensorflow as tf\nimport keras\nimport keras.ops as ops\n\nfrom sklearn.base import BaseEstimator, RegressorMixin\nfrom sklearn.preprocessing import StandardScaler, OneHotEncoder, LabelEncoder, OrdinalEncoder, FunctionTransformer\nfrom sklearn.impute import SimpleImputer\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.compose import ColumnTransformer\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import mean_squared_log_error, mean_squared_error, r2_score, mean_absolute_error, make_scorer\n\nfrom sklearn.ensemble import VotingRegressor\nfrom xgboost import XGBRegressor\nfrom xgboost.callback import EarlyStopping as es\nimport lightgbm\nfrom lightgbm import LGBMRegressor\nfrom catboost import CatBoostRegressor\n\nfrom keras.callbacks import EarlyStopping\nfrom keras.models import Sequential\nfrom keras.layers import Dense, BatchNormalization, Dropout, Input\nfrom keras.optimizers import Adam\n\n# Suppress warnings for cleaner output\nimport warnings\nwarnings.filterwarnings('ignore')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:14.60329Z","iopub.execute_input":"2024-12-10T17:43:14.603677Z","iopub.status.idle":"2024-12-10T17:43:14.614674Z","shell.execute_reply.started":"2024-12-10T17:43:14.603645Z","shell.execute_reply":"2024-12-10T17:43:14.613383Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Loading Dataset","metadata":{}},{"cell_type":"code","source":"train_df = pd.read_csv('/kaggle/input/playground-series-s4e12/train.csv')\ntest_df = pd.read_csv('/kaggle/input/playground-series-s4e12/test.csv')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:14.647759Z","iopub.execute_input":"2024-12-10T17:43:14.648344Z","iopub.status.idle":"2024-12-10T17:43:22.265311Z","shell.execute_reply.started":"2024-12-10T17:43:14.6483Z","shell.execute_reply":"2024-12-10T17:43:22.263929Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Data info","metadata":{}},{"cell_type":"code","source":"print(train_df.columns.tolist())","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:22.267762Z","iopub.execute_input":"2024-12-10T17:43:22.268281Z","iopub.status.idle":"2024-12-10T17:43:22.275177Z","shell.execute_reply.started":"2024-12-10T17:43:22.268231Z","shell.execute_reply":"2024-12-10T17:43:22.273751Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_df.head().style.set_properties(**{\n    \"border\": \"1px solid\"\n})","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:22.277349Z","iopub.execute_input":"2024-12-10T17:43:22.277842Z","iopub.status.idle":"2024-12-10T17:43:22.303259Z","shell.execute_reply.started":"2024-12-10T17:43:22.277764Z","shell.execute_reply":"2024-12-10T17:43:22.301691Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Get the number of unique values for each column\nunique_counts = train_df.nunique().to_frame(name=\"Unique Counts\")\n\n# Apply styling to the DataFrame\nunique_counts_styled = unique_counts.style.set_properties(**{\n    \"border\": \"1px solid\"\n})\n\nunique_counts_styled","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:22.306414Z","iopub.execute_input":"2024-12-10T17:43:22.306945Z","iopub.status.idle":"2024-12-10T17:43:23.5222Z","shell.execute_reply.started":"2024-12-10T17:43:22.306894Z","shell.execute_reply":"2024-12-10T17:43:23.521014Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_df.describe().style.set_properties(**{\n    \"border\": \"1px solid\"\n})","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:23.523355Z","iopub.execute_input":"2024-12-10T17:43:23.523656Z","iopub.status.idle":"2024-12-10T17:43:24.244997Z","shell.execute_reply.started":"2024-12-10T17:43:23.523627Z","shell.execute_reply":"2024-12-10T17:43:24.243662Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_df.info()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:24.246278Z","iopub.execute_input":"2024-12-10T17:43:24.246596Z","iopub.status.idle":"2024-12-10T17:43:24.910491Z","shell.execute_reply.started":"2024-12-10T17:43:24.246566Z","shell.execute_reply":"2024-12-10T17:43:24.909338Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_df.isnull().sum()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:24.912186Z","iopub.execute_input":"2024-12-10T17:43:24.912646Z","iopub.status.idle":"2024-12-10T17:43:25.556324Z","shell.execute_reply.started":"2024-12-10T17:43:24.912594Z","shell.execute_reply":"2024-12-10T17:43:25.555185Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"missing_values = train_df.isnull().mean() * 100\nmissing_values = missing_values[missing_values >0]\nmissing_values = missing_values.sort_values(ascending=False)\n\nplt.figure(figsize=(10, 6))\nsns.barplot(x=missing_values.index, y=missing_values.values, palette='viridis')\nplt.xticks(rotation=90)\nplt.xlabel('Features')\nplt.ylabel('Percentage of Missing Values')\nplt.title('Missing Values Distribution in train')\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:25.557836Z","iopub.execute_input":"2024-12-10T17:43:25.558302Z","iopub.status.idle":"2024-12-10T17:43:26.511135Z","shell.execute_reply.started":"2024-12-10T17:43:25.558252Z","shell.execute_reply":"2024-12-10T17:43:26.510038Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test_df.head().style.set_properties(**{\n    \"border\": \"1px solid\"\n})","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:26.51251Z","iopub.execute_input":"2024-12-10T17:43:26.512882Z","iopub.status.idle":"2024-12-10T17:43:26.530148Z","shell.execute_reply.started":"2024-12-10T17:43:26.512838Z","shell.execute_reply":"2024-12-10T17:43:26.528906Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"test_df.isnull().sum()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:26.534003Z","iopub.execute_input":"2024-12-10T17:43:26.534377Z","iopub.status.idle":"2024-12-10T17:43:26.97789Z","shell.execute_reply.started":"2024-12-10T17:43:26.534342Z","shell.execute_reply":"2024-12-10T17:43:26.976586Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train = train_df.drop(columns = ['id'], axis = 1)\ntest_id = test_df[\"id\"]\ntest = test_df.drop(columns = ['id'], axis = 1)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:26.980098Z","iopub.execute_input":"2024-12-10T17:43:26.980519Z","iopub.status.idle":"2024-12-10T17:43:27.200115Z","shell.execute_reply.started":"2024-12-10T17:43:26.980478Z","shell.execute_reply":"2024-12-10T17:43:27.198861Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"for df in [train, test]:\n    df['Policy Start Date'] = pd.to_datetime(df['Policy Start Date'])\n    df['Day'] = df['Policy Start Date'].dt.day\n    df['Month'] = df['Policy Start Date'].dt.month\n    df['Year'] = df['Policy Start Date'].dt.year\n    df = df.drop(columns = 'Policy Start Date', inplace = True)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:27.201849Z","iopub.execute_input":"2024-12-10T17:43:27.20226Z","iopub.status.idle":"2024-12-10T17:43:28.500582Z","shell.execute_reply.started":"2024-12-10T17:43:27.20222Z","shell.execute_reply":"2024-12-10T17:43:28.499244Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Split Train DF into X and y and then further split into training and validation data","metadata":{}},{"cell_type":"code","source":"X_traindf = train.drop(columns=[\"Premium Amount\"])\ny_traindf = train[\"Premium Amount\"]\ny_traindf_log = np.log1p(y_traindf)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-10T17:43:28.502781Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Finding out and separating categorical columns from numerical columns","metadata":{}},{"cell_type":"code","source":"numerical_columns = X_traindf.select_dtypes(include=['float64', 'int64']).columns.tolist()\ncategorical_columns = X_traindf.select_dtypes(include=['object']).columns.tolist()\n# Further classify categorical columns into one-hot and label encoding based on cardinality\nhigh_cardinality_threshold = 10\none_hot_columns = [col for col in categorical_columns if X_traindf[col].nunique() <= high_cardinality_threshold]\nordinal_columns = [col for col in categorical_columns if X_traindf[col].nunique() > high_cardinality_threshold]","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Define preprocessing pipelines\nnumerical_pipeline = Pipeline(steps=[\n    ('imputer', SimpleImputer(strategy='median')),\n    ('scaler', StandardScaler()),\n    ('convert_to_float32', FunctionTransformer(lambda x: x.astype(np.float32)))\n])\n\none_hot_pipeline = Pipeline(steps=[\n    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),\n    ('one_hot', OneHotEncoder(drop='first', sparse=False, handle_unknown='ignore'))\n])\n\nordinal_pipeline = Pipeline(steps=[\n    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),\n    ('ordinal', OrdinalEncoder(dtype=np.int32, handle_unknown='use_encoded_value', unknown_value=-1))\n])\n\n# Combine the pipelines into a ColumnTransformer\npreprocessor = ColumnTransformer(\n    transformers=[\n        ('num', numerical_pipeline, numerical_columns),\n        ('one_hot', one_hot_pipeline, one_hot_columns),\n        ('ordinal', ordinal_pipeline, ordinal_columns)\n    ]\n)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"preprocessor.fit(X_traindf)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"X_traindf_preprocessed = preprocessor.transform(X_traindf)\nX_test_preprocessed = preprocessor.transform(test)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"X_train, X_valid, y_train, y_valid = train_test_split(X_traindf_preprocessed, y_traindf_log, test_size=0.2, random_state=42)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"X_train.shape","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# RMSLE Scorer\ndef root_mean_squared_log_error(y_true, y_pred):\n    return np.sqrt(mean_squared_log_error(y_true, y_pred))\n\nrmsle_scorer = make_scorer(root_mean_squared_log_error, greater_is_better=False)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def evaluate_model(y_true, y_pred, model_name=\"Model\"):\n    rmsle = np.sqrt(mean_squared_log_error(y_true, y_pred))\n    rmse = np.sqrt(mean_squared_error(y_true, y_pred))\n    mae = mean_absolute_error(y_true, y_pred)\n    r2 = r2_score(y_true, y_pred)\n    print(f\"{model_name} Performance:\")\n    print(f\"RMSLE: {rmsle:.4f}\")\n    print(f\"RMSE: {rmse:.4f}\")\n    print(f\"MAE: {mae:.4f}\")\n    print(f\"R2 Score: {r2:.4f}\")\n    return rmsle, rmse, mae, r2","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# XGBoost Wrapper\nclass XGBWrapper(BaseEstimator, RegressorMixin):\n    def __init__(self, n_estimators=100, learning_rate=0.01, objective='reg:squarederror', eval_set=None, eval_metric='rmse', tree_method='hist', max_depth=-1, callbacks=None):\n        self.model = XGBRegressor(\n            objective=objective,\n            eval_metric=eval_metric,\n            tree_method=tree_method,\n            n_estimators=n_estimators,\n            learning_rate=learning_rate,\n            max_depth=max_depth,\n            callbacks=callbacks \n        )\n        self.eval_set = eval_set\n\n    def fit(self, X, y):\n        self.model.fit(X, y, eval_set=self.eval_set, verbose=False)\n        return self\n\n    def predict(self, X):\n        return self.model.predict(X)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model_xgb = XGBWrapper(\n    objective='reg:squaredlogerror',\n    eval_metric='rmsle',\n    tree_method='hist',\n    n_estimators=2500,\n    learning_rate=0.01,\n    max_depth=16,\n    callbacks = [es(rounds=20, save_best=True, metric_name='rmsle')],\n    eval_set=[(X_valid, y_valid)]\n)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(\"Model: XGBoostRegression\")\nmodel_xgb.fit(X_train, y_train)\nprint(\"Trained XGB\")\ny_valid_pred_xgb = np.maximum(model_xgb.predict(X_valid),0)\nprint(\"Predicted Training XGB\")\n\nevaluate_model(np.expm1(y_valid),np.expm1(y_valid_pred_xgb),\"XGBoostRegression\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# LightGBM Wrapper\nclass LGBMWrapper(BaseEstimator, RegressorMixin):\n    def __init__(self, n_estimators=100, learning_rate=0.01, max_depth=-1, early_stopping_round=20, eval_metric=None, eval_set=None, metric='rmse', objective='regression'):\n        self.model = LGBMRegressor(\n            n_estimators=n_estimators,\n            learning_rate=learning_rate,\n            objective=objective,\n            metric=metric,\n        )\n        self.eval_set = eval_set\n        self.early_stopping_rounds = early_stopping_round\n        self.eval_metric = eval_metric\n\n    def fit(self, X, y):\n        self.model.fit(X, y, eval_set=self.eval_set, eval_metric=self.eval_metric)\n        return self\n\n    def predict(self, X):\n        return self.model.predict(X)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# LightGBM Regressor\nmodel_lgbm = LGBMWrapper(\n    n_estimators=2500,\n    learning_rate=0.01,\n    max_depth=-1,\n    objective='regression',\n    metric='rmsle',\n    eval_metric='rmsle',\n    eval_set=[(X_valid, y_valid)]\n)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(\"Model: LightGBMRegression\")\nmodel_lgbm.fit(X_train, y_train)\nprint(\"Trained LGBM\")\ny_valid_pred_lgbm = np.maximum(model_lgbm.predict(X_valid),0)\nprint(\"Predicted Training LGBM\")\n\nrmsle_lgb, rmse_lgb, mae_lgb, r2_lgb = evaluate_model(np.expm1(y_valid),np.expm1(y_valid_pred_lgbm),\"LightGBMRegression\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# CatBoost Wrapper\nclass CatBoostWrapper(BaseEstimator, RegressorMixin):\n    def __init__(self, iterations=100, learning_rate=0.01, depth=-1, early_stopping_rounds=20, eval_set=None, verbose=0, loss_function=\"RMSE\", eval_metric=\"RMSE\"):\n        self.model = CatBoostRegressor(\n            iterations=iterations,\n            learning_rate=learning_rate,\n            verbose=verbose,\n            depth=depth,\n            early_stopping_rounds=early_stopping_rounds,\n            loss_function=loss_function,\n            eval_metric=eval_metric,\n        )\n        self.eval_set = eval_set\n    \n    def fit(self, X, y):\n        self.model.fit(X, y, eval_set=self.eval_set, use_best_model=True)\n        return self\n\n    def predict(self, X):\n        return self.model.predict(X)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# CatBoost Regressor\nmodel_cat = CatBoostWrapper(\n    iterations=2500,                # Number of trees\n    learning_rate=0.01,             # Learning rate\n    depth=16,                       # Maximum depth of trees\n    early_stopping_rounds=20,\n    verbose=200,                    # Verbose output\n    loss_function='RMSE',           # Use RMSE for regression\n    eval_metric='RMSE',             # RMSE as the evaluation metric\n    eval_set=[(X_valid, y_valid)]\n)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(\"Model: CATBoostRegression\")\nmodel_cat.fit(X_train, y_train)\nprint(\"Trained CAT\")\ny_valid_pred_cat = np.maximum(model_cat.predict(X_valid),0)\nprint(\"Predicted Training CAT\")\n\nrmsle_cat, rmse_cat, mae_cat, r2_cat = evaluate_model(np.expm1(y_valid),np.expm1(y_valid_pred_cat),\"CATBoostRegression\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Custom wrapper for Keras model\nclass KerasRegressorWrapper(BaseEstimator, RegressorMixin):\n    def __init__(self, epochs=100, batch_size=32, validation_data=None, patience=10, input_size=128, loss_function='rmse'):\n        self.epochs = epochs\n        self.batch_size = batch_size\n        self.validation_data = validation_data\n        self.patience = patience\n        self.input_shape = input_size\n        self.loss_function = loss_function\n        self.model = None\n    \n    def build_model(self):\n        # Build a simple Keras model\n        model = Sequential([\n            Input(shape=[self.input_shape]),\n            Dense(128, activation='relu'),\n            BatchNormalization(),\n            Dropout(0.25),\n            Dense(64, activation='relu'),\n            BatchNormalization(),\n            Dropout(0.25),\n            Dense(32, activation='relu'),\n            BatchNormalization(),\n            Dropout(0.25),\n            Dense(16, activation='relu'),\n            BatchNormalization(),\n            Dropout(0.25),\n            Dense(8, activation='relu'),\n            BatchNormalization(),\n            Dropout(0.25),\n            Dense(1)  # Regression output\n        ])\n        model.compile(optimizer=Adam(learning_rate=0.01), loss=self.loss_function)\n        return model\n    \n    def fit(self, X, y):\n        # Build the model\n        self.model = self.build_model()\n\n        # Prepare validation data if provided\n        val_data = self.validation_data if self.validation_data else (X, y)\n\n        # Set up early stopping\n        early_stopping = EarlyStopping(monitor='val_loss', patience=self.patience, restore_best_weights=True)\n\n        # Fit the model\n        self.model.fit(X, y, epochs=self.epochs, batch_size=self.batch_size, validation_data=val_data, callbacks=[early_stopping])\n\n        return self\n    \n    def predict(self, X):\n        # Make predictions with the trained model\n        return self.model.predict(X).flatten()\n    ","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model_ksm = KerasRegressorWrapper(\n    epochs=2500, \n    batch_size=256, \n    validation_data=(X_valid, y_valid), \n    patience=20,\n    loss_function='mean_squared_logarithmic_error',\n    input_size=X_train.shape[1]\n)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(\"Model: KSMRegression\")\nmodel_ksm.fit(X_train, y_train)\nprint(\"Trained KSM\")\ny_valid_pred_ksm = np.maximum(model_ksm.predict(X_valid),0)\nprint(\"Predicted Training KSM\")\n\nrmsle_ksm, rmse_ksm, mae_ksm, r2_ksm = evaluate_model(np.expm1(y_valid),np.expm1(y_valid_pred_ksm),\"KSMRegression\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model_ensemble = VotingRegressor([('LGBM', model_lgbm), ('XGB', model_xgb), ('CAT', model_cat), ('KSM', model_ksm)])","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(\"Model: VotingRegression\")\nmodel_ensemble.fit(X_train, y_train)\nprint(\"Trained VotingRegression\")\ny_valid_pred_ensemble = np.maximum(model_ensemble.predict(X_valid),0)\nprint(\"Predicted Training VotingRegression\")\n\nrmsle_ens, rmse_ens, mae_ens, r2_ens = evaluate_model(np.expm1(y_valid),np.expm1(y_valid_pred_ensemble),\"VotingRegression\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"y_pred_xgb = np.expm1(model_xgb.predict(X_test_preprocessed))\nprint(\"Predicted Test XGB\")\ny_pred_lgb = np.expm1(model_lgbm.predict(X_test_preprocessed))\nprint(\"Predicted Test LGBM\")\ny_pred_cat = np.expm1(model_cat.predict(X_test_preprocessed))\nprint(\"Predicted Test CAT\")\ny_pred_ksm = np.expm1(model_ksm.predict(X_test_preprocessed))\nprint(\"Predicted Test KSM\")\ny_pred_ens = np.expm1(model_ensemble.predict(X_test_prerocessed))\nprint(\"Predicted Test Ensemble\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"submit_xgb = pd.DataFrame({\n    'id': test_id,\n    'Premium Amount': y_pred_xgb.flatten()\n})\n\nsubmit_lgb = pd.DataFrame({\n    'id': test_id,\n    'Premium Amount': y_pred_lgb.flatten()\n})\n\nsubmit_cat = pd.DataFrame({\n    'id': test_id,\n    'Premium Amount': y_pred_cat.flatten()\n})\n\nsubmit_ksm = pd.DataFrame({\n    'id': test_id,\n    'Premium Amount': y_pred_ksm.flatten()\n})\n\nsubmit_ens = pd.DataFrame({\n    'id': test_id,\n    'Premium Amount': y_pred_ens.flatten()\n})\n\nsubmit_xgb.to_csv(\"submission_xgb.csv\", index=False)\nsubmit_lgb.to_csv(\"submission_lgb.csv\", index=False)\nsubmit_cat.to_csv(\"submission_cat.csv\", index=False)\nsubmit_ksm.to_csv(\"submission_ksm.csv\", index=False)\nsubmit_ens.to_csv(\"submission_ens.csv\", index=False)","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}